# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/src/rgw//"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"



# 1 "/usr/include/c++/10/array" 1 3
# 32 "/usr/include/c++/10/array" 3
       
# 33 "/usr/include/c++/10/array" 3





# 1 "/usr/include/c++/10/utility" 1 3
# 58 "/usr/include/c++/10/utility" 3
       
# 59 "/usr/include/c++/10/utility" 3
# 68 "/usr/include/c++/10/utility" 3
# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 1 3


# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 4 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 2 3
# 2353 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 3

# 2353 "/usr/include/c++/10/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;

}
# 2375 "/usr/include/c++/10/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"))) { }
}
# 2542 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{


  extern "C++" inline void
  __replacement_assert(const char* __file, int __line,
         const char* __function, const char* __condition)
  {
    __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line,
       __function, __condition);
    __builtin_abort();
  }
}
# 2613 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 3
# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/os_defines.h" 1 3
# 39 "/usr/include/c++/10/x86_64-redhat-linux/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 465 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 452 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 453 "/usr/include/sys/cdefs.h" 2 3 4
# 1 "/usr/include/bits/long-double.h" 1 3 4
# 454 "/usr/include/sys/cdefs.h" 2 3 4
# 466 "/usr/include/features.h" 2 3 4
# 489 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 3 4
# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/gnu/stubs.h" 2 3 4
# 490 "/usr/include/features.h" 2 3 4
# 40 "/usr/include/c++/10/x86_64-redhat-linux/bits/os_defines.h" 2 3
# 2614 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 2 3


# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
# 2617 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 2 3
# 2783 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 3
# 1 "/usr/include/c++/10/pstl/pstl_config.h" 1 3
# 2784 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++config.h" 2 3
# 69 "/usr/include/c++/10/utility" 2 3
# 1 "/usr/include/c++/10/bits/stl_relops.h" 1 3
# 67 "/usr/include/c++/10/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace rel_ops
  {
# 85 "/usr/include/c++/10/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 98 "/usr/include/c++/10/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 111 "/usr/include/c++/10/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 124 "/usr/include/c++/10/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }
  }


}
# 70 "/usr/include/c++/10/utility" 2 3
# 1 "/usr/include/c++/10/bits/stl_pair.h" 1 3
# 59 "/usr/include/c++/10/bits/stl_pair.h" 3
# 1 "/usr/include/c++/10/bits/move.h" 1 3
# 38 "/usr/include/c++/10/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Tp>
    inline constexpr _Tp*
    __addressof(_Tp& __r) noexcept
    { return __builtin_addressof(__r); }




}

# 1 "/usr/include/c++/10/type_traits" 1 3
# 32 "/usr/include/c++/10/type_traits" 3
       
# 33 "/usr/include/c++/10/type_traits" 3







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

# 56 "/usr/include/c++/10/type_traits" 3
  template<typename _Tp, _Tp __v>
    struct integral_constant
    {
      static constexpr _Tp value = __v;
      typedef _Tp value_type;
      typedef integral_constant<_Tp, __v> type;
      constexpr operator value_type() const noexcept { return value; }




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

    };

  template<typename _Tp, _Tp __v>
    constexpr _Tp integral_constant<_Tp, __v>::value;


  typedef integral_constant<bool, true> true_type;


  typedef integral_constant<bool, false> false_type;

  template<bool __v>
    using __bool_constant = integral_constant<bool, __v>;



  template<bool __v>
    using bool_constant = integral_constant<bool, __v>;




  template<bool, typename, typename>
    struct conditional;

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

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

  template<typename...>
    struct __or_;

  template<>
    struct __or_<>
    : public false_type
    { };

  template<typename _B1>
    struct __or_<_B1>
    : public _B1
    { };

  template<typename _B1, typename _B2>
    struct __or_<_B1, _B2>
    : public conditional<_B1::value, _B1, _B2>::type
    { };

  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
    struct __or_<_B1, _B2, _B3, _Bn...>
    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
    { };

  template<typename...>
    struct __and_;

  template<>
    struct __and_<>
    : public true_type
    { };

  template<typename _B1>
    struct __and_<_B1>
    : public _B1
    { };

  template<typename _B1, typename _B2>
    struct __and_<_B1, _B2>
    : public conditional<_B1::value, _B2, _B1>::type
    { };

  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
    struct __and_<_B1, _B2, _B3, _Bn...>
    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
    { };

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



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



  template<typename... _Bn>
    struct conjunction
    : __and_<_Bn...>
    { };

  template<typename... _Bn>
    struct disjunction
    : __or_<_Bn...>
    { };

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

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

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

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




  template<typename>
    struct is_reference;
  template<typename>
    struct is_function;
  template<typename>
    struct is_void;
  template<typename>
    struct __is_array_unknown_bounds;




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

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






  template<typename _Tp>
    struct __success_type
    { typedef _Tp type; };

  struct __failure_type
  { };

  template<typename>
    struct remove_cv;


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

  template<typename>
    struct is_const;



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

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


  template<typename _Tp>
    struct is_void
    : public __is_void_helper<__remove_cv_t<_Tp>>::type
    { };

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

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

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

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

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


  template<>
    struct __is_integral_helper<wchar_t>
    : public true_type { };
# 284 "/usr/include/c++/10/type_traits" 3
  template<>
    struct __is_integral_helper<char16_t>
    : public true_type { };

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

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

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

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

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

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

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

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

  template<>
    struct __is_integral_helper<unsigned long long>
    : public true_type { };
# 364 "/usr/include/c++/10/type_traits" 3
  template<typename _Tp>
    struct is_integral
    : public __is_integral_helper<__remove_cv_t<_Tp>>::type
    { };

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

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

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

  template<>
    struct __is_floating_point_helper<long double>
    : public true_type { };
# 392 "/usr/include/c++/10/type_traits" 3
  template<typename _Tp>
    struct is_floating_point
    : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
    { };


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

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

  template<typename _Tp>
    struct is_array<_Tp[]>
    : public true_type { };

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

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


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


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

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


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

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

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

  template<typename _Tp, typename _Cp>
    struct __is_member_object_pointer_helper<_Tp _Cp::*>
    : public __not_<is_function<_Tp>>::type { };


  template<typename _Tp>
    struct is_member_object_pointer
    : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type
    { };

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

  template<typename _Tp, typename _Cp>
    struct __is_member_function_pointer_helper<_Tp _Cp::*>
    : public is_function<_Tp>::type { };


  template<typename _Tp>
    struct is_member_function_pointer
    : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type
    { };


  template<typename _Tp>
    struct is_enum
    : public integral_constant<bool, __is_enum(_Tp)>
    { };


  template<typename _Tp>
    struct is_union
    : public integral_constant<bool, __is_union(_Tp)>
    { };


  template<typename _Tp>
    struct is_class
    : public integral_constant<bool, __is_class(_Tp)>
    { };


  template<typename _Tp>
    struct is_function
    : public __bool_constant<!is_const<const _Tp>::value> { };

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

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



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

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


  template<typename _Tp>
    struct is_null_pointer
    : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type
    { };


  template<typename _Tp>
    struct __is_nullptr_t
    : public is_null_pointer<_Tp>
    { } __attribute__ ((__deprecated__));




  template<typename _Tp>
    struct is_reference
    : public __or_<is_lvalue_reference<_Tp>,
                   is_rvalue_reference<_Tp>>::type
    { };


  template<typename _Tp>
    struct is_arithmetic
    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
    { };


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


  template<typename _Tp>
    struct is_object
    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
                          is_void<_Tp>>>::type
    { };

  template<typename>
    struct is_member_pointer;


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


  template<typename _Tp>
    struct is_compound
    : public __not_<is_fundamental<_Tp>>::type { };

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

  template<typename _Tp, typename _Cp>
    struct __is_member_pointer_helper<_Tp _Cp::*>
    : public true_type { };


  template<typename _Tp>
    struct is_member_pointer
    : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type
    { };

  template<typename, typename>
    struct is_same;

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


  template<typename _Tp>
    using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
   signed char, signed short, signed int, signed long,
   signed long long
# 604 "/usr/include/c++/10/type_traits" 3
   >;


  template<typename _Tp>
    using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
   unsigned char, unsigned short, unsigned int, unsigned long,
   unsigned long long
# 623 "/usr/include/c++/10/type_traits" 3
   >;



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



  template<typename _Tp, typename = void>
    struct __is_referenceable
    : public false_type
    { };

  template<typename _Tp>
    struct __is_referenceable<_Tp, __void_t<_Tp&>>
    : public true_type
    { };




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

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


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

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


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


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


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



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


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


  template<typename _Tp>
    struct is_empty
    : public integral_constant<bool, __is_empty(_Tp)>
    { };


  template<typename _Tp>
    struct is_polymorphic
    : public integral_constant<bool, __is_polymorphic(_Tp)>
    { };




  template<typename _Tp>
    struct is_final
    : public integral_constant<bool, __is_final(_Tp)>
    { };



  template<typename _Tp>
    struct is_abstract
    : public integral_constant<bool, __is_abstract(_Tp)>
    { };

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

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


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


  template<typename _Tp>
    struct is_unsigned
    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
    { };
# 766 "/usr/include/c++/10/type_traits" 3
  template<typename _Tp, typename _Up = _Tp&&>
    _Up
    __declval(int);

  template<typename _Tp>
    _Tp
    __declval(long);

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

  template<typename, unsigned = 0>
    struct extent;

  template<typename>
    struct remove_all_extents;

  template<typename _Tp>
    struct __is_array_known_bounds
    : public integral_constant<bool, (extent<_Tp>::value > 0)>
    { };

  template<typename _Tp>
    struct __is_array_unknown_bounds
    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
    { };






  struct __do_is_destructible_impl
  {
    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
      static true_type __test(int);

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

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

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

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

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

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


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





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

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

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

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

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

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

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


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

  template<typename _Tp, typename... _Args>
    struct __is_constructible_impl
    : public __bool_constant<__is_constructible(_Tp, _Args...)>
    { };


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


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_copy_constructible_impl;

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

  template<typename _Tp>
    struct __is_copy_constructible_impl<_Tp, true>
    : public __is_constructible_impl<_Tp, const _Tp&>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_move_constructible_impl;

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

  template<typename _Tp>
    struct __is_move_constructible_impl<_Tp, true>
    : public __is_constructible_impl<_Tp, _Tp&&>
    { };


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

  template<typename _Tp>
    struct __is_nt_default_constructible_atom
    : public integral_constant<bool, noexcept(_Tp())>
    { };

  template<typename _Tp, bool = is_array<_Tp>::value>
    struct __is_nt_default_constructible_impl;

  template<typename _Tp>
    struct __is_nt_default_constructible_impl<_Tp, true>
    : public __and_<__is_array_known_bounds<_Tp>,
      __is_nt_default_constructible_atom<typename
                      remove_all_extents<_Tp>::type>>
    { };

  template<typename _Tp>
    struct __is_nt_default_constructible_impl<_Tp, false>
    : public __is_nt_default_constructible_atom<_Tp>
    { };

  template<typename _Tp>
    using __is_nothrow_default_constructible_impl
      = __and_<__is_constructible_impl<_Tp>,
        __is_nt_default_constructible_impl<_Tp>>;


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

  template<typename _Tp, typename... _Args>
    struct __is_nt_constructible_impl
    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
    { };

  template<typename _Tp, typename _Arg>
    struct __is_nt_constructible_impl<_Tp, _Arg>
    : public integral_constant<bool,
                               noexcept(static_cast<_Tp>(declval<_Arg>()))>
    { };

  template<typename _Tp>
    struct __is_nt_constructible_impl<_Tp>
    : public __is_nothrow_default_constructible_impl<_Tp>
    { };

  template<typename _Tp, typename... _Args>
    struct __is_nothrow_constructible_impl
    : public __and_<__is_constructible_impl<_Tp, _Args...>,
      __is_nt_constructible_impl<_Tp, _Args...>>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_nothrow_copy_constructible_impl;

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

  template<typename _Tp>
    struct __is_nothrow_copy_constructible_impl<_Tp, true>
    : public __is_nothrow_constructible_impl<_Tp, const _Tp&>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_nothrow_move_constructible_impl;

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

  template<typename _Tp>
    struct __is_nothrow_move_constructible_impl<_Tp, true>
    : public __is_nothrow_constructible_impl<_Tp, _Tp&&>
    { };


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


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_copy_assignable_impl;

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

  template<typename _Tp>
    struct __is_copy_assignable_impl<_Tp, true>
    : public __bool_constant<__is_assignable(_Tp&, const _Tp&)>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_move_assignable_impl;

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

  template<typename _Tp>
    struct __is_move_assignable_impl<_Tp, true>
    : public __bool_constant<__is_assignable(_Tp&, _Tp&&)>
    { };


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

  template<typename _Tp, typename _Up>
    struct __is_nt_assignable_impl
    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
    { };

  template<typename _Tp, typename _Up>
    struct __is_nothrow_assignable_impl
    : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
      __is_nt_assignable_impl<_Tp, _Up>>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_nt_copy_assignable_impl;

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

  template<typename _Tp>
    struct __is_nt_copy_assignable_impl<_Tp, true>
    : public __is_nothrow_assignable_impl<_Tp&, const _Tp&>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_nt_move_assignable_impl;

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

  template<typename _Tp>
    struct __is_nt_move_assignable_impl<_Tp, true>
    : public __is_nothrow_assignable_impl<_Tp&, _Tp&&>
    { };


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


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


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

  struct __do_is_implicitly_default_constructible_impl
  {
    template <typename _Tp>
    static void __helper(const _Tp&);

    template <typename _Tp>
    static true_type __test(const _Tp&,
                            decltype(__helper<const _Tp&>({}))* = 0);

    static false_type __test(...);
  };

  template<typename _Tp>
    struct __is_implicitly_default_constructible_impl
    : public __do_is_implicitly_default_constructible_impl
    {
      typedef decltype(__test(declval<_Tp>())) type;
    };

  template<typename _Tp>
    struct __is_implicitly_default_constructible_safe
    : public __is_implicitly_default_constructible_impl<_Tp>::type
    { };

  template <typename _Tp>
    struct __is_implicitly_default_constructible
    : public __and_<__is_constructible_impl<_Tp>,
      __is_implicitly_default_constructible_safe<_Tp>>
    { };

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_trivially_copy_constructible_impl;

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

  template<typename _Tp>
    struct __is_trivially_copy_constructible_impl<_Tp, true>
    : public __and_<__is_copy_constructible_impl<_Tp>,
      integral_constant<bool,
   __is_trivially_constructible(_Tp, const _Tp&)>>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_trivially_move_constructible_impl;

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

  template<typename _Tp>
    struct __is_trivially_move_constructible_impl<_Tp, true>
    : public __and_<__is_move_constructible_impl<_Tp>,
      integral_constant<bool,
   __is_trivially_constructible(_Tp, _Tp&&)>>
    { };


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


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_trivially_copy_assignable_impl;

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

  template<typename _Tp>
    struct __is_trivially_copy_assignable_impl<_Tp, true>
    : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
    { };


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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __is_trivially_move_assignable_impl;

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

  template<typename _Tp>
    struct __is_trivially_move_assignable_impl<_Tp, true>
    : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
    { };


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


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



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





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


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

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

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


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

  template<typename _Tp, unsigned _Uint, std::size_t _Size>
    struct extent<_Tp[_Size], _Uint>
    : public integral_constant<std::size_t,
          _Uint == 0 ? _Size : extent<_Tp,
          _Uint - 1>::value>
    { };

  template<typename _Tp, unsigned _Uint>
    struct extent<_Tp[], _Uint>
    : public integral_constant<std::size_t,
          _Uint == 0 ? 0 : extent<_Tp,
             _Uint - 1>::value>
    { };





  template<typename _Tp, typename _Up>
    struct is_same

    : public integral_constant<bool, __is_same_as(_Tp, _Up)>



    { };
# 1410 "/usr/include/c++/10/type_traits" 3
  template<typename _Base, typename _Derived>
    struct is_base_of
    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
    { };

  template<typename _From, typename _To,
           bool = __or_<is_void<_From>, is_function<_To>,
                        is_array<_To>>::value>
    struct __is_convertible_helper
    {
      typedef typename is_void<_To>::type type;
    };

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

      template<typename _From1, typename _To1,
        typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
 static true_type
 __test(int);

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

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


  template<typename _From, typename _To>
    struct is_convertible
    : public __is_convertible_helper<_From, _To>::type
    { };

  template<typename _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 _ToElementType, typename _FromElementType>
    using __is_array_convertible
      = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;


  template<typename _From, typename _To>
    struct __is_nothrow_convertible
    : public __is_nt_convertible_helper<_From, _To>::type
    { };
# 1507 "/usr/include/c++/10/type_traits" 3
  template<typename _Tp>
    struct remove_const
    { typedef _Tp type; };

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


  template<typename _Tp>
    struct remove_volatile
    { typedef _Tp type; };

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


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

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

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

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


  template<typename _Tp>
    struct add_const
    { typedef _Tp const type; };


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


  template<typename _Tp>
    struct add_cv
    {
      typedef typename
      add_const<typename add_volatile<_Tp>::type>::type type;
    };






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


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


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


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


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


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





  template<typename _Tp>
    struct remove_reference
    { typedef _Tp type; };

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

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

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __add_lvalue_reference_helper
    { typedef _Tp type; };

  template<typename _Tp>
    struct __add_lvalue_reference_helper<_Tp, true>
    { typedef _Tp& type; };


  template<typename _Tp>
    struct add_lvalue_reference
    : public __add_lvalue_reference_helper<_Tp>
    { };

  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
    struct __add_rvalue_reference_helper
    { typedef _Tp type; };

  template<typename _Tp>
    struct __add_rvalue_reference_helper<_Tp, true>
    { typedef _Tp&& type; };


  template<typename _Tp>
    struct add_rvalue_reference
    : public __add_rvalue_reference_helper<_Tp>
    { };



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


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


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





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

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

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

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

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

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

    public:
      typedef typename __match::__type __type;
    };


  template<typename _Tp>
    struct __make_unsigned
    { typedef _Tp __type; };

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

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

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

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

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

  template<>
    struct __make_unsigned<long long>
    { typedef unsigned long long __type; };
# 1729 "/usr/include/c++/10/type_traits" 3
  template<typename _Tp,
    bool _IsInt = is_integral<_Tp>::value,
    bool _IsEnum = is_enum<_Tp>::value>
    class __make_unsigned_selector;

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

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

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

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

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

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

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


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

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

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

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






  template<>
    struct __make_unsigned<wchar_t>
    {
      using __type
 = typename __make_unsigned_selector<wchar_t, false, true>::__type;
    };
# 1805 "/usr/include/c++/10/type_traits" 3
  template<>
    struct __make_unsigned<char16_t>
    {
      using __type
 = typename __make_unsigned_selector<char16_t, false, true>::__type;
    };

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





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


  template<>
    struct make_unsigned<bool>;



  template<typename _Tp>
    struct __make_signed
    { typedef _Tp __type; };

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

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

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

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

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

  template<>
    struct __make_signed<unsigned long long>
    { typedef signed long long __type; };
# 1883 "/usr/include/c++/10/type_traits" 3
  template<typename _Tp,
    bool _IsInt = is_integral<_Tp>::value,
    bool _IsEnum = is_enum<_Tp>::value>
    class __make_signed_selector;

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

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


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

    public:
      typedef typename __make_signed_selector<__unsigned_type>::__type __type;
    };






  template<>
    struct __make_signed<wchar_t>
    {
      using __type
 = typename __make_signed_selector<wchar_t, false, true>::__type;
    };
# 1931 "/usr/include/c++/10/type_traits" 3
  template<>
    struct __make_signed<char16_t>
    {
      using __type
 = typename __make_signed_selector<char16_t, false, true>::__type;
    };

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





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


  template<>
    struct make_signed<bool>;



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


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





  template<typename _Tp>
    struct remove_extent
    { typedef _Tp type; };

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

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


  template<typename _Tp>
    struct remove_all_extents
    { typedef _Tp type; };

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

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



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


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




  template<typename _Tp, typename>
    struct __remove_pointer_helper
    { typedef _Tp type; };

  template<typename _Tp, typename _Up>
    struct __remove_pointer_helper<_Tp, _Up*>
    { typedef _Up type; };


  template<typename _Tp>
    struct remove_pointer
    : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
    { };


  template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
          is_void<_Tp>>::value>
    struct __add_pointer_helper
    { typedef _Tp type; };

  template<typename _Tp>
    struct __add_pointer_helper<_Tp, true>
    { typedef typename remove_reference<_Tp>::type* type; };

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



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


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


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

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

  template <typename _Tp, typename... _Types>
    struct __strictest_alignment<_Tp, _Types...>
    {
      static const size_t _S_alignment =
        alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
 ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
      static const size_t _S_size =
        sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
 ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
    };
# 2105 "/usr/include/c++/10/type_traits" 3
  template <size_t _Len, typename... _Types>
    struct aligned_union
    {
    private:
      static_assert(sizeof...(_Types) != 0, "At least one type is required");

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

      static const size_t alignment_value = __strictest::_S_alignment;

      typedef typename aligned_storage<_S_len, alignment_value>::type type;
    };

  template <size_t _Len, typename... _Types>
    const size_t aligned_union<_Len, _Types...>::alignment_value;



  template<typename _Up,
    bool _IsArray = is_array<_Up>::value,
    bool _IsFunction = is_function<_Up>::value>
    struct __decay_selector;


  template<typename _Up>
    struct __decay_selector<_Up, false, false>
    { typedef __remove_cv_t<_Up> __type; };

  template<typename _Up>
    struct __decay_selector<_Up, true, false>
    { typedef typename remove_extent<_Up>::type* __type; };

  template<typename _Up>
    struct __decay_selector<_Up, false, true>
    { typedef typename add_pointer<_Up>::type __type; };


  template<typename _Tp>
    class decay
    {
      typedef typename remove_reference<_Tp>::type __remove_type;

    public:
      typedef typename __decay_selector<__remove_type>::__type type;
    };


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

  template<typename _Tp>
    class reference_wrapper;


  template<typename _Tp>
    struct __strip_reference_wrapper
    {
      typedef _Tp __type;
    };

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

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




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


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


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

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



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


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


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


  template<typename... _Tp>
    struct common_type;



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



    template<typename _Tp, typename _Up>
      static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
      _S_test(int);
# 2238 "/usr/include/c++/10/type_traits" 3
    template<typename, typename>
      static __failure_type
      _S_test_2(...);

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


  template<>
    struct common_type<>
    { };


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


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


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

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


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


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

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

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


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




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


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

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

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


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

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

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


  template<typename _Signature>
    class result_of;





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


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


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

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

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


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

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

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


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

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

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


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

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

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

  template<typename _MemPtr, typename _Arg>
    struct __result_of_memobj;

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

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

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






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

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

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

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

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


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

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

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


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

  template<typename _Functor, typename... _ArgTypes>
    struct result_of<_Functor(_ArgTypes...)>
    : public __invoke_result<_Functor, _ArgTypes...>
    { };



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

  template <size_t _Len, typename... _Types>
    using aligned_union_t = typename aligned_union<_Len, _Types...>::type;


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


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


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


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


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


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





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



  template<typename _Default, typename _AlwaysVoid,
    template<typename...> class _Op, typename... _Args>
    struct __detector
    {
      using value_t = false_type;
      using type = _Default;
    };


  template<typename _Default, template<typename...> class _Op,
     typename... _Args>
    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
    {
      using value_t = true_type;
      using type = _Op<_Args...>;
    };


  template<typename _Default, template<typename...> class _Op,
    typename... _Args>
    using __detected_or = __detector<_Default, void, _Op, _Args...>;


  template<typename _Default, template<typename...> class _Op,
    typename... _Args>
    using __detected_or_t
      = typename __detected_or<_Default, _Op, _Args...>::type;
# 2623 "/usr/include/c++/10/type_traits" 3
  template <typename _Tp>
    struct __is_swappable;

  template <typename _Tp>
    struct __is_nothrow_swappable;

  template<typename... _Elements>
    class tuple;

  template<typename>
    struct __is_tuple_like_impl : false_type
    { };

  template<typename... _Tps>
    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
    { };


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

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

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

  namespace __swappable_details {
    using std::swap;

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

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

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

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

  }

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

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

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

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






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


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



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


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


  namespace __swappable_with_details {
    using std::swap;

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

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

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

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

  }

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


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

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


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


  template<typename _Tp, typename _Up>
    struct is_swappable_with
    : public __is_swappable_with_impl<_Tp, _Up>::type
    { };


  template<typename _Tp, typename _Up>
    struct is_nothrow_swappable_with
    : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
    { };



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


  template<typename _Tp, typename _Up>
    inline constexpr bool is_nothrow_swappable_with_v =
      is_nothrow_swappable_with<_Tp, _Up>::value;







  template<typename _Result, typename _Ret,
    bool = is_void<_Ret>::value, typename = void>
    struct __is_invocable_impl : false_type { };


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

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

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


      static typename _Result::type _S_get();

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


      template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))>
 static true_type
 _S_test(int);

      template<typename _Tp>
 static false_type
 _S_test(...);

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

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

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

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

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

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

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

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

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


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

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





  template<typename _Functor, typename... _ArgTypes>
    struct invoke_result
    : public __invoke_result<_Functor, _ArgTypes...>
    { };


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


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


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


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

  template<typename _Result, typename _Ret, typename = void>
    struct __is_nt_invocable_impl : false_type { };

  template<typename _Result, typename _Ret>
    struct __is_nt_invocable_impl<_Result, _Ret,
      __void_t<typename _Result::type>>
    : __or_<is_void<_Ret>,
     __is_nothrow_convertible<typename _Result::type, _Ret>>
    { };


  template<typename _Ret, typename _Fn, typename... _ArgTypes>
    struct is_nothrow_invocable_r
    : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
    { };


  template<typename _Fn, typename... _Args>
    inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;


  template<typename _Fn, typename... _Args>
    inline constexpr bool is_nothrow_invocable_v
      = is_nothrow_invocable<_Fn, _Args...>::value;


  template<typename _Ret, typename _Fn, typename... _Args>
    inline constexpr bool is_invocable_r_v
      = is_invocable_r<_Ret, _Fn, _Args...>::value;


  template<typename _Ret, typename _Fn, typename... _Args>
    inline constexpr bool is_nothrow_invocable_r_v
      = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;




template <typename _Tp>
  inline constexpr bool is_void_v = is_void<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_integral_v = is_integral<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_array_v = is_array<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_lvalue_reference_v =
    is_lvalue_reference<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_rvalue_reference_v =
    is_rvalue_reference<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_member_object_pointer_v =
    is_member_object_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_member_function_pointer_v =
    is_member_function_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_enum_v = is_enum<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_union_v = is_union<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_class_v = is_class<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_function_v = is_function<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_reference_v = is_reference<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_object_v = is_object<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_compound_v = is_compound<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_const_v = is_const<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_trivially_copyable_v =
    is_trivially_copyable<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template <typename _Tp>
 
  inline constexpr bool is_pod_v = is_pod<_Tp>::value;
#pragma GCC diagnostic pop
template <typename _Tp>
  inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_empty_v = is_empty<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_abstract_v = is_abstract<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_final_v = is_final<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_signed_v = is_signed<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
template <typename _Tp, typename... _Args>
  inline constexpr bool is_constructible_v =
    is_constructible<_Tp, _Args...>::value;
template <typename _Tp>
  inline constexpr bool is_default_constructible_v =
    is_default_constructible<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_copy_constructible_v =
    is_copy_constructible<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_move_constructible_v =
    is_move_constructible<_Tp>::value;
template <typename _Tp, typename _Up>
  inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value;
template <typename _Tp>
  inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
template <typename _Tp, typename... _Args>
  inline constexpr bool is_trivially_constructible_v =
    is_trivially_constructible<_Tp, _Args...>::value;
template <typename _Tp>
  inline constexpr bool is_trivially_default_constructible_v =
    is_trivially_default_constructible<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_trivially_copy_constructible_v =
    is_trivially_copy_constructible<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_trivially_move_constructible_v =
    is_trivially_move_constructible<_Tp>::value;
template <typename _Tp, typename _Up>
  inline constexpr bool is_trivially_assignable_v =
    is_trivially_assignable<_Tp, _Up>::value;
template <typename _Tp>
  inline constexpr bool is_trivially_copy_assignable_v =
    is_trivially_copy_assignable<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_trivially_move_assignable_v =
    is_trivially_move_assignable<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_trivially_destructible_v =
    is_trivially_destructible<_Tp>::value;
template <typename _Tp, typename... _Args>
  inline constexpr bool is_nothrow_constructible_v =
    is_nothrow_constructible<_Tp, _Args...>::value;
template <typename _Tp>
  inline constexpr bool is_nothrow_default_constructible_v =
    is_nothrow_default_constructible<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_nothrow_copy_constructible_v =
    is_nothrow_copy_constructible<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_nothrow_move_constructible_v =
    is_nothrow_move_constructible<_Tp>::value;
template <typename _Tp, typename _Up>
  inline constexpr bool is_nothrow_assignable_v =
    is_nothrow_assignable<_Tp, _Up>::value;
template <typename _Tp>
  inline constexpr bool is_nothrow_copy_assignable_v =
    is_nothrow_copy_assignable<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_nothrow_move_assignable_v =
    is_nothrow_move_assignable<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_nothrow_destructible_v =
    is_nothrow_destructible<_Tp>::value;
template <typename _Tp>
  inline constexpr bool has_virtual_destructor_v =
    has_virtual_destructor<_Tp>::value;
template <typename _Tp>
  inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
template <typename _Tp>
  inline constexpr size_t rank_v = rank<_Tp>::value;
template <typename _Tp, unsigned _Idx = 0>
  inline constexpr size_t extent_v = extent<_Tp, _Idx>::value;

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




template <typename _Base, typename _Derived>
  inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
template <typename _From, typename _To>
  inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;




  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<_Tp>::value;
# 3449 "/usr/include/c++/10/type_traits" 3

}
# 58 "/usr/include/c++/10/bits/move.h" 2 3

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

# 74 "/usr/include/c++/10/bits/move.h" 3
  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }







  template<typename _Tp>
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
      " substituting _Tp is an lvalue reference type");
      return static_cast<_Tp&&>(__t);
    }






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


  template<typename _Tp>
    struct __move_if_noexcept_cond
    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
                    is_copy_constructible<_Tp>>::type { };
# 118 "/usr/include/c++/10/bits/move.h" 3
  template<typename _Tp>
    constexpr typename
    conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
    move_if_noexcept(_Tp& __x) noexcept
    { return std::move(__x); }
# 138 "/usr/include/c++/10/bits/move.h" 3
  template<typename _Tp>
    inline constexpr _Tp*
    addressof(_Tp& __r) noexcept
    { return std::__addressof(__r); }



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


  template <typename _Tp, typename _Up = _Tp>
   
    inline _Tp
    __exchange(_Tp& __obj, _Up&& __new_val)
    {
      _Tp __old_val = std::move(__obj);
      __obj = std::forward<_Up>(__new_val);
      return __old_val;
    }
# 179 "/usr/include/c++/10/bits/move.h" 3
  template<typename _Tp>
   
    inline

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



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

    {




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




  template<typename _Tp, size_t _Nm>
   
    inline

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



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



}
# 60 "/usr/include/c++/10/bits/stl_pair.h" 2 3
# 68 "/usr/include/c++/10/bits/stl_pair.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 79 "/usr/include/c++/10/bits/stl_pair.h" 3
  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };


  inline constexpr piecewise_construct_t piecewise_construct =
    piecewise_construct_t();




  template<typename...>
    class tuple;

  template<std::size_t...>
    struct _Index_tuple;






  template <bool, typename _T1, typename _T2>
    struct _PCC
    {
      template <typename _U1, typename _U2>
      static constexpr bool _ConstructiblePair()
      {
 return __and_<is_constructible<_T1, const _U1&>,
        is_constructible<_T2, const _U2&>>::value;
      }

      template <typename _U1, typename _U2>
      static constexpr bool _ImplicitlyConvertiblePair()
      {
 return __and_<is_convertible<const _U1&, _T1>,
        is_convertible<const _U2&, _T2>>::value;
      }

      template <typename _U1, typename _U2>
      static constexpr bool _MoveConstructiblePair()
      {
 return __and_<is_constructible<_T1, _U1&&>,
        is_constructible<_T2, _U2&&>>::value;
      }

      template <typename _U1, typename _U2>
      static constexpr bool _ImplicitlyMoveConvertiblePair()
      {
 return __and_<is_convertible<_U1&&, _T1>,
        is_convertible<_U2&&, _T2>>::value;
      }

      template <bool __implicit, typename _U1, typename _U2>
      static constexpr bool _CopyMovePair()
      {
 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
      is_convertible<_U2&&, _T2>>;
 using __converts = typename conditional<__implicit,
           __do_converts,
           __not_<__do_converts>>::type;
 return __and_<is_constructible<_T1, const _U1&>,
        is_constructible<_T2, _U2&&>,
        __converts
        >::value;
      }

      template <bool __implicit, typename _U1, typename _U2>
      static constexpr bool _MoveCopyPair()
      {
 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
      is_convertible<const _U2&, _T2>>;
 using __converts = typename conditional<__implicit,
           __do_converts,
           __not_<__do_converts>>::type;
 return __and_<is_constructible<_T1, _U1&&>,
        is_constructible<_T2, const _U2&&>,
        __converts
        >::value;
      }
  };

  template <typename _T1, typename _T2>
    struct _PCC<false, _T1, _T2>
    {
      template <typename _U1, typename _U2>
      static constexpr bool _ConstructiblePair()
      {
 return false;
      }

      template <typename _U1, typename _U2>
      static constexpr bool _ImplicitlyConvertiblePair()
      {
 return false;
      }

      template <typename _U1, typename _U2>
      static constexpr bool _MoveConstructiblePair()
      {
 return false;
      }

      template <typename _U1, typename _U2>
      static constexpr bool _ImplicitlyMoveConvertiblePair()
      {
 return false;
      }
  };


  template<typename _U1, typename _U2> class __pair_base
  {

    template<typename _T1, typename _T2> friend struct pair;
    __pair_base() = default;
    ~__pair_base() = default;
    __pair_base(const __pair_base&) = default;
    __pair_base& operator=(const __pair_base&) = delete;

  };
# 209 "/usr/include/c++/10/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    struct pair
    : private __pair_base<_T1, _T2>
    {
      typedef _T1 first_type;
      typedef _T2 second_type;

      _T1 first;
      _T2 second;






      template <typename _U1 = _T1,
                typename _U2 = _T2,
                typename enable_if<__and_<
                                     __is_implicitly_default_constructible<_U1>,
                                     __is_implicitly_default_constructible<_U2>>
                                   ::value, bool>::type = true>

      constexpr pair()
      : first(), second() { }


      template <typename _U1 = _T1,
                typename _U2 = _T2,
                typename enable_if<__and_<
                       is_default_constructible<_U1>,
                       is_default_constructible<_U2>,
                       __not_<
                         __and_<__is_implicitly_default_constructible<_U1>,
                                __is_implicitly_default_constructible<_U2>>>>
                                   ::value, bool>::type = false>
      explicit constexpr pair()
      : first(), second() { }
# 255 "/usr/include/c++/10/bits/stl_pair.h" 3
      using _PCCP = _PCC<true, _T1, _T2>;



      template<typename _U1 = _T1, typename _U2=_T2, typename
        enable_if<_PCCP::template
      _ConstructiblePair<_U1, _U2>()
                  && _PCCP::template
      _ImplicitlyConvertiblePair<_U1, _U2>(),
                         bool>::type=true>
      constexpr pair(const _T1& __a, const _T2& __b)
      : first(__a), second(__b) { }


       template<typename _U1 = _T1, typename _U2=_T2, typename
  enable_if<_PCCP::template
       _ConstructiblePair<_U1, _U2>()
                   && !_PCCP::template
       _ImplicitlyConvertiblePair<_U1, _U2>(),
                         bool>::type=false>
      explicit constexpr pair(const _T1& __a, const _T2& __b)
      : first(__a), second(__b) { }
# 287 "/usr/include/c++/10/bits/stl_pair.h" 3
      template <typename _U1, typename _U2>
        using _PCCFP = _PCC<!is_same<_T1, _U1>::value
       || !is_same<_T2, _U2>::value,
       _T1, _T2>;


      template<typename _U1, typename _U2, typename
        enable_if<_PCCFP<_U1, _U2>::template
      _ConstructiblePair<_U1, _U2>()
                  && _PCCFP<_U1, _U2>::template
      _ImplicitlyConvertiblePair<_U1, _U2>(),
     bool>::type=true>
        constexpr pair(const pair<_U1, _U2>& __p)
        : first(__p.first), second(__p.second) { }

      template<typename _U1, typename _U2, typename
        enable_if<_PCCFP<_U1, _U2>::template
      _ConstructiblePair<_U1, _U2>()
    && !_PCCFP<_U1, _U2>::template
      _ImplicitlyConvertiblePair<_U1, _U2>(),
                         bool>::type=false>
 explicit constexpr pair(const pair<_U1, _U2>& __p)
 : first(__p.first), second(__p.second) { }



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


      template<typename _U1, typename
        enable_if<_PCCP::template
      _MoveCopyPair<true, _U1, _T2>(),
                         bool>::type=true>
       constexpr pair(_U1&& __x, const _T2& __y)
       : first(std::forward<_U1>(__x)), second(__y) { }

      template<typename _U1, typename
        enable_if<_PCCP::template
      _MoveCopyPair<false, _U1, _T2>(),
                         bool>::type=false>
       explicit constexpr pair(_U1&& __x, const _T2& __y)
       : first(std::forward<_U1>(__x)), second(__y) { }

      template<typename _U2, typename
        enable_if<_PCCP::template
      _CopyMovePair<true, _T1, _U2>(),
                         bool>::type=true>
       constexpr pair(const _T1& __x, _U2&& __y)
       : first(__x), second(std::forward<_U2>(__y)) { }

      template<typename _U2, typename
        enable_if<_PCCP::template
      _CopyMovePair<false, _T1, _U2>(),
                         bool>::type=false>
       explicit pair(const _T1& __x, _U2&& __y)
       : first(__x), second(std::forward<_U2>(__y)) { }

      template<typename _U1, typename _U2, typename
        enable_if<_PCCP::template
      _MoveConstructiblePair<_U1, _U2>()
     && _PCCP::template
      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                         bool>::type=true>
 constexpr pair(_U1&& __x, _U2&& __y)
 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }

      template<typename _U1, typename _U2, typename
        enable_if<_PCCP::template
      _MoveConstructiblePair<_U1, _U2>()
     && !_PCCP::template
      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                         bool>::type=false>
 explicit constexpr pair(_U1&& __x, _U2&& __y)
 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }


      template<typename _U1, typename _U2, typename
        enable_if<_PCCFP<_U1, _U2>::template
      _MoveConstructiblePair<_U1, _U2>()
     && _PCCFP<_U1, _U2>::template
      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                         bool>::type=true>
 constexpr pair(pair<_U1, _U2>&& __p)
 : first(std::forward<_U1>(__p.first)),
   second(std::forward<_U2>(__p.second)) { }

      template<typename _U1, typename _U2, typename
        enable_if<_PCCFP<_U1, _U2>::template
      _MoveConstructiblePair<_U1, _U2>()
     && !_PCCFP<_U1, _U2>::template
      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
                         bool>::type=false>
 explicit constexpr pair(pair<_U1, _U2>&& __p)
 : first(std::forward<_U1>(__p.first)),
   second(std::forward<_U2>(__p.second)) { }

      template<typename... _Args1, typename... _Args2>

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

      pair&
      operator=(typename conditional<
  __and_<is_copy_assignable<_T1>,
         is_copy_assignable<_T2>>::value,
  const pair&, const __nonesuch&>::type __p)
      {
 first = __p.first;
 second = __p.second;
 return *this;
      }

      pair&
      operator=(typename conditional<
  __and_<is_move_assignable<_T1>,
         is_move_assignable<_T2>>::value,
  pair&&, __nonesuch&&>::type __p)
      noexcept(__and_<is_nothrow_move_assignable<_T1>,
        is_nothrow_move_assignable<_T2>>::value)
      {
 first = std::forward<first_type>(__p.first);
 second = std::forward<second_type>(__p.second);
 return *this;
      }

      template<typename _U1, typename _U2>

 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
      is_assignable<_T2&, const _U2&>>::value,
      pair&>::type
 operator=(const pair<_U1, _U2>& __p)
 {
   first = __p.first;
   second = __p.second;
   return *this;
 }

      template<typename _U1, typename _U2>

 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
      is_assignable<_T2&, _U2&&>>::value,
      pair&>::type
 operator=(pair<_U1, _U2>&& __p)
 {
   first = std::forward<_U1>(__p.first);
   second = std::forward<_U2>(__p.second);
   return *this;
 }


      void
      swap(pair& __p)
      noexcept(__and_<__is_nothrow_swappable<_T1>,
                      __is_nothrow_swappable<_T2>>::value)
      {
 using std::swap;
 swap(first, __p.first);
 swap(second, __p.second);
      }

    private:
      template<typename... _Args1, std::size_t... _Indexes1,
               typename... _Args2, std::size_t... _Indexes2>

        pair(tuple<_Args1...>&, tuple<_Args2...>&,
             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);

    };




  template<typename _T1, typename _T2> pair(_T1, _T2) -> pair<_T1, _T2>;



  template<typename _T1, typename _T2>
    inline constexpr bool
    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first == __y.first && __x.second == __y.second; }
# 486 "/usr/include/c++/10/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    inline constexpr bool
    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first < __y.first
      || (!(__y.first < __x.first) && __x.second < __y.second); }


  template<typename _T1, typename _T2>
    inline constexpr bool
    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x == __y); }


  template<typename _T1, typename _T2>
    inline constexpr bool
    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __y < __x; }


  template<typename _T1, typename _T2>
    inline constexpr bool
    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__y < __x); }


  template<typename _T1, typename _T2>
    inline constexpr bool
    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x < __y); }
# 523 "/usr/include/c++/10/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    inline


    typename enable_if<__and_<__is_swappable<_T1>,
                              __is_swappable<_T2>>::value>::type



    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }


  template<typename _T1, typename _T2>
    typename enable_if<!__and_<__is_swappable<_T1>,
          __is_swappable<_T2>>::value>::type
    swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
# 563 "/usr/include/c++/10/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));
    }
# 582 "/usr/include/c++/10/bits/stl_pair.h" 3

}
# 71 "/usr/include/c++/10/utility" 2 3





# 1 "/usr/include/c++/10/initializer_list" 1 3
# 33 "/usr/include/c++/10/initializer_list" 3
       
# 34 "/usr/include/c++/10/initializer_list" 3





#pragma GCC visibility push(default)



namespace std
{

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

    private:
      iterator _M_array;
      size_type _M_len;


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

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


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


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


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







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







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

#pragma GCC visibility pop
# 77 "/usr/include/c++/10/utility" 2 3

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



  template<typename _Tp>
    struct tuple_size;





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

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

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

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


  template<std::size_t __i, typename _Tp>
    struct tuple_element;


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

  template<std::size_t __i, typename _Tp>
    struct tuple_element<__i, const _Tp>
    {
      typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
    };

  template<std::size_t __i, typename _Tp>
    struct tuple_element<__i, volatile _Tp>
    {
      typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
    };

  template<std::size_t __i, typename _Tp>
    struct tuple_element<__i, const volatile _Tp>
    {
      typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
    };







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





  template<typename _T1, typename _T2>
    struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
    { };


  template<class _Tp1, class _Tp2>
    struct tuple_size<std::pair<_Tp1, _Tp2>>
    : public integral_constant<std::size_t, 2> { };


  template<class _Tp1, class _Tp2>
    struct tuple_element<0, std::pair<_Tp1, _Tp2>>
    { typedef _Tp1 type; };


  template<class _Tp1, class _Tp2>
    struct tuple_element<1, std::pair<_Tp1, _Tp2>>
    { typedef _Tp2 type; };

  template<std::size_t _Int>
    struct __pair_get;

  template<>
    struct __pair_get<0>
    {
      template<typename _Tp1, typename _Tp2>
        static constexpr _Tp1&
        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
        { return __pair.first; }

      template<typename _Tp1, typename _Tp2>
        static constexpr _Tp1&&
        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
        { return std::forward<_Tp1>(__pair.first); }

      template<typename _Tp1, typename _Tp2>
        static constexpr const _Tp1&
        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
        { return __pair.first; }

      template<typename _Tp1, typename _Tp2>
        static constexpr const _Tp1&&
        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
        { return std::forward<const _Tp1>(__pair.first); }
    };

  template<>
    struct __pair_get<1>
    {
      template<typename _Tp1, typename _Tp2>
        static constexpr _Tp2&
        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
        { return __pair.second; }

      template<typename _Tp1, typename _Tp2>
        static constexpr _Tp2&&
        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
        { return std::forward<_Tp2>(__pair.second); }

      template<typename _Tp1, typename _Tp2>
        static constexpr const _Tp2&
        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
        { return __pair.second; }

      template<typename _Tp1, typename _Tp2>
        static constexpr const _Tp2&&
        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
        { return std::forward<const _Tp2>(__pair.second); }
    };

  template<std::size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
    get(std::pair<_Tp1, _Tp2>& __in) noexcept
    { return __pair_get<_Int>::__get(__in); }

  template<std::size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
    get(std::pair<_Tp1, _Tp2>&& __in) noexcept
    { return __pair_get<_Int>::__move_get(std::move(__in)); }

  template<std::size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
    get(const std::pair<_Tp1, _Tp2>& __in) noexcept
    { return __pair_get<_Int>::__const_get(__in); }

  template<std::size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
    get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
    { return __pair_get<_Int>::__const_move_get(std::move(__in)); }





  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); }
# 288 "/usr/include/c++/10/utility" 3
  template <typename _Tp, typename _Up = _Tp>
   
    inline _Tp
    exchange(_Tp& __obj, _Up&& __new_val)
    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }





  template<size_t... _Indexes> struct _Index_tuple { };
# 307 "/usr/include/c++/10/utility" 3
  template<size_t _Num>
    struct _Build_index_tuple
    {






      using __type = _Index_tuple<__integer_pack(_Num)...>;

    };






  template<typename _Tp, _Tp... _Idx>
    struct integer_sequence
    {
      typedef _Tp value_type;
      static constexpr size_t size() noexcept { return sizeof...(_Idx); }
    };


  template<typename _Tp, _Tp _Num>
    using make_integer_sequence



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





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


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


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




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

  inline constexpr in_place_t in_place{};

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

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

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

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

  template<typename>
    struct __is_in_place_type_impl : false_type
    { };

  template<typename _Tp>
    struct __is_in_place_type_impl<in_place_type_t<_Tp>> : true_type
    { };

  template<typename _Tp>
    struct __is_in_place_type
      : public __is_in_place_type_impl<_Tp>
    { };


  template<typename _Tp>
    constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }

  template<typename _Tp>
    void as_const(const _Tp&&) = delete;




}
# 39 "/usr/include/c++/10/array" 2 3
# 1 "/usr/include/c++/10/bits/functexcept.h" 1 3
# 40 "/usr/include/c++/10/bits/functexcept.h" 3
# 1 "/usr/include/c++/10/bits/exception_defines.h" 1 3
# 41 "/usr/include/c++/10/bits/functexcept.h" 2 3

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



  void
  __throw_bad_exception(void) __attribute__((__noreturn__));


  void
  __throw_bad_alloc(void) __attribute__((__noreturn__));


  void
  __throw_bad_cast(void) __attribute__((__noreturn__));

  void
  __throw_bad_typeid(void) __attribute__((__noreturn__));


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

  void
  __throw_domain_error(const char*) __attribute__((__noreturn__));

  void
  __throw_invalid_argument(const char*) __attribute__((__noreturn__));

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

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

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

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

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

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

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


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

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


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


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


  void
  __throw_bad_function_call() __attribute__((__noreturn__));


}
# 40 "/usr/include/c++/10/array" 2 3
# 1 "/usr/include/c++/10/bits/stl_algobase.h" 1 3
# 61 "/usr/include/c++/10/bits/stl_algobase.h" 3
# 1 "/usr/include/c++/10/bits/cpp_type_traits.h" 1 3
# 35 "/usr/include/c++/10/bits/cpp_type_traits.h" 3
       
# 36 "/usr/include/c++/10/bits/cpp_type_traits.h" 3
# 67 "/usr/include/c++/10/bits/cpp_type_traits.h" 3
extern "C++" {

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


  struct __true_type { };
  struct __false_type { };

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

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



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


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

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


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

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




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





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

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

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

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


  template<>
    struct __is_integer<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 184 "/usr/include/c++/10/bits/cpp_type_traits.h" 3
  template<>
    struct __is_integer<char16_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

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


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

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

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

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

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

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

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

  template<>
    struct __is_integer<unsigned long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 287 "/usr/include/c++/10/bits/cpp_type_traits.h" 3
  template<typename _Tp>
    struct __is_floating
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };


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

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

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




  template<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;
    };
# 426 "/usr/include/c++/10/bits/cpp_type_traits.h" 3
  template<typename _Tp>
    struct __is_move_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };



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


}
}
# 62 "/usr/include/c++/10/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/10/ext/type_traits.h" 1 3
# 32 "/usr/include/c++/10/ext/type_traits.h" 3
       
# 33 "/usr/include/c++/10/ext/type_traits.h" 3




extern "C++" {

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



  template<bool, typename>
    struct __enable_if
    { };

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



  template<bool _Cond, typename _Iftrue, typename _Iffalse>
    struct __conditional_type
    { typedef _Iftrue __type; };

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



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

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

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

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

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

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

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

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


  template<>
    struct __add_unsigned<bool>;

  template<>
    struct __add_unsigned<wchar_t>;



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

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

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

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

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

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

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

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


  template<>
    struct __remove_unsigned<bool>;

  template<>
    struct __remove_unsigned<wchar_t>;



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

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


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



  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
    struct __promote
    { typedef double __type; };




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

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

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

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

  template<typename _Tp, typename _Up,
           typename _Tp2 = typename __promote<_Tp>::__type,
           typename _Up2 = typename __promote<_Up>::__type>
    struct __promote_2
    {
      typedef __typeof__(_Tp2() + _Up2()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp,
           typename _Tp2 = typename __promote<_Tp>::__type,
           typename _Up2 = typename __promote<_Up>::__type,
           typename _Vp2 = typename __promote<_Vp>::__type>
    struct __promote_3
    {
      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
           typename _Tp2 = typename __promote<_Tp>::__type,
           typename _Up2 = typename __promote<_Up>::__type,
           typename _Vp2 = typename __promote<_Vp>::__type,
           typename _Wp2 = typename __promote<_Wp>::__type>
    struct __promote_4
    {
      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
    };


}
}
# 63 "/usr/include/c++/10/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/10/ext/numeric_traits.h" 1 3
# 32 "/usr/include/c++/10/ext/numeric_traits.h" 3
       
# 33 "/usr/include/c++/10/ext/numeric_traits.h" 3




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

# 54 "/usr/include/c++/10/ext/numeric_traits.h" 3
  template<typename _Value>
    struct __numeric_traits_integer
    {

      static const _Value __min = (((_Value)(-1) < 0) ? -(((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0) - 1 : (_Value)0);
      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);



      static const bool __is_signed = ((_Value)(-1) < 0);
      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
    };

  template<typename _Value>
    const _Value __numeric_traits_integer<_Value>::__min;

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

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

  template<typename _Value>
    const int __numeric_traits_integer<_Value>::__digits;
# 99 "/usr/include/c++/10/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 __conditional_type<std::__is_integer<_Value>::__value,
    __numeric_traits_integer<_Value>,
    __numeric_traits_floating<_Value> >::__type
    { };


}
# 64 "/usr/include/c++/10/bits/stl_algobase.h" 2 3

# 1 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 1 3
# 62 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3
       
# 63 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3
# 74 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 93 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3
  struct input_iterator_tag { };


  struct output_iterator_tag { };


  struct forward_iterator_tag : public input_iterator_tag { };



  struct bidirectional_iterator_tag : public forward_iterator_tag { };



  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
# 125 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3
  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
           typename _Pointer = _Tp*, typename _Reference = _Tp&>
    struct iterator
    {

      typedef _Category iterator_category;

      typedef _Tp value_type;

      typedef _Distance difference_type;

      typedef _Pointer pointer;

      typedef _Reference reference;
    };
# 149 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3
  template<typename _Iterator>
    struct iterator_traits;




  template<typename _Iterator, typename = __void_t<>>
    struct __iterator_traits { };



  template<typename _Iterator>
    struct __iterator_traits<_Iterator,
        __void_t<typename _Iterator::iterator_category,
          typename _Iterator::value_type,
          typename _Iterator::difference_type,
          typename _Iterator::pointer,
          typename _Iterator::reference>>
    {
      typedef typename _Iterator::iterator_category iterator_category;
      typedef typename _Iterator::value_type value_type;
      typedef typename _Iterator::difference_type difference_type;
      typedef typename _Iterator::pointer pointer;
      typedef typename _Iterator::reference reference;
    };


  template<typename _Iterator>
    struct iterator_traits
    : public __iterator_traits<_Iterator> { };
# 209 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3
  template<typename _Tp>
    struct iterator_traits<_Tp*>
    {
      typedef random_access_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef ptrdiff_t difference_type;
      typedef _Tp* pointer;
      typedef _Tp& reference;
    };


  template<typename _Tp>
    struct iterator_traits<const _Tp*>
    {
      typedef random_access_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef ptrdiff_t difference_type;
      typedef const _Tp* pointer;
      typedef const _Tp& reference;
    };






  template<typename _Iter>
    inline constexpr
    typename iterator_traits<_Iter>::iterator_category
    __iterator_category(const _Iter&)
    { return typename iterator_traits<_Iter>::iterator_category(); }




  template<typename _Iter>
    using __iterator_category_t
      = typename iterator_traits<_Iter>::iterator_category;

  template<typename _InIter>
    using _RequireInputIter =
      __enable_if_t<is_convertible<__iterator_category_t<_InIter>,
       input_iterator_tag>::value>;

  template<typename _It,
    typename _Cat = __iterator_category_t<_It>>
    struct __is_random_access_iter
      : is_base_of<random_access_iterator_tag, _Cat>
    {
      typedef is_base_of<random_access_iterator_tag, _Cat> _Base;
      enum { __value = _Base::value };
    };








}
# 66 "/usr/include/c++/10/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 1 3
# 62 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3
       
# 63 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3

# 1 "/usr/include/c++/10/bits/concept_check.h" 1 3
# 33 "/usr/include/c++/10/bits/concept_check.h" 3
       
# 34 "/usr/include/c++/10/bits/concept_check.h" 3
# 65 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 2 3
# 1 "/usr/include/c++/10/debug/assertions.h" 1 3
# 66 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 2 3

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




  template <typename> struct _List_iterator;
  template <typename> struct _List_const_iterator;


  template<typename _InputIterator>
    inline constexpr
    typename iterator_traits<_InputIterator>::difference_type
    __distance(_InputIterator __first, _InputIterator __last,
               input_iterator_tag)
    {

     

      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      while (__first != __last)
 {
   ++__first;
   ++__n;
 }
      return __n;
    }

  template<typename _RandomAccessIterator>
    inline constexpr
    typename iterator_traits<_RandomAccessIterator>::difference_type
    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
               random_access_iterator_tag)
    {

     

      return __last - __first;
    }



  template<typename _Tp>
    ptrdiff_t
    __distance(std::_List_iterator<_Tp>,
        std::_List_iterator<_Tp>,
        input_iterator_tag);

  template<typename _Tp>
    ptrdiff_t
    __distance(std::_List_const_iterator<_Tp>,
        std::_List_const_iterator<_Tp>,
        input_iterator_tag);
# 135 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator>
    inline constexpr
    typename iterator_traits<_InputIterator>::difference_type
    distance(_InputIterator __first, _InputIterator __last)
    {

      return std::__distance(__first, __last,
        std::__iterator_category(__first));
    }

  template<typename _InputIterator, typename _Distance>
    inline constexpr void
    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
    {

     
      do { if (! (__n >= 0)) std::__replacement_assert("/usr/include/c++/10/bits/stl_iterator_base_funcs.h", 151, __PRETTY_FUNCTION__, "__n >= 0"); } 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;
    }
# 200 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    inline constexpr void
    advance(_InputIterator& __i, _Distance __n)
    {

      typename iterator_traits<_InputIterator>::difference_type __d = __n;
      std::__advance(__i, __d, std::__iterator_category(__i));
    }



  template<typename _InputIterator>
    inline constexpr _InputIterator
    next(_InputIterator __x, typename
  iterator_traits<_InputIterator>::difference_type __n = 1)
    {

     
      std::advance(__x, __n);
      return __x;
    }

  template<typename _BidirectionalIterator>
    inline constexpr _BidirectionalIterator
    prev(_BidirectionalIterator __x, typename
  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
    {

     

      std::advance(__x, -__n);
      return __x;
    }




}
# 67 "/usr/include/c++/10/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/10/bits/stl_iterator.h" 1 3
# 66 "/usr/include/c++/10/bits/stl_iterator.h" 3
# 1 "/usr/include/c++/10/bits/ptr_traits.h" 1 3
# 37 "/usr/include/c++/10/bits/ptr_traits.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  class __undefined;


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

  template<template<typename, typename...> class _Template, typename _Tp,
           typename... _Types>
    struct __get_first_arg<_Template<_Tp, _Types...>>
    { using type = _Tp; };

  template<typename _Tp>
    using __get_first_arg_t = typename __get_first_arg<_Tp>::type;


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

  template<template<typename, typename...> class _Template, typename _Up,
           typename _Tp, typename... _Types>
    struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
    { using type = _Template<_Up, _Types...>; };

  template<typename _Tp, typename _Up>
    using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;

  template<typename _Tp>
    using __make_not_void
      = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;





  template<typename _Ptr>
    struct pointer_traits
    {
    private:
      template<typename _Tp>
 using __element_type = typename _Tp::element_type;

      template<typename _Tp>
 using __difference_type = typename _Tp::difference_type;

      template<typename _Tp, typename _Up, typename = void>
 struct __rebind : __replace_first_arg<_Tp, _Up> { };

      template<typename _Tp, typename _Up>
 struct __rebind<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>>>
 { using type = typename _Tp::template rebind<_Up>; };

    public:

      using pointer = _Ptr;


      using element_type
 = __detected_or_t<__get_first_arg_t<_Ptr>, __element_type, _Ptr>;


      using difference_type
 = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;


      template<typename _Up>
        using rebind = typename __rebind<_Ptr, _Up>::type;

      static _Ptr
      pointer_to(__make_not_void<element_type>& __e)
      { return _Ptr::pointer_to(__e); }

      static_assert(!is_same<element_type, __undefined>::value,
   "pointer type defines element_type or is like SomePointer<T, Args>");
    };





  template<typename _Tp>
    struct pointer_traits<_Tp*>
    {

      typedef _Tp* pointer;

      typedef _Tp element_type;

      typedef ptrdiff_t difference_type;

      template<typename _Up>
        using rebind = _Up*;






      static pointer
      pointer_to(__make_not_void<element_type>& __r) noexcept
      { return std::addressof(__r); }
    };


  template<typename _Ptr, typename _Tp>
    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;

  template<typename _Tp>
    constexpr _Tp*
    __to_address(_Tp* __ptr) noexcept
    {
      static_assert(!std::is_function<_Tp>::value, "not a function pointer");
      return __ptr;
    }


  template<typename _Ptr>
    constexpr typename std::pointer_traits<_Ptr>::element_type*
    __to_address(const _Ptr& __ptr)
    { return std::__to_address(__ptr.operator->()); }
# 198 "/usr/include/c++/10/bits/ptr_traits.h" 3

}
# 67 "/usr/include/c++/10/bits/stl_iterator.h" 2 3
# 81 "/usr/include/c++/10/bits/stl_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 109 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class reverse_iterator
    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
        typename iterator_traits<_Iterator>::value_type,
        typename iterator_traits<_Iterator>::difference_type,
        typename iterator_traits<_Iterator>::pointer,
                      typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator current;

      typedef iterator_traits<_Iterator> __traits_type;

    public:
      typedef _Iterator iterator_type;
      typedef typename __traits_type::difference_type difference_type;
      typedef typename __traits_type::pointer pointer;
      typedef typename __traits_type::reference reference;
# 135 "/usr/include/c++/10/bits/stl_iterator.h" 3
      constexpr
      reverse_iterator() : current() { }




      explicit constexpr
      reverse_iterator(iterator_type __x) : current(__x) { }




      constexpr
      reverse_iterator(const reverse_iterator& __x)
      : current(__x.current) { }


      reverse_iterator& operator=(const reverse_iterator&) = default;






      template<typename _Iter>
 constexpr
        reverse_iterator(const reverse_iterator<_Iter>& __x)
 : current(__x.base()) { }




      constexpr iterator_type
      base() const
      { return current; }
# 181 "/usr/include/c++/10/bits/stl_iterator.h" 3
      constexpr reference
      operator*() const
      {
 _Iterator __tmp = current;
 return *--__tmp;
      }






      constexpr pointer
      operator->() const




      {


 _Iterator __tmp = current;
 --__tmp;
 return _S_to_pointer(__tmp);
      }






      constexpr reverse_iterator&
      operator++()
      {
 --current;
 return *this;
      }






      constexpr reverse_iterator
      operator++(int)
      {
 reverse_iterator __tmp = *this;
 --current;
 return __tmp;
      }






      constexpr reverse_iterator&
      operator--()
      {
 ++current;
 return *this;
      }






      constexpr reverse_iterator
      operator--(int)
      {
 reverse_iterator __tmp = *this;
 ++current;
 return __tmp;
      }






      constexpr reverse_iterator
      operator+(difference_type __n) const
      { return reverse_iterator(current - __n); }







      constexpr reverse_iterator&
      operator+=(difference_type __n)
      {
 current -= __n;
 return *this;
      }






      constexpr reverse_iterator
      operator-(difference_type __n) const
      { return reverse_iterator(current + __n); }







      constexpr reverse_iterator&
      operator-=(difference_type __n)
      {
 current += __n;
 return *this;
      }






      constexpr reference
      operator[](difference_type __n) const
      { return *(*this + __n); }

    private:
      template<typename _Tp>
 static constexpr _Tp*
 _S_to_pointer(_Tp* __p)
        { return __p; }

      template<typename _Tp>
 static constexpr pointer
 _S_to_pointer(_Tp __t)
        { return __t.operator->(); }
    };
# 332 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Iterator>
    inline constexpr bool
    operator==(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return __x.base() == __y.base(); }

  template<typename _Iterator>
    inline constexpr bool
    operator<(const reverse_iterator<_Iterator>& __x,
       const reverse_iterator<_Iterator>& __y)
    { return __y.base() < __x.base(); }

  template<typename _Iterator>
    inline constexpr bool
    operator!=(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return !(__x == __y); }

  template<typename _Iterator>
    inline constexpr bool
    operator>(const reverse_iterator<_Iterator>& __x,
       const reverse_iterator<_Iterator>& __y)
    { return __y < __x; }

  template<typename _Iterator>
    inline constexpr bool
    operator<=(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return !(__y < __x); }

  template<typename _Iterator>
    inline constexpr bool
    operator>=(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return !(__x < __y); }



  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator==(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return __x.base() == __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator<(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    { return __y.base() < __x.base(); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator!=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return !(__x == __y); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator>(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    { return __y < __x; }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator<=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return !(__y < __x); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator>=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return !(__x < __y); }
# 422 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    inline constexpr auto
    operator-(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    -> decltype(__y.base() - __x.base())
    { return __y.base() - __x.base(); }


  template<typename _Iterator>
    inline constexpr reverse_iterator<_Iterator>
    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
       const reverse_iterator<_Iterator>& __x)
    { return reverse_iterator<_Iterator>(__x.base() - __n); }



  template<typename _Iterator>
    inline constexpr reverse_iterator<_Iterator>
    __make_reverse_iterator(_Iterator __i)
    { return reverse_iterator<_Iterator>(__i); }







  template<typename _Iterator>
    inline constexpr reverse_iterator<_Iterator>
    make_reverse_iterator(_Iterator __i)
    { return reverse_iterator<_Iterator>(__i); }
# 463 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Iterator>
   
    auto
    __niter_base(reverse_iterator<_Iterator> __it)
    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
    { return __make_reverse_iterator(__niter_base(__it.base())); }

  template<typename _Iterator>
    struct __is_move_iterator<reverse_iterator<_Iterator> >
      : __is_move_iterator<_Iterator>
    { };

  template<typename _Iterator>
   
    auto
    __miter_base(reverse_iterator<_Iterator> __it)
    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
    { return __make_reverse_iterator(__miter_base(__it.base())); }
# 494 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Container>
    class back_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;


      explicit
      back_insert_iterator(_Container& __x)
      : container(std::__addressof(__x)) { }
# 529 "/usr/include/c++/10/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 container->push_back(__value);
 return *this;
      }

      back_insert_iterator&
      operator=(typename _Container::value_type&& __value)
      {
 container->push_back(std::move(__value));
 return *this;
      }



      back_insert_iterator&
      operator*()
      { return *this; }


      back_insert_iterator&
      operator++()
      { return *this; }


      back_insert_iterator
      operator++(int)
      { return *this; }
    };
# 571 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Container>
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 586 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Container>
    class front_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;


      explicit front_insert_iterator(_Container& __x)
      : container(std::__addressof(__x)) { }
# 620 "/usr/include/c++/10/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 container->push_front(__value);
 return *this;
      }

      front_insert_iterator&
      operator=(typename _Container::value_type&& __value)
      {
 container->push_front(std::move(__value));
 return *this;
      }



      front_insert_iterator&
      operator*()
      { return *this; }


      front_insert_iterator&
      operator++()
      { return *this; }


      front_insert_iterator
      operator++(int)
      { return *this; }
    };
# 662 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Container>
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 681 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Container>
    class insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;
      typename _Container::iterator iter;

    public:

      typedef _Container container_type;





      insert_iterator(_Container& __x, typename _Container::iterator __i)
      : container(std::__addressof(__x)), iter(__i) {}
# 732 "/usr/include/c++/10/bits/stl_iterator.h" 3
      insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 iter = container->insert(iter, __value);
 ++iter;
 return *this;
      }

      insert_iterator&
      operator=(typename _Container::value_type&& __value)
      {
 iter = container->insert(iter, std::move(__value));
 ++iter;
 return *this;
      }



      insert_iterator&
      operator*()
      { return *this; }


      insert_iterator&
      operator++()
      { return *this; }


      insert_iterator&
      operator++(int)
      { return *this; }
    };
# 777 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Container, typename _Iterator>
    inline insert_iterator<_Container>
    inserter(_Container& __x, _Iterator __i)
    {
      return insert_iterator<_Container>(__x,
      typename _Container::iterator(__i));
    }




}

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

# 801 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Iterator, typename _Container>
    class __normal_iterator
    {
    protected:
      _Iterator _M_current;

      typedef std::iterator_traits<_Iterator> __traits_type;

    public:
      typedef _Iterator iterator_type;
      typedef typename __traits_type::iterator_category iterator_category;
      typedef typename __traits_type::value_type value_type;
      typedef typename __traits_type::difference_type difference_type;
      typedef typename __traits_type::reference reference;
      typedef typename __traits_type::pointer pointer;





      constexpr __normal_iterator() noexcept
      : _M_current(_Iterator()) { }

      explicit
      __normal_iterator(const _Iterator& __i) noexcept
      : _M_current(__i) { }


      template<typename _Iter>
       
        __normal_iterator(const __normal_iterator<_Iter,
     typename __enable_if<
              (std::__are_same<_Iter, typename _Container::pointer>::__value),
        _Container>::__type>& __i) noexcept
        : _M_current(__i.base()) { }


     
      reference
      operator*() const noexcept
      { return *_M_current; }

     
      pointer
      operator->() const noexcept
      { return _M_current; }

     
      __normal_iterator&
      operator++() noexcept
      {
 ++_M_current;
 return *this;
      }

     
      __normal_iterator
      operator++(int) noexcept
      { return __normal_iterator(_M_current++); }


     
      __normal_iterator&
      operator--() noexcept
      {
 --_M_current;
 return *this;
      }

     
      __normal_iterator
      operator--(int) noexcept
      { return __normal_iterator(_M_current--); }


     
      reference
      operator[](difference_type __n) const noexcept
      { return _M_current[__n]; }

     
      __normal_iterator&
      operator+=(difference_type __n) noexcept
      { _M_current += __n; return *this; }

     
      __normal_iterator
      operator+(difference_type __n) const noexcept
      { return __normal_iterator(_M_current + __n); }

     
      __normal_iterator&
      operator-=(difference_type __n) noexcept
      { _M_current -= __n; return *this; }

     
      __normal_iterator
      operator-(difference_type __n) const noexcept
      { return __normal_iterator(_M_current - __n); }

     
      const _Iterator&
      base() const noexcept
      { return _M_current; }
    };
# 916 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>
   
    inline bool
    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept
    { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline bool
    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
   
    inline bool
    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept
    { return __lhs.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline bool
    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() != __rhs.base(); }


  template<typename _IteratorL, typename _IteratorR, typename _Container>
   
    inline bool
    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept
    { return __lhs.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline bool
    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() < __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
   
    inline bool
    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept
    { return __lhs.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline bool
    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() > __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
   
    inline bool
    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept
    { return __lhs.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline bool
    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() <= __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
   
    inline bool
    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept
    { return __lhs.base() >= __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline bool
    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() >= __rhs.base(); }





  template<typename _IteratorL, typename _IteratorR, typename _Container>


   
    inline auto
    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
    -> decltype(__lhs.base() - __rhs.base())





    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline typename __normal_iterator<_Iterator, _Container>::difference_type
    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
   
    inline __normal_iterator<_Iterator, _Container>
    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
       __n, const __normal_iterator<_Iterator, _Container>& __i)
    noexcept
    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }


}

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


  template<typename _Iterator, typename _Container>
   
    _Iterator
    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
    { return __it.base(); }
# 1127 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class move_iterator
    {
      _Iterator _M_current;

      using __traits_type = iterator_traits<_Iterator>;



      using __base_ref = typename __traits_type::reference;


    public:
      using iterator_type = _Iterator;
# 1151 "/usr/include/c++/10/bits/stl_iterator.h" 3
      typedef typename __traits_type::iterator_category iterator_category;
      typedef typename __traits_type::value_type value_type;
      typedef typename __traits_type::difference_type difference_type;

      typedef _Iterator pointer;


      typedef typename conditional<is_reference<__base_ref>::value,
    typename remove_reference<__base_ref>::type&&,
    __base_ref>::type reference;


      constexpr
      move_iterator()
      : _M_current() { }

      explicit constexpr
      move_iterator(iterator_type __i)
      : _M_current(__i) { }

      template<typename _Iter>
 constexpr
 move_iterator(const move_iterator<_Iter>& __i)
 : _M_current(__i.base()) { }

      constexpr iterator_type
      base() const
      { return _M_current; }

      constexpr reference
      operator*() const
      { return static_cast<reference>(*_M_current); }

      constexpr pointer
      operator->() const
      { return _M_current; }

      constexpr move_iterator&
      operator++()
      {
 ++_M_current;
 return *this;
      }

      constexpr move_iterator
      operator++(int)
      {
 move_iterator __tmp = *this;
 ++_M_current;
 return __tmp;
      }

      constexpr move_iterator&
      operator--()
      {
 --_M_current;
 return *this;
      }

      constexpr move_iterator
      operator--(int)
      {
 move_iterator __tmp = *this;
 --_M_current;
 return __tmp;
      }

      constexpr move_iterator
      operator+(difference_type __n) const
      { return move_iterator(_M_current + __n); }

      constexpr move_iterator&
      operator+=(difference_type __n)
      {
 _M_current += __n;
 return *this;
      }

      constexpr move_iterator
      operator-(difference_type __n) const
      { return move_iterator(_M_current - __n); }

      constexpr move_iterator&
      operator-=(difference_type __n)
      {
 _M_current -= __n;
 return *this;
      }

      constexpr reference
      operator[](difference_type __n) const
      { return std::move(_M_current[__n]); }
# 1271 "/usr/include/c++/10/bits/stl_iterator.h" 3
    };




  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator==(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)
    { return __x.base() == __y.base(); }

  template<typename _Iterator>
    inline constexpr bool
    operator==(const move_iterator<_Iterator>& __x,
        const move_iterator<_Iterator>& __y)
    { return __x.base() == __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator!=(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)
    { return !(__x == __y); }

  template<typename _Iterator>
    inline constexpr bool
    operator!=(const move_iterator<_Iterator>& __x,
        const move_iterator<_Iterator>& __y)
    { return !(__x == __y); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator<(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)
    { return __x.base() < __y.base(); }

  template<typename _Iterator>
    inline constexpr bool
    operator<(const move_iterator<_Iterator>& __x,
       const move_iterator<_Iterator>& __y)
    { return __x.base() < __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator<=(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)
    { return !(__y < __x); }

  template<typename _Iterator>
    inline constexpr bool
    operator<=(const move_iterator<_Iterator>& __x,
        const move_iterator<_Iterator>& __y)
    { return !(__y < __x); }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator>(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)
    { return __y < __x; }

  template<typename _Iterator>
    inline constexpr bool
    operator>(const move_iterator<_Iterator>& __x,
       const move_iterator<_Iterator>& __y)
    { return __y < __x; }

  template<typename _IteratorL, typename _IteratorR>
    inline constexpr bool
    operator>=(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)
    { return !(__x < __y); }

  template<typename _Iterator>
    inline constexpr bool
    operator>=(const move_iterator<_Iterator>& __x,
        const move_iterator<_Iterator>& __y)
    { return !(__x < __y); }


  template<typename _IteratorL, typename _IteratorR>
    inline constexpr auto
    operator-(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)
    -> decltype(__x.base() - __y.base())
    { return __x.base() - __y.base(); }

  template<typename _Iterator>
    inline constexpr move_iterator<_Iterator>
    operator+(typename move_iterator<_Iterator>::difference_type __n,
       const move_iterator<_Iterator>& __x)
    { return __x + __n; }

  template<typename _Iterator>
    inline constexpr move_iterator<_Iterator>
    make_move_iterator(_Iterator __i)
    { return move_iterator<_Iterator>(__i); }

  template<typename _Iterator, typename _ReturnType
    = typename conditional<__move_if_noexcept_cond
      <typename iterator_traits<_Iterator>::value_type>::value,
                _Iterator, move_iterator<_Iterator>>::type>
    inline constexpr _ReturnType
    __make_move_if_noexcept_iterator(_Iterator __i)
    { return _ReturnType(__i); }



  template<typename _Tp, typename _ReturnType
    = typename conditional<__move_if_noexcept_cond<_Tp>::value,
      const _Tp*, move_iterator<_Tp*>>::type>
    inline constexpr _ReturnType
    __make_move_if_noexcept_iterator(_Tp* __i)
    { return _ReturnType(__i); }
# 1972 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _Iterator>
    auto
    __niter_base(move_iterator<_Iterator> __it)
    -> decltype(make_move_iterator(__niter_base(__it.base())))
    { return make_move_iterator(__niter_base(__it.base())); }

  template<typename _Iterator>
    struct __is_move_iterator<move_iterator<_Iterator> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<typename _Iterator>
    auto
    __miter_base(move_iterator<_Iterator> __it)
    -> decltype(__miter_base(__it.base()))
    { return __miter_base(__it.base()); }
# 2002 "/usr/include/c++/10/bits/stl_iterator.h" 3
  template<typename _InputIterator>
    using __iter_key_t = remove_const_t<
    typename iterator_traits<_InputIterator>::value_type::first_type>;

  template<typename _InputIterator>
    using __iter_val_t =
    typename iterator_traits<_InputIterator>::value_type::second_type;

  template<typename _T1, typename _T2>
    struct pair;

  template<typename _InputIterator>
    using __iter_to_alloc_t =
    pair<add_const_t<__iter_key_t<_InputIterator>>,
  __iter_val_t<_InputIterator>>;



}
# 68 "/usr/include/c++/10/bits/stl_algobase.h" 2 3

# 1 "/usr/include/c++/10/debug/debug.h" 1 3
# 48 "/usr/include/c++/10/debug/debug.h" 3
namespace std
{
  namespace __debug { }
}




namespace __gnu_debug
{
  using namespace std::__debug;

  template<typename _Ite, typename _Seq, typename _Cat>
    struct _Safe_iterator;
}
# 70 "/usr/include/c++/10/bits/stl_algobase.h" 2 3

# 1 "/usr/include/c++/10/bits/predefined_ops.h" 1 3
# 33 "/usr/include/c++/10/bits/predefined_ops.h" 3
namespace __gnu_cxx
{
namespace __ops
{
  struct _Iter_less_iter
  {
    template<typename _Iterator1, typename _Iterator2>
      constexpr
      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2) const
      { return *__it1 < *__it2; }
  };

  constexpr
  inline _Iter_less_iter
  __iter_less_iter()
  { return _Iter_less_iter(); }

  struct _Iter_less_val
  {

    constexpr _Iter_less_val() = default;




   
    explicit
    _Iter_less_val(_Iter_less_iter) { }

    template<typename _Iterator, typename _Value>
     
      bool
      operator()(_Iterator __it, _Value& __val) const
      { return *__it < __val; }
  };

 
  inline _Iter_less_val
  __iter_less_val()
  { return _Iter_less_val(); }

 
  inline _Iter_less_val
  __iter_comp_val(_Iter_less_iter)
  { return _Iter_less_val(); }

  struct _Val_less_iter
  {

    constexpr _Val_less_iter() = default;




   
    explicit
    _Val_less_iter(_Iter_less_iter) { }

    template<typename _Value, typename _Iterator>
     
      bool
      operator()(_Value& __val, _Iterator __it) const
      { return __val < *__it; }
  };

 
  inline _Val_less_iter
  __val_less_iter()
  { return _Val_less_iter(); }

 
  inline _Val_less_iter
  __val_comp_iter(_Iter_less_iter)
  { return _Val_less_iter(); }

  struct _Iter_equal_to_iter
  {
    template<typename _Iterator1, typename _Iterator2>
     
      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2) const
      { return *__it1 == *__it2; }
  };

 
  inline _Iter_equal_to_iter
  __iter_equal_to_iter()
  { return _Iter_equal_to_iter(); }

  struct _Iter_equal_to_val
  {
    template<typename _Iterator, typename _Value>
     
      bool
      operator()(_Iterator __it, _Value& __val) const
      { return *__it == __val; }
  };

 
  inline _Iter_equal_to_val
  __iter_equal_to_val()
  { return _Iter_equal_to_val(); }

 
  inline _Iter_equal_to_val
  __iter_comp_val(_Iter_equal_to_iter)
  { return _Iter_equal_to_val(); }

  template<typename _Compare>
    struct _Iter_comp_iter
    {
      _Compare _M_comp;

      explicit constexpr
      _Iter_comp_iter(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      template<typename _Iterator1, typename _Iterator2>
        constexpr
        bool
        operator()(_Iterator1 __it1, _Iterator2 __it2)
        { return bool(_M_comp(*__it1, *__it2)); }
    };

  template<typename _Compare>
    constexpr
    inline _Iter_comp_iter<_Compare>
    __iter_comp_iter(_Compare __comp)
    { return _Iter_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    struct _Iter_comp_val
    {
      _Compare _M_comp;

     
      explicit
      _Iter_comp_val(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

     
      explicit
      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
 : _M_comp(__comp._M_comp)
      { }


     
      explicit
      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
 : _M_comp(std::move(__comp._M_comp))
      { }


      template<typename _Iterator, typename _Value>

 bool
 operator()(_Iterator __it, _Value& __val)
 { return bool(_M_comp(*__it, __val)); }
    };

  template<typename _Compare>
   
    inline _Iter_comp_val<_Compare>
    __iter_comp_val(_Compare __comp)
    { return _Iter_comp_val<_Compare>(std::move(__comp)); }

  template<typename _Compare>
   
    inline _Iter_comp_val<_Compare>
    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
    { return _Iter_comp_val<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    struct _Val_comp_iter
    {
      _Compare _M_comp;

     
      explicit
      _Val_comp_iter(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

     
      explicit
      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
 : _M_comp(__comp._M_comp)
      { }


     
      explicit
      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
 : _M_comp(std::move(__comp._M_comp))
      { }


      template<typename _Value, typename _Iterator>

 bool
 operator()(_Value& __val, _Iterator __it)
 { return bool(_M_comp(__val, *__it)); }
    };

  template<typename _Compare>
   
    inline _Val_comp_iter<_Compare>
    __val_comp_iter(_Compare __comp)
    { return _Val_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Compare>
   
    inline _Val_comp_iter<_Compare>
    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
    { return _Val_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Value>
    struct _Iter_equals_val
    {
      _Value& _M_value;

     
      explicit
      _Iter_equals_val(_Value& __value)
 : _M_value(__value)
      { }

      template<typename _Iterator>

 bool
 operator()(_Iterator __it)
 { return *__it == _M_value; }
    };

  template<typename _Value>
   
    inline _Iter_equals_val<_Value>
    __iter_equals_val(_Value& __val)
    { return _Iter_equals_val<_Value>(__val); }

  template<typename _Iterator1>
    struct _Iter_equals_iter
    {
      _Iterator1 _M_it1;

     
      explicit
      _Iter_equals_iter(_Iterator1 __it1)
 : _M_it1(__it1)
      { }

      template<typename _Iterator2>

 bool
 operator()(_Iterator2 __it2)
 { return *__it2 == *_M_it1; }
    };

  template<typename _Iterator>
   
    inline _Iter_equals_iter<_Iterator>
    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
    { return _Iter_equals_iter<_Iterator>(__it); }

  template<typename _Predicate>
    struct _Iter_pred
    {
      _Predicate _M_pred;

     
      explicit
      _Iter_pred(_Predicate __pred)
 : _M_pred(std::move(__pred))
      { }

      template<typename _Iterator>

 bool
 operator()(_Iterator __it)
 { return bool(_M_pred(*__it)); }
    };

  template<typename _Predicate>
   
    inline _Iter_pred<_Predicate>
    __pred_iter(_Predicate __pred)
    { return _Iter_pred<_Predicate>(std::move(__pred)); }

  template<typename _Compare, typename _Value>
    struct _Iter_comp_to_val
    {
      _Compare _M_comp;
      _Value& _M_value;

     
      _Iter_comp_to_val(_Compare __comp, _Value& __value)
 : _M_comp(std::move(__comp)), _M_value(__value)
      { }

      template<typename _Iterator>

 bool
 operator()(_Iterator __it)
 { return bool(_M_comp(*__it, _M_value)); }
    };

  template<typename _Compare, typename _Value>
    _Iter_comp_to_val<_Compare, _Value>
   
    __iter_comp_val(_Compare __comp, _Value &__val)
    {
      return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val);
    }

  template<typename _Compare, typename _Iterator1>
    struct _Iter_comp_to_iter
    {
      _Compare _M_comp;
      _Iterator1 _M_it1;

     
      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
 : _M_comp(std::move(__comp)), _M_it1(__it1)
      { }

      template<typename _Iterator2>

 bool
 operator()(_Iterator2 __it2)
 { return bool(_M_comp(*__it2, *_M_it1)); }
    };

  template<typename _Compare, typename _Iterator>
   
    inline _Iter_comp_to_iter<_Compare, _Iterator>
    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
    {
      return _Iter_comp_to_iter<_Compare, _Iterator>(
   std::move(__comp._M_comp), __it);
    }

  template<typename _Predicate>
    struct _Iter_negate
    {
      _Predicate _M_pred;

     
      explicit
      _Iter_negate(_Predicate __pred)
 : _M_pred(std::move(__pred))
      { }

      template<typename _Iterator>

 bool
 operator()(_Iterator __it)
 { return !bool(_M_pred(*__it)); }
    };

  template<typename _Predicate>
   
    inline _Iter_negate<_Predicate>
    __negate(_Iter_pred<_Predicate> __pred)
    { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); }

}
}
# 72 "/usr/include/c++/10/bits/stl_algobase.h" 2 3







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






  template<bool _IsMove, typename _Tp>
    constexpr
    inline void*
    __memmove(_Tp* __dst, const _Tp* __src, size_t __num)
    {
# 108 "/usr/include/c++/10/bits/stl_algobase.h" 3
 return __builtin_memmove(__dst, __src, sizeof(_Tp) * __num);
      return __dst;
    }





  template<typename _Tp>
    constexpr
    inline int
    __memcmp(const _Tp* __first1, const _Tp* __first2, size_t __num)
    {
# 131 "/usr/include/c++/10/bits/stl_algobase.h" 3
 return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num);
    }
# 177 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
   
    inline void
    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
    {

     

     
# 208 "/usr/include/c++/10/bits/stl_algobase.h" 3
      swap(*__a, *__b);

    }
# 224 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
   
    _ForwardIterator2
    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2)
    {

     

     

      ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 std::iter_swap(__first1, __first2);
      return __first2;
    }
# 253 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _Tp>
    constexpr
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {

     

      if (__b < __a)
 return __b;
      return __a;
    }
# 277 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _Tp>
    constexpr
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {

     

      if (__a < __b)
 return __b;
      return __a;
    }
# 301 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    constexpr
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__b, __a))
 return __b;
      return __a;
    }
# 323 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    constexpr
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__a, __b))
 return __b;
      return __a;
    }



  template<typename _Iterator>
   
    inline _Iterator
    __niter_base(_Iterator __it)
    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
    { return __it; }




  template<typename _From, typename _To>
   
    inline _From
    __niter_wrap(_From __from, _To __res)
    { return __from + (__res - std::__niter_base(__from)); }


  template<typename _Iterator>
   
    inline _Iterator
    __niter_wrap(const _Iterator&, _Iterator __res)
    { return __res; }







  template<bool _IsMove, bool _IsSimple, typename _Category>
    struct __copy_move
    {
      template<typename _II, typename _OI>

 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   for (; __first != __last; ++__result, (void)++__first)
     *__result = *__first;
   return __result;
 }
    };


  template<typename _Category>
    struct __copy_move<true, false, _Category>
    {
      template<typename _II, typename _OI>

 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   for (; __first != __last; ++__result, (void)++__first)
     *__result = std::move(*__first);
   return __result;
 }
    };


  template<>
    struct __copy_move<false, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>

 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   typedef typename iterator_traits<_II>::difference_type _Distance;
   for(_Distance __n = __last - __first; __n > 0; --__n)
     {
       *__result = *__first;
       ++__first;
       ++__result;
     }
   return __result;
 }
    };


  template<>
    struct __copy_move<true, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>

 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   typedef typename iterator_traits<_II>::difference_type _Distance;
   for(_Distance __n = __last - __first; __n > 0; --__n)
     {
       *__result = std::move(*__first);
       ++__first;
       ++__result;
     }
   return __result;
 }
    };


  template<bool _IsMove>
    struct __copy_move<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>

 static _Tp*
 __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
 {

   using __assignable = conditional<_IsMove,
        is_move_assignable<_Tp>,
        is_copy_assignable<_Tp>>;

   static_assert( __assignable::type::value, "type is not assignable" );

   const ptrdiff_t _Num = __last - __first;
   if (_Num)
     std::__memmove<_IsMove>(__result, __first, _Num);
   return __result + _Num;
 }
    };



  template<typename _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits>
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator;

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(_CharT*, _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(const _CharT*, const _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

  template<bool _IsMove, typename _II, typename _OI>
   
    inline _OI
    __copy_move_a2(_II __first, _II __last, _OI __result)
    {
      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
      typedef typename iterator_traits<_II>::iterator_category _Category;
      const bool __simple = (__is_trivially_copyable(_ValueTypeI)
        && __is_pointer<_II>::__value
        && __is_pointer<_OI>::__value
        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
      return std::__copy_move<_IsMove, __simple,
         _Category>::__copy_m(__first, __last, __result);
    }



  template<typename _Tp, typename _Ref, typename _Ptr>
    struct _Deque_iterator;



  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
     std::_Deque_iterator<_Tp, _Ref, _Ptr>,
     _OI);

  template<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>,
     std::_Deque_iterator<_ITp, _IRef, _IPtr>,
     std::_Deque_iterator<_OTp, _OTp&, _OTp*>);

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>);

  template<bool _IsMove, typename _II, typename _OI>
   
    inline _OI
    __copy_move_a1(_II __first, _II __last, _OI __result)
    { return std::__copy_move_a2<_IsMove>(__first, __last, __result); }

  template<bool _IsMove, typename _II, typename _OI>
   
    inline _OI
    __copy_move_a(_II __first, _II __last, _OI __result)
    {
      return std::__niter_wrap(__result,
  std::__copy_move_a1<_IsMove>(std::__niter_base(__first),
          std::__niter_base(__last),
          std::__niter_base(__result)));
    }

  template<bool _IsMove,
    typename _Ite, typename _Seq, typename _Cat, typename _OI>
    _OI
    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
    _OI);

  template<bool _IsMove,
    typename _II, typename _Ite, typename _Seq, typename _Cat>
    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __copy_move_a(_II, _II,
    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

  template<bool _IsMove,
    typename _IIte, typename _ISeq, typename _ICat,
    typename _OIte, typename _OSeq, typename _OCat>
    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
    const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
    const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
# 584 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
   
    inline _OI
    copy(_II __first, _II __last, _OI __result)
    {

     
     

      ;

      return std::__copy_move_a<__is_move_iterator<_II>::__value>
      (std::__miter_base(__first), std::__miter_base(__last), __result);
    }
# 617 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
   
    inline _OI
    move(_II __first, _II __last, _OI __result)
    {

     
     

      ;

      return std::__copy_move_a<true>(std::__miter_base(__first),
          std::__miter_base(__last), __result);
    }






  template<bool _IsMove, bool _IsSimple, typename _Category>
    struct __copy_move_backward
    {
      template<typename _BI1, typename _BI2>

 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   while (__first != __last)
     *--__result = *--__last;
   return __result;
 }
    };


  template<typename _Category>
    struct __copy_move_backward<true, false, _Category>
    {
      template<typename _BI1, typename _BI2>

 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   while (__first != __last)
     *--__result = std::move(*--__last);
   return __result;
 }
    };


  template<>
    struct __copy_move_backward<false, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>

 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   typename iterator_traits<_BI1>::difference_type
     __n = __last - __first;
   for (; __n > 0; --__n)
     *--__result = *--__last;
   return __result;
 }
    };


  template<>
    struct __copy_move_backward<true, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>

 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   typename iterator_traits<_BI1>::difference_type
     __n = __last - __first;
   for (; __n > 0; --__n)
     *--__result = std::move(*--__last);
   return __result;
 }
    };


  template<bool _IsMove>
    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>

 static _Tp*
 __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
 {

   using __assignable = conditional<_IsMove,
        is_move_assignable<_Tp>,
        is_copy_assignable<_Tp>>;

   static_assert( __assignable::type::value, "type is not assignable" );

   const ptrdiff_t _Num = __last - __first;
   if (_Num)
     std::__memmove<_IsMove>(__result - _Num, __first, _Num);
   return __result - _Num;
 }
    };

  template<bool _IsMove, typename _BI1, typename _BI2>
   
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
      typedef typename iterator_traits<_BI1>::iterator_category _Category;
      const bool __simple = (__is_trivially_copyable(_ValueType1)
        && __is_pointer<_BI1>::__value
        && __is_pointer<_BI2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);







      return std::__copy_move_backward<_IsMove, __simple,
           _Category>::__copy_move_b(__first,
         __last,
         __result);
    }

  template<bool _IsMove, typename _BI1, typename _BI2>
   
    inline _BI2
    __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result)
    { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
       std::_Deque_iterator<_Tp, _Ref, _Ptr>,
       _OI);

  template<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_backward_a1(
   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
   std::_Deque_iterator<_OTp, _OTp&, _OTp*>);

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_backward_a1(_II, _II,
       std::_Deque_iterator<_Tp, _Tp&, _Tp*>);

  template<bool _IsMove, typename _II, typename _OI>
   
    inline _OI
    __copy_move_backward_a(_II __first, _II __last, _OI __result)
    {
      return std::__niter_wrap(__result,
  std::__copy_move_backward_a1<_IsMove>
    (std::__niter_base(__first), std::__niter_base(__last),
     std::__niter_base(__result)));
    }

  template<bool _IsMove,
    typename _Ite, typename _Seq, typename _Cat, typename _OI>
    _OI
    __copy_move_backward_a(
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
  _OI);

  template<bool _IsMove,
    typename _II, typename _Ite, typename _Seq, typename _Cat>
    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __copy_move_backward_a(_II, _II,
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

  template<bool _IsMove,
    typename _IIte, typename _ISeq, typename _ICat,
    typename _OIte, typename _OSeq, typename _OCat>
    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
    __copy_move_backward_a(
  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
  const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
# 828 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
   
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {

     
     
     


      ;

      return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value>
      (std::__miter_base(__first), std::__miter_base(__last), __result);
    }
# 864 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
   
    inline _BI2
    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {

     
     
     


      ;

      return std::__copy_move_backward_a<true>(std::__miter_base(__first),
            std::__miter_base(__last),
            __result);
    }






  template<typename _ForwardIterator, typename _Tp>
   
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
    __fill_a1(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
      for (; __first != __last; ++__first)
 *__first = __value;
    }

  template<typename _ForwardIterator, typename _Tp>
   
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
    __fill_a1(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __first != __last; ++__first)
 *__first = __tmp;
    }


  template<typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
    __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c)
    {
      const _Tp __tmp = __c;
      if (const size_t __len = __last - __first)
 __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
    }

  template<typename _Ite, typename _Cont, typename _Tp>
   
    inline void
    __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first,
       ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last,
       const _Tp& __value)
    { std::__fill_a1(__first.base(), __last.base(), __value); }

  template<typename _Tp, typename _VTp>
    void
    __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
       const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
       const _VTp&);

  template<typename _FIte, typename _Tp>
   
    inline void
    __fill_a(_FIte __first, _FIte __last, const _Tp& __value)
    { std::__fill_a1(__first, __last, __value); }

  template<typename _Ite, typename _Seq, typename _Cat, typename _Tp>
    void
    __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
      const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
      const _Tp&);
# 959 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
   
    inline void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {

     

      ;

      std::__fill_a(__first, __last, __value);
    }


  inline constexpr int
  __size_to_integer(int __n) { return __n; }
  inline constexpr unsigned
  __size_to_integer(unsigned __n) { return __n; }
  inline constexpr long
  __size_to_integer(long __n) { return __n; }
  inline constexpr unsigned long
  __size_to_integer(unsigned long __n) { return __n; }
  inline constexpr long long
  __size_to_integer(long long __n) { return __n; }
  inline constexpr unsigned long long
  __size_to_integer(unsigned long long __n) { return __n; }
# 1011 "/usr/include/c++/10/bits/stl_algobase.h" 3
  inline constexpr long long
  __size_to_integer(float __n) { return __n; }
  inline constexpr long long
  __size_to_integer(double __n) { return __n; }
  inline constexpr long long
  __size_to_integer(long double __n) { return __n; }





  template<typename _OutputIterator, typename _Size, typename _Tp>
   
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      for (; __n > 0; --__n, (void) ++__first)
 *__first = __value;
      return __first;
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
   
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __n > 0; --__n, (void) ++__first)
 *__first = __tmp;
      return __first;
    }

  template<typename _Ite, typename _Seq, typename _Cat, typename _Size,
    typename _Tp>
    ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first,
        _Size __n, const _Tp& __value,
        std::input_iterator_tag);

  template<typename _OutputIterator, typename _Size, typename _Tp>
   
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::output_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      return __fill_n_a1(__first, __n, __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
   
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::input_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      return __fill_n_a1(__first, __n, __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
   
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::random_access_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      if (__n <= 0)
 return __first;

      ;

      std::__fill_a(__first, __first + __n, __value);
      return __first + __n;
    }
# 1111 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _OI, typename _Size, typename _Tp>
   
    inline _OI
    fill_n(_OI __first, _Size __n, const _Tp& __value)
    {

     

      return std::__fill_n_a(__first, std::__size_to_integer(__n), __value,
          std::__iterator_category(__first));
    }

  template<bool _BoolType>
    struct __equal
    {
      template<typename _II1, typename _II2>

 static bool
 equal(_II1 __first1, _II1 __last1, _II2 __first2)
 {
   for (; __first1 != __last1; ++__first1, (void) ++__first2)
     if (!(*__first1 == *__first2))
       return false;
   return true;
 }
    };

  template<>
    struct __equal<true>
    {
      template<typename _Tp>

 static bool
 equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
 {
   if (const size_t __len = (__last1 - __first1))
     return !std::__memcmp(__first1, __first2, __len);
   return true;
 }
    };

  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
   std::_Deque_iterator<_Tp, _Ref, _Ptr>,
   _II);

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
   std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
   std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

  template<typename _II, typename _Tp, typename _Ref, typename _Ptr>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(_II, _II,
  std::_Deque_iterator<_Tp, _Ref, _Ptr>);

  template<typename _II1, typename _II2>
   
    inline bool
    __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple = ((__is_integer<_ValueType1>::__value
         || __is_pointer<_ValueType1>::__value)
        && __is_pointer<_II1>::__value
        && __is_pointer<_II2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__equal<__simple>::equal(__first1, __last1, __first2);
    }

  template<typename _II1, typename _II2>
   
    inline bool
    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      return std::__equal_aux1(std::__niter_base(__first1),
          std::__niter_base(__last1),
          std::__niter_base(__first2));
    }

  template<typename _II1, typename _Seq1, typename _Cat1, typename _II2>
    bool
    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  _II2);

  template<typename _II1, typename _II2, typename _Seq2, typename _Cat2>
    bool
    __equal_aux(_II1, _II1,
  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

  template<typename _II1, typename _Seq1, typename _Cat1,
    typename _II2, typename _Seq2, typename _Cat2>
    bool
    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

  template<typename, typename>
    struct __lc_rai
    {
      template<typename _II1, typename _II2>

 static _II1
 __newlast1(_II1, _II1 __last1, _II2, _II2)
 { return __last1; }

      template<typename _II>

 static bool
 __cnd2(_II __first, _II __last)
 { return __first != __last; }
    };

  template<>
    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
    {
      template<typename _RAI1, typename _RAI2>

 static _RAI1
 __newlast1(_RAI1 __first1, _RAI1 __last1,
     _RAI2 __first2, _RAI2 __last2)
 {
   const typename iterator_traits<_RAI1>::difference_type
     __diff1 = __last1 - __first1;
   const typename iterator_traits<_RAI2>::difference_type
     __diff2 = __last2 - __first2;
   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
 }

      template<typename _RAI>
 static bool
 __cnd2(_RAI, _RAI)
 { return true; }
    };

  template<typename _II1, typename _II2, typename _Compare>
   
    bool
    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2,
       _Compare __comp)
    {
      typedef typename iterator_traits<_II1>::iterator_category _Category1;
      typedef typename iterator_traits<_II2>::iterator_category _Category2;
      typedef std::__lc_rai<_Category1, _Category2> __rai_type;

      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
    ++__first1, (void)++__first2)
 {
   if (__comp(__first1, __first2))
     return true;
   if (__comp(__first2, __first1))
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }

  template<bool _BoolType>
    struct __lexicographical_compare
    {
      template<typename _II1, typename _II2>

 static bool __lc(_II1, _II1, _II2, _II2);
    };

  template<bool _BoolType>
    template<typename _II1, typename _II2>
     
      bool
      __lexicographical_compare<_BoolType>::
      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      {
 return std::__lexicographical_compare_impl(__first1, __last1,
         __first2, __last2,
     __gnu_cxx::__ops::__iter_less_iter());
      }

  template<>
    struct __lexicographical_compare<true>
    {
      template<typename _Tp, typename _Up>

 static bool
 __lc(const _Tp* __first1, const _Tp* __last1,
      const _Up* __first2, const _Up* __last2)
 {
   const size_t __len1 = __last1 - __first1;
   const size_t __len2 = __last2 - __first2;
   if (const size_t __len = std::min(__len1, __len2))
     if (int __result = std::__memcmp(__first1, __first2, __len))
       return __result < 0;
   return __len1 < __len2;
 }
    };

  template<typename _II1, typename _II2>
   
    inline bool
    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
      _II2 __first2, _II2 __last2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple =
 (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
  && __is_pointer<_II1>::__value
  && __is_pointer<_II2>::__value);

      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
           __first2, __last2);
    }

  template<typename _ForwardIterator, typename _Tp, typename _Compare>
   
    _ForwardIterator
    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 1373 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
   
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {

     
     

      ;

      return std::__lower_bound(__first, __last, __val,
    __gnu_cxx::__ops::__iter_less_val());
    }



  inline constexpr int
  __lg(int __n)
  { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }

  inline constexpr unsigned
  __lg(unsigned __n)
  { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }

  inline constexpr long
  __lg(long __n)
  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }

  inline constexpr unsigned long
  __lg(unsigned long __n)
  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }

  inline constexpr long long
  __lg(long long __n)
  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }

  inline constexpr unsigned long long
  __lg(unsigned long long __n)
  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }


# 1429 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
   
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2)
    {

     
     
     


      ;

      return std::__equal_aux(__first1, __last1, __first2);
    }
# 1460 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
   
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _BinaryPredicate __binary_pred)
    {

     
     
      ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 if (!bool(__binary_pred(*__first1, *__first2)))
   return false;
      return true;
    }



  template<typename _II1, typename _II2>
   
    inline bool
    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
    {
      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if (_RAIters())
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 != __d2)
     return false;
   return std::equal(__first1, __last1, __first2);
 }

      for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
 if (!(*__first1 == *__first2))
   return false;
      return __first1 == __last1 && __first2 == __last2;
    }


  template<typename _II1, typename _II2, typename _BinaryPredicate>
   
    inline bool
    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
      _BinaryPredicate __binary_pred)
    {
      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if (_RAIters())
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 != __d2)
     return false;
   return std::equal(__first1, __last1, __first2,
           __binary_pred);
 }

      for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
 if (!bool(__binary_pred(*__first1, *__first2)))
   return false;
      return __first1 == __last1 && __first2 == __last2;
    }
# 1550 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
   
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
    {

     
     
     


      ;
      ;

      return std::__equal4(__first1, __last1, __first2, __last2);
    }
# 1583 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
   
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
    {

     
     
      ;
      ;

      return std::__equal4(__first1, __last1, __first2, __last2,
          __binary_pred);
    }
# 1615 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
   
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {





     
     
     
     
      ;
      ;

      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
      std::__niter_base(__last1),
      std::__niter_base(__first2),
      std::__niter_base(__last2));
    }
# 1652 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2, typename _Compare>
   
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2, _Compare __comp)
    {

     
     
      ;
      ;

      return std::__lexicographical_compare_impl
 (__first1, __last1, __first2, __last2,
  __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 1765 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
   
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __binary_pred(__first1, __first2))
 {
   ++__first1;
   ++__first2;
 }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 1793 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
   
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2)
    {

     
     
     


      ;

      return std::__mismatch(__first1, __last1, __first2,
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 1827 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
   
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {

     
     
      ;

      return std::__mismatch(__first1, __last1, __first2,
 __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }



  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
   
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __first2 != __last2
      && __binary_pred(__first1, __first2))
 {
   ++__first1;
   ++__first2;
 }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 1876 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
   
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {

     
     
     


      ;
      ;

      return std::__mismatch(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 1912 "/usr/include/c++/10/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
   
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _BinaryPredicate __binary_pred)
    {

     
     
      ;
      ;

      return std::__mismatch(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }




}
# 41 "/usr/include/c++/10/array" 2 3
# 1 "/usr/include/c++/10/bits/range_access.h" 1 3
# 33 "/usr/include/c++/10/bits/range_access.h" 3
       
# 34 "/usr/include/c++/10/bits/range_access.h" 3



# 1 "/usr/include/c++/10/bits/iterator_concepts.h" 1 3
# 33 "/usr/include/c++/10/bits/iterator_concepts.h" 3
       
# 34 "/usr/include/c++/10/bits/iterator_concepts.h" 3

# 1 "/usr/include/c++/10/concepts" 1 3
# 36 "/usr/include/c++/10/bits/iterator_concepts.h" 2 3

# 1 "/usr/include/c++/10/bits/range_cmp.h" 1 3
# 38 "/usr/include/c++/10/bits/iterator_concepts.h" 2 3
# 38 "/usr/include/c++/10/bits/range_access.h" 2 3

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







  template<typename _Container>
    inline constexpr auto
    begin(_Container& __cont) -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    inline constexpr auto
    begin(const _Container& __cont) -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    inline constexpr auto
    end(_Container& __cont) -> decltype(__cont.end())
    { return __cont.end(); }






  template<typename _Container>
    inline constexpr auto
    end(const _Container& __cont) -> decltype(__cont.end())
    { return __cont.end(); }





  template<typename _Tp, size_t _Nm>
    inline constexpr _Tp*
    begin(_Tp (&__arr)[_Nm])
    { return __arr; }






  template<typename _Tp, size_t _Nm>
    inline constexpr _Tp*
    end(_Tp (&__arr)[_Nm])
    { return __arr + _Nm; }



  template<typename _Tp> class valarray;

  template<typename _Tp> _Tp* begin(valarray<_Tp>&);
  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
  template<typename _Tp> _Tp* end(valarray<_Tp>&);
  template<typename _Tp> const _Tp* end(const valarray<_Tp>&);






  template<typename _Container>
    inline constexpr auto
    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
      -> decltype(std::begin(__cont))
    { return std::begin(__cont); }






  template<typename _Container>
    inline constexpr auto
    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
      -> decltype(std::end(__cont))
    { return std::end(__cont); }






  template<typename _Container>
    inline constexpr auto
    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
    { return __cont.rbegin(); }






  template<typename _Container>
    inline constexpr auto
    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
    { return __cont.rbegin(); }






  template<typename _Container>
    inline constexpr auto
    rend(_Container& __cont) -> decltype(__cont.rend())
    { return __cont.rend(); }






  template<typename _Container>
    inline constexpr auto
    rend(const _Container& __cont) -> decltype(__cont.rend())
    { return __cont.rend(); }






  template<typename _Tp, size_t _Nm>
    inline constexpr reverse_iterator<_Tp*>
    rbegin(_Tp (&__arr)[_Nm])
    { return reverse_iterator<_Tp*>(__arr + _Nm); }






  template<typename _Tp, size_t _Nm>
    inline constexpr reverse_iterator<_Tp*>
    rend(_Tp (&__arr)[_Nm])
    { return reverse_iterator<_Tp*>(__arr); }






  template<typename _Tp>
    inline constexpr reverse_iterator<const _Tp*>
    rbegin(initializer_list<_Tp> __il)
    { return reverse_iterator<const _Tp*>(__il.end()); }






  template<typename _Tp>
    inline constexpr reverse_iterator<const _Tp*>
    rend(initializer_list<_Tp> __il)
    { return reverse_iterator<const _Tp*>(__il.begin()); }






  template<typename _Container>
    inline constexpr auto
    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
    { return std::rbegin(__cont); }






  template<typename _Container>
    inline constexpr auto
    crend(const _Container& __cont) -> decltype(std::rend(__cont))
    { return std::rend(__cont); }
# 242 "/usr/include/c++/10/bits/range_access.h" 3
  template <typename _Container>
    constexpr auto
    size(const _Container& __cont) noexcept(noexcept(__cont.size()))
    -> decltype(__cont.size())
    { return __cont.size(); }




  template <typename _Tp, size_t _Nm>
    constexpr size_t
    size(const _Tp (&)[_Nm]) noexcept
    { return _Nm; }





  template <typename _Container>
    [[nodiscard]] constexpr auto
    empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
    -> decltype(__cont.empty())
    { return __cont.empty(); }




  template <typename _Tp, size_t _Nm>
    [[nodiscard]] constexpr bool
    empty(const _Tp (&)[_Nm]) noexcept
    { return false; }





  template <typename _Tp>
    [[nodiscard]] constexpr bool
    empty(initializer_list<_Tp> __il) noexcept
    { return __il.size() == 0;}





  template <typename _Container>
    constexpr auto
    data(_Container& __cont) noexcept(noexcept(__cont.data()))
    -> decltype(__cont.data())
    { return __cont.data(); }





  template <typename _Container>
    constexpr auto
    data(const _Container& __cont) noexcept(noexcept(__cont.data()))
    -> decltype(__cont.data())
    { return __cont.data(); }





  template <typename _Tp, size_t _Nm>
    constexpr _Tp*
    data(_Tp (&__array)[_Nm]) noexcept
    { return __array; }





  template <typename _Tp>
    constexpr const _Tp*
    data(initializer_list<_Tp> __il) noexcept
    { return __il.begin(); }
# 1121 "/usr/include/c++/10/bits/range_access.h" 3

}
# 42 "/usr/include/c++/10/array" 2 3

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


  template<typename _Tp, std::size_t _Nm>
    struct __array_traits
    {
      typedef _Tp _Type[_Nm];
      typedef __is_swappable<_Tp> _Is_swappable;
      typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;

      static constexpr _Tp&
      _S_ref(const _Type& __t, std::size_t __n) noexcept
      { return const_cast<_Tp&>(__t[__n]); }

      static constexpr _Tp*
      _S_ptr(const _Type& __t) noexcept
      { return const_cast<_Tp*>(__t); }
    };

 template<typename _Tp>
   struct __array_traits<_Tp, 0>
   {
     struct _Type { };
     typedef true_type _Is_swappable;
     typedef true_type _Is_nothrow_swappable;

     static constexpr _Tp&
     _S_ref(const _Type&, std::size_t) noexcept
     { return *static_cast<_Tp*>(nullptr); }

     static constexpr _Tp*
     _S_ptr(const _Type&) noexcept
     { return nullptr; }
   };
# 93 "/usr/include/c++/10/array" 3
  template<typename _Tp, std::size_t _Nm>
    struct array
    {
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef value_type* iterator;
      typedef const value_type* const_iterator;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;


      typedef std::__array_traits<_Tp, _Nm> _AT_Type;
      typename _AT_Type::_Type _M_elems;




      void
      fill(const value_type& __u)
      { std::fill_n(begin(), size(), __u); }

      void
      swap(array& __other)
      noexcept(_AT_Type::_Is_nothrow_swappable::value)
      { std::swap_ranges(begin(), end(), __other.begin()); }


      constexpr iterator
      begin() noexcept
      { return iterator(data()); }

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

      constexpr iterator
      end() noexcept
      { return iterator(data() + _Nm); }

      constexpr const_iterator
      end() const noexcept
      { return const_iterator(data() + _Nm); }

      constexpr reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      constexpr const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      constexpr reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      constexpr const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }

      constexpr const_iterator
      cbegin() const noexcept
      { return const_iterator(data()); }

      constexpr const_iterator
      cend() const noexcept
      { return const_iterator(data() + _Nm); }

      constexpr const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      constexpr const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }


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

      constexpr size_type
      max_size() const noexcept { return _Nm; }

      [[__nodiscard__]] constexpr bool
      empty() const noexcept { return size() == 0; }


      constexpr reference
      operator[](size_type __n) noexcept
      { return _AT_Type::_S_ref(_M_elems, __n); }

      constexpr const_reference
      operator[](size_type __n) const noexcept
      { return _AT_Type::_S_ref(_M_elems, __n); }

      constexpr reference
      at(size_type __n)
      {
 if (__n >= _Nm)
   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
                                 ,
     __n, _Nm);
 return _AT_Type::_S_ref(_M_elems, __n);
      }

      constexpr const_reference
      at(size_type __n) const
      {


 return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
                                    ,
        __n, _Nm),
      _AT_Type::_S_ref(_M_elems, 0));
      }

      constexpr reference
      front() noexcept
      { return *begin(); }

      constexpr const_reference
      front() const noexcept
      { return _AT_Type::_S_ref(_M_elems, 0); }

      constexpr reference
      back() noexcept
      { return _Nm ? *(end() - 1) : *end(); }

      constexpr const_reference
      back() const noexcept
      {
 return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
             : _AT_Type::_S_ref(_M_elems, 0);
      }

      constexpr pointer
      data() noexcept
      { return _AT_Type::_S_ptr(_M_elems); }

      constexpr const_pointer
      data() const noexcept
      { return _AT_Type::_S_ptr(_M_elems); }
    };


  template<typename _Tp, typename... _Up>
    array(_Tp, _Up...)
      -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
        1 + sizeof...(_Up)>;



  template<typename _Tp, std::size_t _Nm>
   
    inline bool
    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
# 275 "/usr/include/c++/10/array" 3
  template<typename _Tp, std::size_t _Nm>
   
    inline bool
    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return !(__one == __two); }

  template<typename _Tp, std::size_t _Nm>
   
    inline bool
    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
    {
      return std::lexicographical_compare(__a.begin(), __a.end(),
       __b.begin(), __b.end());
    }

  template<typename _Tp, std::size_t _Nm>
   
    inline bool
    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return __two < __one; }

  template<typename _Tp, std::size_t _Nm>
   
    inline bool
    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return !(__one > __two); }

  template<typename _Tp, std::size_t _Nm>
   
    inline bool
    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return !(__one < __two); }



  template<typename _Tp, std::size_t _Nm>
   
    inline


    typename enable_if<
      std::__array_traits<_Tp, _Nm>::_Is_swappable::value
    >::type



    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
    noexcept(noexcept(__one.swap(__two)))
    { __one.swap(__two); }


  template<typename _Tp, std::size_t _Nm>
    typename enable_if<
      !std::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;


  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    constexpr _Tp&
    get(array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::__array_traits<_Tp, _Nm>::
 _S_ref(__arr._M_elems, _Int);
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    constexpr _Tp&&
    get(array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    constexpr const _Tp&
    get(const array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::__array_traits<_Tp, _Nm>::
 _S_ref(__arr._M_elems, _Int);
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    constexpr const _Tp&&
    get(const array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }
# 404 "/usr/include/c++/10/array" 3

}

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





  template<typename _Tp>
    struct tuple_size;


  template<typename _Tp, std::size_t _Nm>
    struct tuple_size<std::array<_Tp, _Nm>>
    : public integral_constant<std::size_t, _Nm> { };


  template<std::size_t _Int, typename _Tp>
    struct tuple_element;


  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    struct tuple_element<_Int, std::array<_Tp, _Nm>>
    {
      static_assert(_Int < _Nm, "index is out of bounds");
      typedef _Tp type;
    };

  template<typename _Tp, std::size_t _Nm>
    struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
    { };


}
# 5 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2
# 1 "/usr/include/c++/10/algorithm" 1 3
# 58 "/usr/include/c++/10/algorithm" 3
       
# 59 "/usr/include/c++/10/algorithm" 3



# 1 "/usr/include/c++/10/bits/stl_algo.h" 1 3
# 59 "/usr/include/c++/10/bits/stl_algo.h" 3
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 75 "/usr/include/c++/10/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 26 "/usr/include/stdlib.h" 2 3 4





# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 209 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 32 "/usr/include/stdlib.h" 2 3 4

extern "C" {





# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 40 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 55 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/floatn.h" 1 3 4
# 74 "/usr/include/bits/floatn.h" 3 4
typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
# 86 "/usr/include/bits/floatn.h" 3 4
typedef __float128 _Float128;
# 119 "/usr/include/bits/floatn.h" 3 4
# 1 "/usr/include/bits/floatn-common.h" 1 3 4
# 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
# 56 "/usr/include/stdlib.h" 2 3 4


typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;





__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;
# 97 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () __attribute__ ((__warn_unused_result__));



extern double atof (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern int atoi (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern long int atol (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



__extension__ extern long long int atoll (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern double strtod (const char *__restrict __nptr,
        char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));



extern float strtof (const char *__restrict __nptr,
       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));

extern long double strtold (const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));
# 140 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32 (const char *__restrict __nptr,
     char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));



extern _Float64 strtof64 (const char *__restrict __nptr,
     char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));



extern _Float128 strtof128 (const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));



extern _Float32x strtof32x (const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));



extern _Float64x strtof64x (const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));
# 176 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

extern unsigned long int strtoul (const char *__restrict __nptr,
      char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));



__extension__
extern long long int strtoq (const char *__restrict __nptr,
        char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int strtoll (const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));




extern int strfromd (char *__dest, size_t __size, const char *__format,
       double __f)
     throw () __attribute__ ((__nonnull__ (3)));

extern int strfromf (char *__dest, size_t __size, const char *__format,
       float __f)
     throw () __attribute__ ((__nonnull__ (3)));

extern int strfroml (char *__dest, size_t __size, const char *__format,
       long double __f)
     throw () __attribute__ ((__nonnull__ (3)));
# 232 "/usr/include/stdlib.h" 3 4
extern int strfromf32 (char *__dest, size_t __size, const char * __format,
         _Float32 __f)
     throw () __attribute__ ((__nonnull__ (3)));



extern int strfromf64 (char *__dest, size_t __size, const char * __format,
         _Float64 __f)
     throw () __attribute__ ((__nonnull__ (3)));



extern int strfromf128 (char *__dest, size_t __size, const char * __format,
   _Float128 __f)
     throw () __attribute__ ((__nonnull__ (3)));



extern int strfromf32x (char *__dest, size_t __size, const char * __format,
   _Float32x __f)
     throw () __attribute__ ((__nonnull__ (3)));



extern int strfromf64x (char *__dest, size_t __size, const char * __format,
   _Float64x __f)
     throw () __attribute__ ((__nonnull__ (3)));
# 272 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/types/locale_t.h" 1 3 4
# 22 "/usr/include/bits/types/locale_t.h" 3 4
# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4
# 28 "/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;
# 273 "/usr/include/stdlib.h" 2 3 4

extern long int strtol_l (const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

extern double strtod_l (const char *__restrict __nptr,
   char **__restrict __endptr, locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (const char *__restrict __nptr,
         char **__restrict __endptr, locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));
# 316 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));



extern _Float64 strtof64_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));



extern _Float128 strtof128_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));



extern _Float32x strtof32x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));



extern _Float64x strtof64x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));
# 360 "/usr/include/stdlib.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) atoi (const char *__nptr) throw ()
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__leaf__)) atol (const char *__nptr) throw ()
{
  return strtol (__nptr, (char **) __null, 10);
}


__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__leaf__)) atoll (const char *__nptr) throw ()
{
  return strtoll (__nptr, (char **) __null, 10);
}
# 385 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () __attribute__ ((__warn_unused_result__));


extern long int a64l (const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));




# 1 "/usr/include/sys/types.h" 1 3 4
# 27 "/usr/include/sys/types.h" 3 4
extern "C" {

# 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
# 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 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;
# 30 "/usr/include/sys/types.h" 2 3 4



typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;


typedef __loff_t loff_t;






typedef __ino64_t ino_t;




typedef __ino64_t ino64_t;




typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;







typedef __off64_t off_t;




typedef __off64_t off64_t;




typedef __pid_t pid_t;





typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;




# 1 "/usr/include/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






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 __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 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 __builtin_bswap16 (__bsx);



}






static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{

  return __builtin_bswap32 (__bsx);



}
# 69 "/usr/include/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{

  return __builtin_bswap64 (__bsx);



}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/bits/uintn-identity.h" 1 3 4
# 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
# 22 "/usr/include/bits/select.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 23 "/usr/include/bits/select.h" 2 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
# 10 "/usr/include/bits/types/struct_timespec.h" 3 4
struct timespec
{
  __time_t tv_sec;



  __syscall_slong_t tv_nsec;
# 26 "/usr/include/bits/types/struct_timespec.h" 3 4
};
# 40 "/usr/include/sys/select.h" 2 3 4
# 49 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 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" {
# 101 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);
# 113 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
      fd_set *__restrict __writefds,
      fd_set *__restrict __exceptfds,
      const struct timespec *__restrict __timeout,
      const __sigset_t *__restrict __sigmask);





# 1 "/usr/include/bits/select2.h" 1 3 4
# 24 "/usr/include/bits/select2.h" 3 4
extern long int __fdelt_chk (long int __d);
extern long int __fdelt_warn (long int __d)
  __attribute__((__warning__ ("bit outside of fd_set selected")));
# 124 "/usr/include/sys/select.h" 2 3 4


}
# 180 "/usr/include/sys/types.h" 2 3 4





typedef __blksize_t blksize_t;
# 205 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt_t;



typedef __fsblkcnt64_t fsblkcnt_t;



typedef __fsfilcnt64_t fsfilcnt_t;





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




typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;

typedef struct __pthread_internal_slist
{
  struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 74 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/struct_mutex.h" 1 3 4
# 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
};
# 75 "/usr/include/bits/thread-shared-types.h" 2 3 4
# 87 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4
# 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
};
# 88 "/usr/include/bits/thread-shared-types.h" 2 3 4




struct __pthread_cond_s
{
  __extension__ union
  {
    __extension__ unsigned long long int __wseq;
    struct
    {
      unsigned int __low;
      unsigned int __high;
    } __wseq32;
  };
  __extension__ union
  {
    __extension__ unsigned long long int __g1_start;
    struct
    {
      unsigned int __low;
      unsigned int __high;
    } __g1_start32;
  };
  unsigned int __g_refs[2] ;
  unsigned int __g_size[2];
  unsigned int __g1_orig_size;
  unsigned int __wrefs;
  unsigned int __g_signals[2];
};
# 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


}
# 395 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) throw ();


extern void srandom (unsigned int __seed) throw ();





extern char *initstate (unsigned int __seed, char *__statebuf,
   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     throw () __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
   size_t __statelen,
   struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
         struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();



extern int rand_r (unsigned int *__seed) throw ();







extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));


extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    __extension__ unsigned long long int __a;

  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int lrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int mrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
        struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__))
     __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_result__));

extern void *calloc (size_t __nmemb, size_t __size)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) __attribute__ ((__warn_unused_result__));






extern void *realloc (void *__ptr, size_t __size)
     throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));







extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     throw () __attribute__ ((__warn_unused_result__))
     __attribute__ ((__alloc_size__ (2, 3)));



extern void free (void *__ptr) throw ();


# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) throw ();





}
# 569 "/usr/include/stdlib.h" 2 3 4





extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__))
     __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_result__));




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));




extern void *aligned_alloc (size_t __alignment, size_t __size)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) __attribute__ ((__warn_unused_result__));



extern void abort (void) throw () __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));




extern "C++" int at_quick_exit (void (*__func) (void))
     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
# 610 "/usr/include/stdlib.h" 3 4
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     throw () __attribute__ ((__nonnull__ (1)));





extern void exit (int __status) throw () __attribute__ ((__noreturn__));





extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));





extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));




extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));




extern char *secure_getenv (const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));






extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));





extern int setenv (const char *__name, const char *__value, int __replace)
     throw () __attribute__ ((__nonnull__ (2)));


extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));






extern int clearenv (void) throw ();
# 675 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 691 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 713 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __asm__ ("" "mkstemps64")
                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 731 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 745 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __asm__ ("" "mkostemp64")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 766 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags) __asm__ ("" "mkostemps64")

     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 784 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) __attribute__ ((__warn_unused_result__));





extern char *canonicalize_file_name (const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 800 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
         char *__restrict __resolved) throw () __attribute__ ((__warn_unused_result__));






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))) __attribute__ ((__warn_unused_result__));


# 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 = (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;
}
# 826 "/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) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern long int labs (long int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));


__extension__ extern long long int llabs (long long int __x)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));






extern div_t div (int __numer, int __denom)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
extern ldiv_t ldiv (long int __numer, long int __denom)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));


__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
# 872 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));




extern char *gcvt (double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));





extern int mblen (const char *__s, size_t __n) throw ();


extern int mbtowc (wchar_t *__restrict __pwc,
     const char *__restrict __s, size_t __n) throw ();


extern int wctomb (char *__s, wchar_t __wchar) throw ();



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
   const char *__restrict __s, size_t __n) throw ();

extern size_t wcstombs (char *__restrict __s,
   const wchar_t *__restrict __pwcs, size_t __n)
     throw ();







extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 957 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
        char *const *__restrict __tokens,
        char **__restrict __valuep)
     throw () __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));







extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));







extern int grantpt (int __fd) throw ();



extern int unlockpt (int __fd) throw ();




extern char *ptsname (int __fd) throw () __attribute__ ((__warn_unused_result__));






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     throw () __attribute__ ((__nonnull__ (1)));
# 1013 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
# 24 "/usr/include/bits/stdlib-float.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) double
__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
{
  return strtod (__nptr, (char **) __null);
}
# 1014 "/usr/include/stdlib.h" 2 3 4



# 1 "/usr/include/bits/stdlib.h" 1 3 4
# 23 "/usr/include/bits/stdlib.h" 3 4
extern char *__realpath_chk (const char *__restrict __name,
        char *__restrict __resolved,
        size_t __resolvedlen) throw () __attribute__ ((__warn_unused_result__));
extern char *__realpath_alias (const char *__restrict __name, char *__restrict __resolved) throw () __asm__ ("" "realpath")

                                                 __attribute__ ((__warn_unused_result__));
extern char *__realpath_chk_warn (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) throw () __asm__ ("" "__realpath_chk")


                                                __attribute__ ((__warn_unused_result__))
     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
                                      ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__leaf__)) realpath (const char *__restrict __name, char *__restrict __resolved) throw ()
{
  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
    {




      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
    }

  return __realpath_alias (__name, __resolved);
}


extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ptsname_r")

     __attribute__ ((__nonnull__ (2)));
extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ptsname_r_chk")


     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
                   ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __ptsname_r_alias (__fd, __buf, __buflen);
}


extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
  throw () __attribute__ ((__warn_unused_result__));
extern int __wctomb_alias (char *__s, wchar_t __wchar) throw () __asm__ ("" "wctomb")
              __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) int
__attribute__ ((__leaf__)) wctomb (char *__s, wchar_t __wchar) throw ()
{







  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
  return __wctomb_alias (__s, __wchar);
}


extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
         const char *__restrict __src,
         size_t __len, size_t __dstlen) throw ();
extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) throw () __asm__ ("" "mbstowcs")


                                  ;
extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__mbstowcs_chk")



     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __mbstowcs_chk (__dst, __src, __len,
          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));

      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
 return __mbstowcs_chk_warn (__dst, __src, __len,
         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
    }
  return __mbstowcs_alias (__dst, __src, __len);
}


extern size_t __wcstombs_chk (char *__restrict __dst,
         const wchar_t *__restrict __src,
         size_t __len, size_t __dstlen) throw ();
extern size_t __wcstombs_alias (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) throw () __asm__ ("" "wcstombs")


                                  ;
extern size_t __wcstombs_chk_warn (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__wcstombs_chk")



     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
      if (__len > __builtin_object_size (__dst, 2 > 1))
 return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
    }
  return __wcstombs_alias (__dst, __src, __len);
}
# 1018 "/usr/include/stdlib.h" 2 3 4





}
# 76 "/usr/include/c++/10/cstdlib" 2 3

# 1 "/usr/include/c++/10/bits/std_abs.h" 1 3
# 33 "/usr/include/c++/10/bits/std_abs.h" 3
       
# 34 "/usr/include/c++/10/bits/std_abs.h" 3
# 46 "/usr/include/c++/10/bits/std_abs.h" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::abs;


  inline long
  abs(long __i) { return __builtin_labs(__i); }



  inline long long
  abs(long long __x) { return __builtin_llabs (__x); }
# 70 "/usr/include/c++/10/bits/std_abs.h" 3
  inline constexpr double
  abs(double __x)
  { return __builtin_fabs(__x); }

  inline constexpr float
  abs(float __x)
  { return __builtin_fabsf(__x); }

  inline constexpr long double
  abs(long double __x)
  { return __builtin_fabsl(__x); }
# 107 "/usr/include/c++/10/bits/std_abs.h" 3

}
}
# 78 "/usr/include/c++/10/cstdlib" 2 3
# 121 "/usr/include/c++/10/cstdlib" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::div_t;
  using ::ldiv_t;

  using ::abort;

  using ::aligned_alloc;

  using ::atexit;


  using ::at_quick_exit;


  using ::atof;
  using ::atoi;
  using ::atol;
  using ::bsearch;
  using ::calloc;
  using ::div;
  using ::exit;
  using ::free;
  using ::getenv;
  using ::labs;
  using ::ldiv;
  using ::malloc;

  using ::mblen;
  using ::mbstowcs;
  using ::mbtowc;

  using ::qsort;


  using ::quick_exit;


  using ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;

  using ::wcstombs;
  using ::wctomb;



  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }




}
# 195 "/usr/include/c++/10/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  using ::lldiv_t;





  using ::_Exit;



  using ::llabs;

  inline lldiv_t
  div(long long __n, long long __d)
  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }

  using ::lldiv;
# 227 "/usr/include/c++/10/cstdlib" 3
  using ::atoll;
  using ::strtoll;
  using ::strtoull;

  using ::strtof;
  using ::strtold;


}

namespace std
{

  using ::__gnu_cxx::lldiv_t;

  using ::__gnu_cxx::_Exit;

  using ::__gnu_cxx::llabs;
  using ::__gnu_cxx::div;
  using ::__gnu_cxx::lldiv;

  using ::__gnu_cxx::atoll;
  using ::__gnu_cxx::strtof;
  using ::__gnu_cxx::strtoll;
  using ::__gnu_cxx::strtoull;
  using ::__gnu_cxx::strtold;
}



}
# 60 "/usr/include/c++/10/bits/stl_algo.h" 2 3
# 1 "/usr/include/c++/10/bits/algorithmfwd.h" 1 3
# 33 "/usr/include/c++/10/bits/algorithmfwd.h" 3
       
# 34 "/usr/include/c++/10/bits/algorithmfwd.h" 3
# 42 "/usr/include/c++/10/bits/algorithmfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 199 "/usr/include/c++/10/bits/algorithmfwd.h" 3
  template<typename _IIter, typename _Predicate>
   
    bool
    all_of(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Predicate>
   
    bool
    any_of(_IIter, _IIter, _Predicate);


  template<typename _FIter, typename _Tp>
   
    bool
    binary_search(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
   
    bool
    binary_search(_FIter, _FIter, const _Tp&, _Compare);


  template<typename _Tp>
    constexpr
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);


  template<typename _IIter, typename _OIter>
   
    _OIter
    copy(_IIter, _IIter, _OIter);

  template<typename _BIter1, typename _BIter2>
   
    _BIter2
    copy_backward(_BIter1, _BIter1, _BIter2);


  template<typename _IIter, typename _OIter, typename _Predicate>
   
    _OIter
    copy_if(_IIter, _IIter, _OIter, _Predicate);

  template<typename _IIter, typename _Size, typename _OIter>
   
    _OIter
    copy_n(_IIter, _Size, _OIter);





  template<typename _FIter, typename _Tp>
   
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
   
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _FIter, typename _Tp>
   
    void
    fill(_FIter, _FIter, const _Tp&);

  template<typename _OIter, typename _Size, typename _Tp>
   
    _OIter
    fill_n(_OIter, _Size, const _Tp&);



  template<typename _FIter1, typename _FIter2>
   
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
   
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);





  template<typename _IIter, typename _Predicate>
   
    _IIter
    find_if_not(_IIter, _IIter, _Predicate);






  template<typename _IIter1, typename _IIter2>
   
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
   
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _BIter>
    void
    inplace_merge(_BIter, _BIter, _BIter);

  template<typename _BIter, typename _Compare>
    void
    inplace_merge(_BIter, _BIter, _BIter, _Compare);


  template<typename _RAIter>
   
    bool
    is_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    bool
    is_heap(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>
   
    _RAIter
    is_heap_until(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    _RAIter
    is_heap_until(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _Predicate>
   
    bool
    is_partitioned(_IIter, _IIter, _Predicate);

  template<typename _FIter1, typename _FIter2>
   
    bool
    is_permutation(_FIter1, _FIter1, _FIter2);

  template<typename _FIter1, typename _FIter2,
    typename _BinaryPredicate>
   
    bool
    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);

  template<typename _FIter>
   
    bool
    is_sorted(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
   
    bool
    is_sorted(_FIter, _FIter, _Compare);

  template<typename _FIter>
   
    _FIter
    is_sorted_until(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
   
    _FIter
    is_sorted_until(_FIter, _FIter, _Compare);


  template<typename _FIter1, typename _FIter2>
   
    void
    iter_swap(_FIter1, _FIter2);

  template<typename _FIter, typename _Tp>
   
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
   
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _RAIter>
   
    void
    make_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    void
    make_heap(_RAIter, _RAIter, _Compare);

  template<typename _Tp>
    constexpr
    const _Tp&
    max(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    max(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    constexpr
    const _Tp&
    min(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    min(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    constexpr
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&, _Compare);

  template<typename _FIter>
    constexpr
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter, _Compare);

  template<typename _Tp>
    constexpr
    _Tp
    min(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    _Tp
    min(initializer_list<_Tp>, _Compare);

  template<typename _Tp>
    constexpr
    _Tp
    max(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    _Tp
    max(initializer_list<_Tp>, _Compare);

  template<typename _Tp>
    constexpr
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>, _Compare);




  template<typename _BIter>
   
    bool
    next_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
   
    bool
    next_permutation(_BIter, _BIter, _Compare);


  template<typename _IIter, typename _Predicate>
   
    bool
    none_of(_IIter, _IIter, _Predicate);





  template<typename _IIter, typename _RAIter>
   
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

  template<typename _IIter, typename _RAIter, typename _Compare>
   
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);




  template<typename _IIter, typename _OIter1,
    typename _OIter2, typename _Predicate>
   
    pair<_OIter1, _OIter2>
    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);

  template<typename _FIter, typename _Predicate>
   
    _FIter
    partition_point(_FIter, _FIter, _Predicate);


  template<typename _RAIter>
   
    void
    pop_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    void
    pop_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter>
   
    bool
    prev_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
   
    bool
    prev_permutation(_BIter, _BIter, _Compare);

  template<typename _RAIter>
   
    void
    push_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    void
    push_heap(_RAIter, _RAIter, _Compare);



  template<typename _FIter, typename _Tp>
   
    _FIter
    remove(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Predicate>
   
    _FIter
    remove_if(_FIter, _FIter, _Predicate);

  template<typename _IIter, typename _OIter, typename _Tp>
   
    _OIter
    remove_copy(_IIter, _IIter, _OIter, const _Tp&);

  template<typename _IIter, typename _OIter, typename _Predicate>
   
    _OIter
    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);



  template<typename _IIter, typename _OIter, typename _Tp>
   
    _OIter
    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
   
    _OIter
    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);



  template<typename _BIter>
   
    void
    reverse(_BIter, _BIter);

  template<typename _BIter, typename _OIter>
   
    _OIter
    reverse_copy(_BIter, _BIter, _OIter);

  inline namespace _V2
  {
    template<typename _FIter>
     
      _FIter
      rotate(_FIter, _FIter, _FIter);
  }

  template<typename _FIter, typename _OIter>
   
    _OIter
    rotate_copy(_FIter, _FIter, _FIter, _OIter);
# 625 "/usr/include/c++/10/bits/algorithmfwd.h" 3
  template<typename _RAIter, typename _UGenerator>
    void
    shuffle(_RAIter, _RAIter, _UGenerator&&);


  template<typename _RAIter>
   
    void
    sort_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    void
    sort_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
    _BIter
    stable_partition(_BIter, _BIter, _Predicate);
# 658 "/usr/include/c++/10/bits/algorithmfwd.h" 3
  template<typename _FIter1, typename _FIter2>
   
    _FIter2
    swap_ranges(_FIter1, _FIter1, _FIter2);



  template<typename _FIter>
   
    _FIter
    unique(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
   
    _FIter
    unique(_FIter, _FIter, _BinaryPredicate);



  template<typename _FIter, typename _Tp>
   
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
   
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&, _Compare);



  template<typename _FIter>
   
    _FIter
    adjacent_find(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
   
    _FIter
    adjacent_find(_FIter, _FIter, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
   
    typename iterator_traits<_IIter>::difference_type
    count(_IIter, _IIter, const _Tp&);

  template<typename _IIter, typename _Predicate>
   
    typename iterator_traits<_IIter>::difference_type
    count_if(_IIter, _IIter, _Predicate);

  template<typename _IIter1, typename _IIter2>
   
    bool
    equal(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
   
    bool
    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
   
    _IIter
    find(_IIter, _IIter, const _Tp&);

  template<typename _FIter1, typename _FIter2>
   
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
   
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _IIter, typename _Predicate>
   
    _IIter
    find_if(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Funct>
   
    _Funct
    for_each(_IIter, _IIter, _Funct);

  template<typename _FIter, typename _Generator>
   
    void
    generate(_FIter, _FIter, _Generator);

  template<typename _OIter, typename _Size, typename _Generator>
   
    _OIter
    generate_n(_OIter, _Size, _Generator);

  template<typename _IIter1, typename _IIter2>
   
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
   
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    max_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    max_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
   
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
   
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    min_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    min_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2>
   
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
   
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _RAIter>
   
    void
    nth_element(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    void
    nth_element(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _RAIter>
   
    void
    partial_sort(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    void
    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
   
    _BIter
    partition(_BIter, _BIter, _Predicate);

  template<typename _RAIter>
    void
    random_shuffle(_RAIter, _RAIter);

  template<typename _RAIter, typename _Generator>
    void
    random_shuffle(_RAIter, _RAIter,

     _Generator&&);




  template<typename _FIter, typename _Tp>
   
    void
    replace(_FIter, _FIter, const _Tp&, const _Tp&);

  template<typename _FIter, typename _Predicate, typename _Tp>
   
    void
    replace_if(_FIter, _FIter, _Predicate, const _Tp&);

  template<typename _FIter1, typename _FIter2>
   
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
   
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _FIter, typename _Size, typename _Tp>
   
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&);

  template<typename _FIter, typename _Size, typename _Tp,
    typename _BinaryPredicate>
   
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

  template<typename _IIter1, typename _IIter2, typename _OIter>
   
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
   
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
   
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
   
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
   
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
   
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
        _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
   
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
   
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _RAIter>
   
    void
    sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
   
    void
    sort(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    void
    stable_sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    stable_sort(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _OIter, typename _UnaryOperation>
   
    _OIter
    transform(_IIter, _IIter, _OIter, _UnaryOperation);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _BinaryOperation>
   
    _OIter
    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

  template<typename _IIter, typename _OIter>
   
    _OIter
    unique_copy(_IIter, _IIter, _OIter);

  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
   
    _OIter
    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);



}
# 61 "/usr/include/c++/10/bits/stl_algo.h" 2 3
# 1 "/usr/include/c++/10/bits/stl_heap.h" 1 3
# 62 "/usr/include/c++/10/bits/stl_heap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
   
    _Distance
    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
      _Compare& __comp)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__comp(__first + __parent, __first + __child))
     return __child;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return __n;
    }



  template<typename _RandomAccessIterator, typename _Distance>
   
    inline bool
    __is_heap(_RandomAccessIterator __first, _Distance __n)
    {
      __gnu_cxx::__ops::_Iter_less_iter __comp;
      return std::__is_heap_until(__first, __n, __comp) == __n;
    }

  template<typename _RandomAccessIterator, typename _Compare,
    typename _Distance>
   
    inline bool
    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
    {
      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      return std::__is_heap_until(__first, __n, __cmp) == __n;
    }

  template<typename _RandomAccessIterator>
   
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::__is_heap(__first, std::distance(__first, __last)); }

  template<typename _RandomAccessIterator, typename _Compare>
   
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      return std::__is_heap(__first, std::move(__comp),
       std::distance(__first, __last));
    }




  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
    typename _Compare>
   
    void
    __push_heap(_RandomAccessIterator __first,
  _Distance __holeIndex, _Distance __topIndex, _Tp __value,
  _Compare& __comp)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
 {
   *(__first + __holeIndex) = std::move(*(__first + __parent));
   __holeIndex = __parent;
   __parent = (__holeIndex - 1) / 2;
 }
      *(__first + __holeIndex) = std::move(__value);
    }
# 158 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
   
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

     
      ;
      ;
      ;

      __gnu_cxx::__ops::_Iter_less_val __comp;
      _ValueType __value = std::move(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), std::move(__value), __comp);
    }
# 194 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

      ;
      ;
      ;

      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
 __cmp(std::move(__comp));
      _ValueType __value = std::move(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), std::move(__value), __cmp);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Tp, typename _Compare>
   
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value, _Compare __comp)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   if (__comp(__first + __secondChild,
       __first + (__secondChild - 1)))
     __secondChild--;
   *(__first + __holeIndex) = std::move(*(__first + __secondChild));
   __holeIndex = __secondChild;
 }
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
                                  ;
   __holeIndex = __secondChild - 1;
 }
      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
 __cmp(std::move(__comp));
      std::__push_heap(__first, __holeIndex, __topIndex,
         std::move(__value), __cmp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Compare& __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      _ValueType __value = std::move(*__result);
      *__result = std::move(*__first);
      std::__adjust_heap(__first, _DistanceType(0),
    _DistanceType(__last - __first),
    std::move(__value), __comp);
    }
# 279 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
   
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      do { if (! (__builtin_expect(__first != __last, true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_heap.h", 289, __PRETTY_FUNCTION__, "__builtin_expect(__first != __last, true)"); } while (false);
      ;
      ;
      ;

      if (__last - __first > 1)
 {
   --__last;
   __gnu_cxx::__ops::_Iter_less_iter __comp;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 313 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {

     

      ;
      ;
      do { if (! (__builtin_expect(__first != __last, true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_heap.h", 324, __PRETTY_FUNCTION__, "__builtin_expect(__first != __last, true)"); } while (false);
      ;

      if (__last - __first > 1)
 {
   typedef __decltype(__comp) _Cmp;
   __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
   --__last;
   std::__pop_heap(__first, __last, __last, __cmp);
 }
    }

  template<typename _RandomAccessIterator, typename _Compare>
   
    void
    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare& __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   _ValueType __value = std::move(*(__first + __parent));
   std::__adjust_heap(__first, __parent, __len, std::move(__value),
        __comp);
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 371 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
   
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;
      ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      std::__make_heap(__first, __last, __comp);
    }
# 398 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {

     

      ;
      ;

      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      std::__make_heap(__first, __last, __cmp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
   
    void
    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare& __comp)
    {
      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 436 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
   
    inline void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;
      ;
      ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      std::__sort_heap(__first, __last, __comp);
    }
# 464 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {

     

      ;
      ;
      ;

      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      std::__sort_heap(__first, __last, __cmp);
    }
# 493 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
   
    inline _RandomAccessIterator
    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;
      ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      return __first +
 std::__is_heap_until(__first, std::distance(__first, __last), __comp);
    }
# 522 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline _RandomAccessIterator
    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {

     

      ;
      ;

      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      return __first
 + std::__is_heap_until(__first, std::distance(__first, __last), __cmp);
    }
# 547 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
   
    inline bool
    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::is_heap_until(__first, __last) == __last; }
# 561 "/usr/include/c++/10/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline bool
    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _Compare __comp)
    {

     

      ;
      ;

      const auto __dist = std::distance(__first, __last);
      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      return std::__is_heap_until(__first, __dist, __cmp) == __dist;
    }



}
# 62 "/usr/include/c++/10/bits/stl_algo.h" 2 3
# 1 "/usr/include/c++/10/bits/stl_tempbuf.h" 1 3
# 60 "/usr/include/c++/10/bits/stl_tempbuf.h" 3
# 1 "/usr/include/c++/10/bits/stl_construct.h" 1 3
# 59 "/usr/include/c++/10/bits/stl_construct.h" 3
# 1 "/usr/include/c++/10/new" 1 3
# 38 "/usr/include/c++/10/new" 3
       
# 39 "/usr/include/c++/10/new" 3


# 1 "/usr/include/c++/10/exception" 1 3
# 33 "/usr/include/c++/10/exception" 3
       
# 34 "/usr/include/c++/10/exception" 3

#pragma GCC visibility push(default)


# 1 "/usr/include/c++/10/bits/exception.h" 1 3
# 34 "/usr/include/c++/10/bits/exception.h" 3
       
# 35 "/usr/include/c++/10/bits/exception.h" 3

#pragma GCC visibility push(default)



extern "C++" {

namespace std
{
# 60 "/usr/include/c++/10/bits/exception.h" 3
  class exception
  {
  public:
    exception() noexcept { }
    virtual ~exception() noexcept;

    exception(const exception&) = default;
    exception& operator=(const exception&) = default;
    exception(exception&&) = default;
    exception& operator=(exception&&) = default;




    virtual const char*
    what() const noexcept;
  };

}

}

#pragma GCC visibility pop
# 39 "/usr/include/c++/10/exception" 2 3

extern "C++" {

namespace std
{






  class bad_exception : public exception
  {
  public:
    bad_exception() noexcept { }



    virtual ~bad_exception() noexcept;


    virtual const char*
    what() const noexcept;
  };


  typedef void (*terminate_handler) ();


  typedef void (*unexpected_handler) ();


  terminate_handler set_terminate(terminate_handler) noexcept;



  terminate_handler get_terminate() noexcept;




  void terminate() noexcept __attribute__ ((__noreturn__));


  unexpected_handler set_unexpected(unexpected_handler) noexcept;



  unexpected_handler get_unexpected() noexcept;




  void unexpected() __attribute__ ((__noreturn__));
# 105 "/usr/include/c++/10/exception" 3
  [[__deprecated__]]
  bool uncaught_exception() noexcept __attribute__ ((__pure__));




  int uncaught_exceptions() noexcept __attribute__ ((__pure__));



}

namespace __gnu_cxx
{

# 137 "/usr/include/c++/10/exception" 3
  void __verbose_terminate_handler();


}

}

#pragma GCC visibility pop


# 1 "/usr/include/c++/10/bits/exception_ptr.h" 1 3
# 34 "/usr/include/c++/10/bits/exception_ptr.h" 3
#pragma GCC visibility push(default)



# 1 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 1 3
# 34 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
       
# 35 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3

#pragma GCC visibility push(default)

# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 143 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 415 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 3 4
typedef struct {
  long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
  long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
# 426 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 3 4
} max_align_t;






  typedef decltype(nullptr) nullptr_t;
# 39 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 2 3
# 50 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3
namespace std
{
  class type_info;
}

namespace __cxxabiv1
{
  struct __cxa_refcounted_exception;

  extern "C"
    {

      void*
      __cxa_allocate_exception(size_t) noexcept;

      void
      __cxa_free_exception(void*) noexcept;


      __cxa_refcounted_exception*
      __cxa_init_primary_exception(void *object, std::type_info *tinfo,
                void ( *dest) (void *)) noexcept;

    }
}



#pragma GCC visibility pop
# 39 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/typeinfo" 1 3
# 32 "/usr/include/c++/10/typeinfo" 3
       
# 33 "/usr/include/c++/10/typeinfo" 3



# 1 "/usr/include/c++/10/bits/hash_bytes.h" 1 3
# 33 "/usr/include/c++/10/bits/hash_bytes.h" 3
       
# 34 "/usr/include/c++/10/bits/hash_bytes.h" 3



namespace std
{







  size_t
  _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);





  size_t
  _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);


}
# 37 "/usr/include/c++/10/typeinfo" 2 3


#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 80 "/usr/include/c++/10/typeinfo" 3
namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();



    const char* name() const noexcept
    { return __name[0] == '*' ? __name + 1 : __name; }
# 115 "/usr/include/c++/10/typeinfo" 3
    bool before(const type_info& __arg) const noexcept
    { return (__name[0] == '*' && __arg.__name[0] == '*')
 ? __name < __arg.__name
 : __builtin_strcmp (__name, __arg.__name) < 0; }

    bool operator==(const type_info& __arg) const noexcept
    {
      return ((__name == __arg.__name)
       || (__name[0] != '*' &&
    __builtin_strcmp (__name, __arg.__name) == 0));
    }
# 136 "/usr/include/c++/10/typeinfo" 3
    bool operator!=(const type_info& __arg) const noexcept
    { return !operator==(__arg); }


    size_t hash_code() const noexcept
    {

      return _Hash_bytes(name(), __builtin_strlen(name()),
    static_cast<size_t>(0xc70f6907UL));



    }



    virtual bool __is_pointer_p() const;


    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
       unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
        void **__obj_ptr) const;

  protected:
    const char *__name;

    explicit type_info(const char *__n): __name(__n) { }

  private:

    type_info& operator=(const type_info&);
    type_info(const type_info&);
  };







  class bad_cast : public exception
  {
  public:
    bad_cast() noexcept { }



    virtual ~bad_cast() noexcept;


    virtual const char* what() const noexcept;
  };





  class bad_typeid : public exception
  {
  public:
    bad_typeid () noexcept { }



    virtual ~bad_typeid() noexcept;


    virtual const char* what() const noexcept;
  };
}

}

#pragma GCC visibility pop
# 40 "/usr/include/c++/10/bits/exception_ptr.h" 2 3
# 1 "/usr/include/c++/10/new" 1 3
# 41 "/usr/include/c++/10/bits/exception_ptr.h" 2 3

extern "C++" {

namespace std
{
  class type_info;






  namespace __exception_ptr
  {
    class exception_ptr;
  }

  using __exception_ptr::exception_ptr;





  exception_ptr current_exception() noexcept;

  template<typename _Ex>
  exception_ptr make_exception_ptr(_Ex) noexcept;


  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));

  namespace __exception_ptr
  {
    using std::rethrow_exception;





    class exception_ptr
    {
      void* _M_exception_object;

      explicit exception_ptr(void* __e) noexcept;

      void _M_addref() noexcept;
      void _M_release() noexcept;

      void *_M_get() const noexcept __attribute__ ((__pure__));

      friend exception_ptr std::current_exception() noexcept;
      friend void std::rethrow_exception(exception_ptr);
      template<typename _Ex>
      friend exception_ptr std::make_exception_ptr(_Ex) noexcept;

    public:
      exception_ptr() noexcept;

      exception_ptr(const exception_ptr&) noexcept;


      exception_ptr(nullptr_t) noexcept
      : _M_exception_object(0)
      { }

      exception_ptr(exception_ptr&& __o) noexcept
      : _M_exception_object(__o._M_exception_object)
      { __o._M_exception_object = 0; }
# 118 "/usr/include/c++/10/bits/exception_ptr.h" 3
      exception_ptr&
      operator=(const exception_ptr&) noexcept;


      exception_ptr&
      operator=(exception_ptr&& __o) noexcept
      {
        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
        return *this;
      }


      ~exception_ptr() noexcept;

      void
      swap(exception_ptr&) noexcept;
# 145 "/usr/include/c++/10/bits/exception_ptr.h" 3
      explicit operator bool() const
      { return _M_exception_object; }


      friend bool
      operator==(const exception_ptr&, const exception_ptr&)
 noexcept __attribute__ ((__pure__));

      const class std::type_info*
      __cxa_exception_type() const noexcept
 __attribute__ ((__pure__));
    };



    bool
    operator==(const exception_ptr&, const exception_ptr&)
      noexcept __attribute__ ((__pure__));

    bool
    operator!=(const exception_ptr&, const exception_ptr&)
      noexcept __attribute__ ((__pure__));

    inline void
    swap(exception_ptr& __lhs, exception_ptr& __rhs)
    { __lhs.swap(__rhs); }




    template<typename _Ex>
      inline void
      __dest_thunk(void* __x)
      { static_cast<_Ex*>(__x)->~_Ex(); }


  }


  template<typename _Ex>
    exception_ptr
    make_exception_ptr(_Ex __ex) noexcept
    {

      void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
      (void) __cxxabiv1::__cxa_init_primary_exception(
   __e, const_cast<std::type_info*>(&typeid(__ex)),
   __exception_ptr::__dest_thunk<_Ex>);
      try
 {
          ::new (__e) _Ex(__ex);
          return exception_ptr(__e);
 }
      catch(...)
 {
   __cxxabiv1::__cxa_free_exception(__e);
   return current_exception();
 }
# 215 "/usr/include/c++/10/bits/exception_ptr.h" 3
    }


}

}

#pragma GCC visibility pop
# 148 "/usr/include/c++/10/exception" 2 3
# 1 "/usr/include/c++/10/bits/nested_exception.h" 1 3
# 33 "/usr/include/c++/10/bits/nested_exception.h" 3
#pragma GCC visibility push(default)
# 42 "/usr/include/c++/10/bits/nested_exception.h" 3
extern "C++" {

namespace std
{






  class nested_exception
  {
    exception_ptr _M_ptr;

  public:
    nested_exception() noexcept : _M_ptr(current_exception()) { }

    nested_exception(const nested_exception&) noexcept = default;

    nested_exception& operator=(const nested_exception&) noexcept = default;

    virtual ~nested_exception() noexcept;

    [[noreturn]]
    void
    rethrow_nested() const
    {
      if (_M_ptr)
 rethrow_exception(_M_ptr);
      std::terminate();
    }

    exception_ptr
    nested_ptr() const noexcept
    { return _M_ptr; }
  };



  template<typename _Except>
    struct _Nested_exception : public _Except, public nested_exception
    {
      explicit _Nested_exception(const _Except& __ex)
      : _Except(__ex)
      { }

      explicit _Nested_exception(_Except&& __ex)
      : _Except(static_cast<_Except&&>(__ex))
      { }
    };




  template<typename _Tp>
    [[noreturn]]
    inline void
    __throw_with_nested_impl(_Tp&& __t, true_type)
    {
      using _Up = typename remove_reference<_Tp>::type;
      throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
    }

  template<typename _Tp>
    [[noreturn]]
    inline void
    __throw_with_nested_impl(_Tp&& __t, false_type)
    { throw std::forward<_Tp>(__t); }





  template<typename _Tp>
    [[noreturn]]
    inline void
    throw_with_nested(_Tp&& __t)
    {
      using _Up = typename decay<_Tp>::type;
      using _CopyConstructible
 = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
      static_assert(_CopyConstructible::value,
   "throw_with_nested argument must be CopyConstructible");
      using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
       __not_<is_base_of<nested_exception, _Up>>>;
      std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
    }




  template<typename _Tp>
    using __rethrow_if_nested_cond = typename enable_if<
      __and_<is_polymorphic<_Tp>,
      __or_<__not_<is_base_of<nested_exception, _Tp>>,
     is_convertible<_Tp*, nested_exception*>>>::value
    >::type;


  template<typename _Ex>
    inline __rethrow_if_nested_cond<_Ex>
    __rethrow_if_nested_impl(const _Ex* __ptr)
    {
      if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
 __ne_ptr->rethrow_nested();
    }


  inline void
  __rethrow_if_nested_impl(const void*)
  { }




  template<typename _Ex>
    inline void
    rethrow_if_nested(const _Ex& __ex)
    { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }


}

}



#pragma GCC visibility pop
# 149 "/usr/include/c++/10/exception" 2 3
# 42 "/usr/include/c++/10/new" 2 3

#pragma GCC visibility push(default)

extern "C++" {

namespace std
{






  class bad_alloc : public exception
  {
  public:
    bad_alloc() throw() { }


    bad_alloc(const bad_alloc&) = default;
    bad_alloc& operator=(const bad_alloc&) = default;




    virtual ~bad_alloc() throw();


    virtual const char* what() const throw();
  };


  class bad_array_new_length : public bad_alloc
  {
  public:
    bad_array_new_length() throw() { }



    virtual ~bad_array_new_length() throw();


    virtual const char* what() const throw();
  };



  enum class align_val_t: size_t {};


  struct nothrow_t
  {

    explicit nothrow_t() = default;

  };

  extern const nothrow_t nothrow;



  typedef void (*new_handler)();



  new_handler set_new_handler(new_handler) throw();



  new_handler get_new_handler() noexcept;

}
# 126 "/usr/include/c++/10/new" 3
[[__nodiscard__]] void* operator new(std::size_t)
  __attribute__((__externally_visible__));
[[__nodiscard__]] void* operator new[](std::size_t)
  __attribute__((__externally_visible__));
void operator delete(void*) noexcept
  __attribute__((__externally_visible__));
void operator delete[](void*) noexcept
  __attribute__((__externally_visible__));

void operator delete(void*, std::size_t) noexcept
  __attribute__((__externally_visible__));
void operator delete[](void*, std::size_t) noexcept
  __attribute__((__externally_visible__));

[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__, __malloc__));
[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__, __malloc__));
void operator delete(void*, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__));

[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t)
  __attribute__((__externally_visible__));
[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__, __malloc__));
void operator delete(void*, std::align_val_t)
  noexcept __attribute__((__externally_visible__));
void operator delete(void*, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__));
[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t)
  __attribute__((__externally_visible__));
[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__, __malloc__));
void operator delete[](void*, std::align_val_t)
  noexcept __attribute__((__externally_visible__));
void operator delete[](void*, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__));

void operator delete(void*, std::size_t, std::align_val_t)
  noexcept __attribute__((__externally_visible__));
void operator delete[](void*, std::size_t, std::align_val_t)
  noexcept __attribute__((__externally_visible__));




[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept
{ return __p; }
[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept
{ return __p; }


inline void operator delete (void*, void*) noexcept { }
inline void operator delete[](void*, void*) noexcept { }

}



namespace std
{


  template<typename _Tp>
    [[nodiscard]] constexpr _Tp*
    launder(_Tp* __p) noexcept
    { return __builtin_launder(__p); }




  template<typename _Ret, typename... _Args , bool _NE>
    void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete;
  template<typename _Ret, typename... _Args , bool _NE>
    void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete;

  void launder(void*) = delete;
  void launder(const void*) = delete;
  void launder(volatile void*) = delete;
  void launder(const volatile void*) = delete;
}
# 230 "/usr/include/c++/10/new" 3
#pragma GCC visibility pop
# 60 "/usr/include/c++/10/bits/stl_construct.h" 2 3
# 73 "/usr/include/c++/10/bits/stl_construct.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Tp>
    inline void
    destroy_at(_Tp* __location)
    {
      if constexpr (201703L > 201703L && is_array_v<_Tp>)
 {
   for (auto& __x : *__location)
     std::destroy_at(std::__addressof(__x));
 }
      else
 __location->~_Tp();
    }
# 106 "/usr/include/c++/10/bits/stl_construct.h" 3
  template<typename _Tp, typename... _Args>
    constexpr _Tp*
    _Construct(_Tp* __p, _Args&&... __args)
    {



      return ::new(static_cast<void*>(__p)) _Tp(std::forward<_Args>(__args)...);

    }
# 127 "/usr/include/c++/10/bits/stl_construct.h" 3
  template<typename _T1>
    inline void
    _Construct_novalue(_T1* __p)
    { ::new(static_cast<void*>(__p)) _T1; }

  template<typename _ForwardIterator>
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last);




  template<typename _Tp>
    constexpr inline void
    _Destroy(_Tp* __pointer)
    {



      __pointer->~_Tp();

    }

  template<bool>
    struct _Destroy_aux
    {
      template<typename _ForwardIterator>
 static void
 __destroy(_ForwardIterator __first, _ForwardIterator __last)
 {
   for (; __first != __last; ++__first)
     std::_Destroy(std::__addressof(*__first));
 }
    };

  template<>
    struct _Destroy_aux<true>
    {
      template<typename _ForwardIterator>
        static void
        __destroy(_ForwardIterator, _ForwardIterator) { }
    };






  template<typename _ForwardIterator>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;


      static_assert(is_destructible<_Value_type>::value,
      "value type is destructible");





      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
 __destroy(__first, __last);
    }

  template<bool>
    struct _Destroy_n_aux
    {
      template<typename _ForwardIterator, typename _Size>
 static _ForwardIterator
 __destroy_n(_ForwardIterator __first, _Size __count)
 {
   for (; __count > 0; (void)++__first, --__count)
     std::_Destroy(std::__addressof(*__first));
   return __first;
 }
    };

  template<>
    struct _Destroy_n_aux<true>
    {
      template<typename _ForwardIterator, typename _Size>
        static _ForwardIterator
        __destroy_n(_ForwardIterator __first, _Size __count)
 {
   std::advance(__first, __count);
   return __first;
 }
    };






  template<typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    _Destroy_n(_ForwardIterator __first, _Size __count)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;


      static_assert(is_destructible<_Value_type>::value,
      "value type is destructible");





      return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
 __destroy_n(__first, __count);
    }


  template <typename _ForwardIterator>
    inline void
    destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      std::_Destroy(__first, __last);
    }

  template <typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    destroy_n(_ForwardIterator __first, _Size __count)
    {
      return std::_Destroy_n(__first, __count);
    }



}
# 61 "/usr/include/c++/10/bits/stl_tempbuf.h" 2 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, __len * sizeof(_Tp));



      }
  }
# 98 "/usr/include/c++/10/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    pair<_Tp*, ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len) noexcept
    {
      const ptrdiff_t __max =
 __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
      if (__len > __max)
 __len = __max;

      while (__len > 0)
 {
   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
       std::nothrow));
   if (__tmp != 0)
     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
   __len /= 2;
 }
      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
    }
# 125 "/usr/include/c++/10/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    inline void
    return_temporary_buffer(_Tp* __p)
    { ::operator delete(__p); }






  template<typename _ForwardIterator, typename _Tp>
    class _Temporary_buffer
    {

     

    public:
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef pointer iterator;
      typedef ptrdiff_t size_type;

    protected:
      size_type _M_original_len;
      size_type _M_len;
      pointer _M_buffer;

    public:

      size_type
      size() const
      { return _M_len; }


      size_type
      requested_size() const
      { return _M_original_len; }


      iterator
      begin()
      { return _M_buffer; }


      iterator
      end()
      { return _M_buffer + _M_len; }





      _Temporary_buffer(_ForwardIterator __seed, size_type __original_len);

      ~_Temporary_buffer()
      {
 std::_Destroy(_M_buffer, _M_buffer + _M_len);
 std::__detail::__return_temporary_buffer(_M_buffer, _M_len);
      }

    private:

      _Temporary_buffer(const _Temporary_buffer&);

      void
      operator=(const _Temporary_buffer&);
    };


  template<bool>
    struct __uninitialized_construct_buf_dispatch
    {
      template<typename _Pointer, typename _ForwardIterator>
        static void
        __ucr(_Pointer __first, _Pointer __last,
       _ForwardIterator __seed)
        {
   if (__first == __last)
     return;

   _Pointer __cur = __first;
   try
     {
       std::_Construct(std::__addressof(*__first),
         std::move(*__seed));
       _Pointer __prev = __cur;
       ++__cur;
       for(; __cur != __last; ++__cur, ++__prev)
  std::_Construct(std::__addressof(*__cur),
    std::move(*__prev));
       *__seed = std::move(*__prev);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_construct_buf_dispatch<true>
    {
      template<typename _Pointer, typename _ForwardIterator>
        static void
        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
    };
# 243 "/usr/include/c++/10/bits/stl_tempbuf.h" 3
  template<typename _Pointer, typename _ForwardIterator>
    inline void
    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
      _ForwardIterator __seed)
    {
      typedef typename std::iterator_traits<_Pointer>::value_type
 _ValueType;

      std::__uninitialized_construct_buf_dispatch<
        __has_trivial_constructor(_ValueType)>::
   __ucr(__first, __last, __seed);
    }

  template<typename _ForwardIterator, typename _Tp>
    _Temporary_buffer<_ForwardIterator, _Tp>::
    _Temporary_buffer(_ForwardIterator __seed, size_type __original_len)
    : _M_original_len(__original_len), _M_len(0), _M_buffer(0)
    {
      std::pair<pointer, size_type> __p(
  std::get_temporary_buffer<value_type>(_M_original_len));

      if (__p.first)
 {
   try
     {
       std::__uninitialized_construct_buf(__p.first, __p.first + __p.second,
       __seed);
       _M_buffer = __p.first;
       _M_len = __p.second;
     }
   catch(...)
     {
       std::__detail::__return_temporary_buffer(__p.first, __p.second);
       throw;
     }
 }
    }


}
# 63 "/usr/include/c++/10/bits/stl_algo.h" 2 3



# 1 "/usr/include/c++/10/bits/uniform_int_dist.h" 1 3
# 35 "/usr/include/c++/10/bits/uniform_int_dist.h" 3
# 1 "/usr/include/c++/10/limits" 1 3
# 40 "/usr/include/c++/10/limits" 3
       
# 41 "/usr/include/c++/10/limits" 3
# 158 "/usr/include/c++/10/limits" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  enum float_round_style
  {
    round_indeterminate = -1,
    round_toward_zero = 0,
    round_to_nearest = 1,
    round_toward_infinity = 2,
    round_toward_neg_infinity = 3
  };







  enum float_denorm_style
  {

    denorm_indeterminate = -1,

    denorm_absent = 0,

    denorm_present = 1
  };
# 202 "/usr/include/c++/10/limits" 3
  struct __numeric_limits_base
  {


    static constexpr bool is_specialized = false;




    static constexpr int digits = 0;


    static constexpr int digits10 = 0;




    static constexpr int max_digits10 = 0;



    static constexpr bool is_signed = false;


    static constexpr bool is_integer = false;




    static constexpr bool is_exact = false;



    static constexpr int radix = 0;



    static constexpr int min_exponent = 0;



    static constexpr int min_exponent10 = 0;




    static constexpr int max_exponent = 0;



    static constexpr int max_exponent10 = 0;


    static constexpr bool has_infinity = false;



    static constexpr bool has_quiet_NaN = false;



    static constexpr bool has_signaling_NaN = false;


    static constexpr float_denorm_style has_denorm = denorm_absent;



    static constexpr bool has_denorm_loss = false;



    static constexpr bool is_iec559 = false;




    static constexpr bool is_bounded = false;
# 288 "/usr/include/c++/10/limits" 3
    static constexpr bool is_modulo = false;


    static constexpr bool traps = false;


    static constexpr bool tinyness_before = false;




    static constexpr float_round_style round_style =
          round_toward_zero;
  };
# 311 "/usr/include/c++/10/limits" 3
  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {


      static constexpr _Tp
      min() noexcept { return _Tp(); }


      static constexpr _Tp
      max() noexcept { return _Tp(); }




      static constexpr _Tp
      lowest() noexcept { return _Tp(); }




      static constexpr _Tp
      epsilon() noexcept { return _Tp(); }


      static constexpr _Tp
      round_error() noexcept { return _Tp(); }


      static constexpr _Tp
      infinity() noexcept { return _Tp(); }



      static constexpr _Tp
      quiet_NaN() noexcept { return _Tp(); }



      static constexpr _Tp
      signaling_NaN() noexcept { return _Tp(); }




      static constexpr _Tp
      denorm_min() noexcept { return _Tp(); }
    };




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

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

  template<typename _Tp>
    struct numeric_limits<const volatile _Tp>
    : public numeric_limits<_Tp> { };
# 383 "/usr/include/c++/10/limits" 3
  template<>
    struct numeric_limits<bool>
    {
      static constexpr bool is_specialized = true;

      static constexpr bool
      min() noexcept { return false; }

      static constexpr bool
      max() noexcept { return true; }


      static constexpr bool
      lowest() noexcept { return min(); }

      static constexpr int digits = 1;
      static constexpr int digits10 = 0;

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr bool
      epsilon() noexcept { return false; }

      static constexpr bool
      round_error() noexcept { return false; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr bool
      infinity() noexcept { return false; }

      static constexpr bool
      quiet_NaN() noexcept { return false; }

      static constexpr bool
      signaling_NaN() noexcept { return false; }

      static constexpr bool
      denorm_min() noexcept { return false; }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;




      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<char>
    {
      static constexpr bool is_specialized = true;

      static constexpr char
      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }

      static constexpr char
      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }


      static constexpr char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((char)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char
      epsilon() noexcept { return 0; }

      static constexpr char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr
      char infinity() noexcept { return char(); }

      static constexpr char
      quiet_NaN() noexcept { return char(); }

      static constexpr char
      signaling_NaN() noexcept { return char(); }

      static constexpr char
      denorm_min() noexcept { return static_cast<char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<signed char>
    {
      static constexpr bool is_specialized = true;

      static constexpr signed char
      min() noexcept { return -0x7f - 1; }

      static constexpr signed char
      max() noexcept { return 0x7f; }


      static constexpr signed char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr signed char
      epsilon() noexcept { return 0; }

      static constexpr signed char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr signed char
      infinity() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      quiet_NaN() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      signaling_NaN() noexcept
      { return static_cast<signed char>(0); }

      static constexpr signed char
      denorm_min() noexcept
      { return static_cast<signed char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned char>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned char
      min() noexcept { return 0; }

      static constexpr unsigned char
      max() noexcept { return 0x7f * 2U + 1; }


      static constexpr unsigned char
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned char
      epsilon() noexcept { return 0; }

      static constexpr unsigned char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned char
      infinity() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      quiet_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      signaling_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      denorm_min() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<wchar_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr wchar_t
      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }

      static constexpr wchar_t
      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }


      static constexpr wchar_t
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr wchar_t
      epsilon() noexcept { return 0; }

      static constexpr wchar_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr wchar_t
      infinity() noexcept { return wchar_t(); }

      static constexpr wchar_t
      quiet_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      signaling_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      denorm_min() noexcept { return wchar_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };
# 796 "/usr/include/c++/10/limits" 3
  template<>
    struct numeric_limits<char16_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char16_t
      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }

      static constexpr char16_t
      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }

      static constexpr char16_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char16_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char16_t
      epsilon() noexcept { return 0; }

      static constexpr char16_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char16_t
      infinity() noexcept { return char16_t(); }

      static constexpr char16_t
      quiet_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      signaling_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      denorm_min() noexcept { return char16_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<char32_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char32_t
      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }

      static constexpr char32_t
      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }

      static constexpr char32_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char32_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char32_t
      epsilon() noexcept { return 0; }

      static constexpr char32_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char32_t
      infinity() noexcept { return char32_t(); }

      static constexpr char32_t
      quiet_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      signaling_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      denorm_min() noexcept { return char32_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };



  template<>
    struct numeric_limits<short>
    {
      static constexpr bool is_specialized = true;

      static constexpr short
      min() noexcept { return -0x7fff - 1; }

      static constexpr short
      max() noexcept { return 0x7fff; }


      static constexpr short
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr short
      epsilon() noexcept { return 0; }

      static constexpr short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr short
      infinity() noexcept { return short(); }

      static constexpr short
      quiet_NaN() noexcept { return short(); }

      static constexpr short
      signaling_NaN() noexcept { return short(); }

      static constexpr short
      denorm_min() noexcept { return short(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned short>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned short
      min() noexcept { return 0; }

      static constexpr unsigned short
      max() noexcept { return 0x7fff * 2U + 1; }


      static constexpr unsigned short
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned short
      epsilon() noexcept { return 0; }

      static constexpr unsigned short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned short
      infinity() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      quiet_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      signaling_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      denorm_min() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<int>
    {
      static constexpr bool is_specialized = true;

      static constexpr int
      min() noexcept { return -0x7fffffff - 1; }

      static constexpr int
      max() noexcept { return 0x7fffffff; }


      static constexpr int
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr int
      epsilon() noexcept { return 0; }

      static constexpr int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr int
      infinity() noexcept { return static_cast<int>(0); }

      static constexpr int
      quiet_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      signaling_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      denorm_min() noexcept { return static_cast<int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned int>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned int
      min() noexcept { return 0; }

      static constexpr unsigned int
      max() noexcept { return 0x7fffffff * 2U + 1; }


      static constexpr unsigned int
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned int
      epsilon() noexcept { return 0; }

      static constexpr unsigned int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned int
      infinity() noexcept { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      quiet_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      signaling_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      denorm_min() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long
      min() noexcept { return -0x7fffffffffffffffL - 1; }

      static constexpr long
      max() noexcept { return 0x7fffffffffffffffL; }


      static constexpr long
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long
      epsilon() noexcept { return 0; }

      static constexpr long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long
      infinity() noexcept { return static_cast<long>(0); }

      static constexpr long
      quiet_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      signaling_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      denorm_min() noexcept { return static_cast<long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long
      min() noexcept { return 0; }

      static constexpr unsigned long
      max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }


      static constexpr unsigned long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long
      infinity() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      quiet_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      signaling_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      denorm_min() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long long
      min() noexcept { return -0x7fffffffffffffffLL - 1; }

      static constexpr long long
      max() noexcept { return 0x7fffffffffffffffLL; }


      static constexpr long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long long
      epsilon() noexcept { return 0; }

      static constexpr long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long long
      infinity() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      quiet_NaN() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      signaling_NaN() noexcept
      { return static_cast<long long>(0); }

      static constexpr long long
      denorm_min() noexcept { return static_cast<long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long long
      min() noexcept { return 0; }

      static constexpr unsigned long long
      max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }


      static constexpr unsigned long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long long
      infinity() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      quiet_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      signaling_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      denorm_min() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };
# 1659 "/usr/include/c++/10/limits" 3
  template<>
    struct numeric_limits<float>
    {
      static constexpr bool is_specialized = true;

      static constexpr float
      min() noexcept { return 1.17549435082228750796873653722224568e-38F; }

      static constexpr float
      max() noexcept { return 3.40282346638528859811704183484516925e+38F; }


      static constexpr float
      lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; }


      static constexpr int digits = 24;
      static constexpr int digits10 = 6;

      static constexpr int max_digits10
  = (2 + (24) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr float
      epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; }

      static constexpr float
      round_error() noexcept { return 0.5F; }

      static constexpr int min_exponent = (-125);
      static constexpr int min_exponent10 = (-37);
      static constexpr int max_exponent = 128;
      static constexpr int max_exponent10 = 38;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
       = false;

      static constexpr float
      infinity() noexcept { return __builtin_huge_valf(); }

      static constexpr float
      quiet_NaN() noexcept { return __builtin_nanf(""); }

      static constexpr float
      signaling_NaN() noexcept { return __builtin_nansf(""); }

      static constexpr float
      denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before
       = false;
      static constexpr float_round_style round_style
       = round_to_nearest;
    };






  template<>
    struct numeric_limits<double>
    {
      static constexpr bool is_specialized = true;

      static constexpr double
      min() noexcept { return double(2.22507385850720138309023271733240406e-308L); }

      static constexpr double
      max() noexcept { return double(1.79769313486231570814527423731704357e+308L); }


      static constexpr double
      lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); }


      static constexpr int digits = 53;
      static constexpr int digits10 = 15;

      static constexpr int max_digits10
  = (2 + (53) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr double
      epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); }

      static constexpr double
      round_error() noexcept { return 0.5; }

      static constexpr int min_exponent = (-1021);
      static constexpr int min_exponent10 = (-307);
      static constexpr int max_exponent = 1024;
      static constexpr int max_exponent10 = 308;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
        = false;

      static constexpr double
      infinity() noexcept { return __builtin_huge_val(); }

      static constexpr double
      quiet_NaN() noexcept { return __builtin_nan(""); }

      static constexpr double
      signaling_NaN() noexcept { return __builtin_nans(""); }

      static constexpr double
      denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before
       = false;
      static constexpr float_round_style round_style
       = round_to_nearest;
    };






  template<>
    struct numeric_limits<long double>
    {
      static constexpr bool is_specialized = true;

      static constexpr long double
      min() noexcept { return 3.36210314311209350626267781732175260e-4932L; }

      static constexpr long double
      max() noexcept { return 1.18973149535723176502126385303097021e+4932L; }


      static constexpr long double
      lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; }


      static constexpr int digits = 64;
      static constexpr int digits10 = 18;

      static constexpr int max_digits10
  = (2 + (64) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr long double
      epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; }

      static constexpr long double
      round_error() noexcept { return 0.5L; }

      static constexpr int min_exponent = (-16381);
      static constexpr int min_exponent10 = (-4931);
      static constexpr int max_exponent = 16384;
      static constexpr int max_exponent10 = 4932;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
 = false;

      static constexpr long double
      infinity() noexcept { return __builtin_huge_vall(); }

      static constexpr long double
      quiet_NaN() noexcept { return __builtin_nanl(""); }

      static constexpr long double
      signaling_NaN() noexcept { return __builtin_nansl(""); }

      static constexpr long double
      denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before =
      false;
      static constexpr float_round_style round_style =
            round_to_nearest;
    };






}
# 36 "/usr/include/c++/10/bits/uniform_int_dist.h" 2 3

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


  namespace __detail
  {

    template<typename _Tp>
      inline bool
      _Power_of_2(_Tp __x)
      {
 return ((__x - 1) & __x) == 0;
      }
  }






  template<typename _IntType = int>
    class uniform_int_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "template argument must be an integral type");

    public:

      typedef _IntType result_type;

      struct param_type
      {
 typedef uniform_int_distribution<_IntType> distribution_type;

 param_type() : param_type(0) { }

 explicit
 param_type(_IntType __a,
     _IntType __b = numeric_limits<_IntType>::max())
 : _M_a(__a), _M_b(__b)
 {
   do { if (! (_M_a <= _M_b)) std::__replacement_assert("/usr/include/c++/10/bits/uniform_int_dist.h", 78, __PRETTY_FUNCTION__, "_M_a <= _M_b"); } 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 = numeric_limits<_IntType>::max())
      : _M_param(__a, __b)
      { }

      explicit
      uniform_int_distribution(const param_type& __p)
      : _M_param(__p)
      { }






      void
      reset() { }

      result_type
      a() const
      { return _M_param.a(); }

      result_type
      b() const
      { return _M_param.b(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return this->a(); }




      result_type
      max() const
      { return this->b(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
        { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const uniform_int_distribution& __d1,
   const uniform_int_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };

  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename uniform_int_distribution<_IntType>::result_type
      uniform_int_distribution<_IntType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 typedef typename _UniformRandomNumberGenerator::result_type
   _Gresult_type;
 typedef typename std::make_unsigned<result_type>::type __utype;
 typedef typename std::common_type<_Gresult_type, __utype>::type
   __uctype;

 const __uctype __urngmin = __urng.min();
 const __uctype __urngmax = __urng.max();
 const __uctype __urngrange = __urngmax - __urngmin;
 const __uctype __urange
   = __uctype(__param.b()) - __uctype(__param.a());

 __uctype __ret;

 if (__urngrange > __urange)
   {

     const __uctype __uerange = __urange + 1;
     const __uctype __scaling = __urngrange / __uerange;
     const __uctype __past = __uerange * __scaling;
     do
       __ret = __uctype(__urng()) - __urngmin;
     while (__ret >= __past);
     __ret /= __scaling;
   }
 else if (__urngrange < __urange)
   {
# 271 "/usr/include/c++/10/bits/uniform_int_dist.h" 3
     __uctype __tmp;
     do
       {
  const __uctype __uerngrange = __urngrange + 1;
  __tmp = (__uerngrange * operator()
    (__urng, param_type(0, __urange / __uerngrange)));
  __ret = __tmp + (__uctype(__urng()) - __urngmin);
       }
     while (__ret > __urange || __ret < __tmp);
   }
 else
   __ret = __uctype(__urng()) - __urngmin;

 return __ret + __param.a();
      }


  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      uniform_int_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {

 typedef typename _UniformRandomNumberGenerator::result_type
   _Gresult_type;
 typedef typename std::make_unsigned<result_type>::type __utype;
 typedef typename std::common_type<_Gresult_type, __utype>::type
   __uctype;

 const __uctype __urngmin = __urng.min();
 const __uctype __urngmax = __urng.max();
 const __uctype __urngrange = __urngmax - __urngmin;
 const __uctype __urange
   = __uctype(__param.b()) - __uctype(__param.a());

 __uctype __ret;

 if (__urngrange > __urange)
   {
     if (__detail::_Power_of_2(__urngrange + 1)
  && __detail::_Power_of_2(__urange + 1))
       {
  while (__f != __t)
    {
      __ret = __uctype(__urng()) - __urngmin;
      *__f++ = (__ret & __urange) + __param.a();
    }
       }
     else
       {

  const __uctype __uerange = __urange + 1;
  const __uctype __scaling = __urngrange / __uerange;
  const __uctype __past = __uerange * __scaling;
  while (__f != __t)
    {
      do
        __ret = __uctype(__urng()) - __urngmin;
      while (__ret >= __past);
      *__f++ = __ret / __scaling + __param.a();
    }
       }
   }
 else if (__urngrange < __urange)
   {
# 355 "/usr/include/c++/10/bits/uniform_int_dist.h" 3
     __uctype __tmp;
     while (__f != __t)
       {
  do
    {
      const __uctype __uerngrange = __urngrange + 1;
      __tmp = (__uerngrange * operator()
        (__urng, param_type(0, __urange / __uerngrange)));
      __ret = __tmp + (__uctype(__urng()) - __urngmin);
    }
  while (__ret > __urange || __ret < __tmp);
  *__f++ = __ret;
       }
   }
 else
   while (__f != __t)
     *__f++ = __uctype(__urng()) - __urngmin + __param.a();
      }




}
# 67 "/usr/include/c++/10/bits/stl_algo.h" 2 3




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



  template<typename _Iterator, typename _Compare>
   
    void
    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
      _Iterator __c, _Compare __comp)
    {
      if (__comp(__a, __b))
 {
   if (__comp(__b, __c))
     std::iter_swap(__result, __b);
   else if (__comp(__a, __c))
     std::iter_swap(__result, __c);
   else
     std::iter_swap(__result, __a);
 }
      else if (__comp(__a, __c))
 std::iter_swap(__result, __a);
      else if (__comp(__b, __c))
 std::iter_swap(__result, __c);
      else
 std::iter_swap(__result, __b);
    }


  template<typename _InputIterator, typename _Predicate>
   
    inline _InputIterator
    __find_if(_InputIterator __first, _InputIterator __last,
       _Predicate __pred, input_iterator_tag)
    {
      while (__first != __last && !__pred(__first))
 ++__first;
      return __first;
    }


  template<typename _RandomAccessIterator, typename _Predicate>
   
    _RandomAccessIterator
    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Predicate __pred, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type
 __trip_count = (__last - __first) >> 2;

      for (; __trip_count > 0; --__trip_count)
 {
   if (__pred(__first))
     return __first;
   ++__first;

   if (__pred(__first))
     return __first;
   ++__first;

   if (__pred(__first))
     return __first;
   ++__first;

   if (__pred(__first))
     return __first;
   ++__first;
 }

      switch (__last - __first)
 {
 case 3:
   if (__pred(__first))
     return __first;
   ++__first;
 case 2:
   if (__pred(__first))
     return __first;
   ++__first;
 case 1:
   if (__pred(__first))
     return __first;
   ++__first;
 case 0:
 default:
   return __last;
 }
    }

  template<typename _Iterator, typename _Predicate>
   
    inline _Iterator
    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
    {
      return __find_if(__first, __last, __pred,
         std::__iterator_category(__first));
    }


  template<typename _InputIterator, typename _Predicate>
   
    inline _InputIterator
    __find_if_not(_InputIterator __first, _InputIterator __last,
    _Predicate __pred)
    {
      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__negate(__pred),
       std::__iterator_category(__first));
    }




  template<typename _InputIterator, typename _Predicate, typename _Distance>
   
    _InputIterator
    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
    {
      for (; __len; --__len, (void) ++__first)
 if (!__pred(__first))
   break;
      return __first;
    }
# 208 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    _ForwardIterator1
    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __predicate)
    {

      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __p1(__first2);
      if (++__p1 == __last2)
 return std::__find_if(__first1, __last1,
  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));


      _ForwardIterator1 __current = __first1;

      for (;;)
 {
   __first1 =
     std::__find_if(__first1, __last1,
  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

   if (__first1 == __last1)
     return __last1;

   _ForwardIterator2 __p = __p1;
   __current = __first1;
   if (++__current == __last1)
     return __last1;

   while (__predicate(__current, __p))
     {
       if (++__p == __last2)
  return __first1;
       if (++__current == __last1)
  return __last1;
     }
   ++__first1;
 }
      return __first1;
    }






  template<typename _ForwardIterator, typename _Integer,
    typename _UnaryPredicate>
   
    _ForwardIterator
    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
     _Integer __count, _UnaryPredicate __unary_pred,
     std::forward_iterator_tag)
    {
      __first = std::__find_if(__first, __last, __unary_pred);
      while (__first != __last)
 {
   typename iterator_traits<_ForwardIterator>::difference_type
     __n = __count;
   _ForwardIterator __i = __first;
   ++__i;
   while (__i != __last && __n != 1 && __unary_pred(__i))
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = std::__find_if(++__i, __last, __unary_pred);
 }
      return __last;
    }





  template<typename _RandomAccessIter, typename _Integer,
    typename _UnaryPredicate>
   
    _RandomAccessIter
    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
     _Integer __count, _UnaryPredicate __unary_pred,
     std::random_access_iterator_tag)
    {
      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
 _DistanceType;

      _DistanceType __tailSize = __last - __first;
      _DistanceType __remainder = __count;

      while (__remainder <= __tailSize)
 {
   __first += __remainder;
   __tailSize -= __remainder;


   _RandomAccessIter __backTrack = __first;
   while (__unary_pred(--__backTrack))
     {
       if (--__remainder == 0)
  return (__first - __count);
     }
   __remainder = __count + 1 - (__first - __backTrack);
 }
      return __last;
    }

  template<typename _ForwardIterator, typename _Integer,
    typename _UnaryPredicate>
   
    _ForwardIterator
    __search_n(_ForwardIterator __first, _ForwardIterator __last,
        _Integer __count,
        _UnaryPredicate __unary_pred)
    {
      if (__count <= 0)
 return __first;

      if (__count == 1)
 return std::__find_if(__first, __last, __unary_pred);

      return std::__search_n_aux(__first, __last, __count, __unary_pred,
     std::__iterator_category(__first));
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag,
        _BinaryPredicate __comp)
    {
      if (__first2 == __last2)
 return __last1;

      _ForwardIterator1 __result = __last1;
      while (1)
 {
   _ForwardIterator1 __new_result
     = std::__search(__first1, __last1, __first2, __last2, __comp);
   if (__new_result == __last1)
     return __result;
   else
     {
       __result = __new_result;
       __first1 = __new_result;
       ++__first1;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BinaryPredicate>
   
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag,
        _BinaryPredicate __comp)
    {

     

     


      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
           _RevIterator2(__last2), __rlast2,
           __comp);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }
# 434 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
   
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {

     
     
     


      ;
      ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 483 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __comp)
    {

     
     
     


      ;
      ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 519 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
   
    inline bool
    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return __last == std::find_if_not(__first, __last, __pred); }
# 537 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
   
    inline bool
    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return __last == std::find_if(__first, __last, __pred); }
# 556 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
   
    inline bool
    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return !std::none_of(__first, __last, __pred); }
# 572 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
   
    inline _InputIterator
    find_if_not(_InputIterator __first, _InputIterator __last,
  _Predicate __pred)
    {

     
     

      ;
      return std::__find_if_not(__first, __last,
    __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 597 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
   
    inline bool
    is_partitioned(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {
      __first = std::find_if_not(__first, __last, __pred);
      if (__first == __last)
 return true;
      ++__first;
      return std::none_of(__first, __last, __pred);
    }
# 619 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
   
    _ForwardIterator
    partition_point(_ForwardIterator __first, _ForwardIterator __last,
      _Predicate __pred)
    {

     
     



      ;

      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__pred(*__middle))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }


  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
   
    _OutputIterator
    __remove_copy_if(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _Predicate __pred)
    {
      for (; __first != __last; ++__first)
 if (!__pred(__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 686 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
   
    inline _OutputIterator
    remove_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, const _Tp& __value)
    {

     
     

     

      ;

      return std::__remove_copy_if(__first, __last, __result,
 __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 719 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
   
    inline _OutputIterator
    remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {

     
     

     

      ;

      return std::__remove_copy_if(__first, __last, __result,
       __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 754 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
   
    _OutputIterator
    copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {

     
     

     

      ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }

  template<typename _InputIterator, typename _Size, typename _OutputIterator>
   
    _OutputIterator
    __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result)
    {
      if (__n > 0)
 {
   while (true)
     {
       *__result = *__first;
       ++__result;
       if (--__n > 0)
  ++__first;
       else
  break;
     }
 }
      return __result;
    }

  template<typename _CharT, typename _Size>
    __enable_if_t<__is_char<_CharT>::__value, _CharT*>
    __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT>>,
        _Size, _CharT*);

  template<typename _InputIterator, typename _Size, typename _OutputIterator>
   
    _OutputIterator
    __copy_n(_InputIterator __first, _Size __n,
      _OutputIterator __result, input_iterator_tag)
    {
      return std::__niter_wrap(__result,
          __copy_n_a(__first, __n,
       std::__niter_base(__result)));
    }

  template<typename _RandomAccessIterator, typename _Size,
    typename _OutputIterator>
   
    inline _OutputIterator
    __copy_n(_RandomAccessIterator __first, _Size __n,
      _OutputIterator __result, random_access_iterator_tag)
    { return std::copy(__first, __first + __n, __result); }
# 835 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Size, typename _OutputIterator>
   
    inline _OutputIterator
    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
    {

     
     

      ;
      ;

      return std::__copy_n(__first, __n, __result,
      std::__iterator_category(__first));
    }
# 866 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator1,
    typename _OutputIterator2, typename _Predicate>
   
    pair<_OutputIterator1, _OutputIterator2>
    partition_copy(_InputIterator __first, _InputIterator __last,
     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
     _Predicate __pred)
    {

     
     

     

     

      ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   {
     *__out_true = *__first;
     ++__out_true;
   }
 else
   {
     *__out_false = *__first;
     ++__out_false;
   }

      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
    }


  template<typename _ForwardIterator, typename _Predicate>
   
    _ForwardIterator
    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred)
    {
      __first = std::__find_if(__first, __last, __pred);
      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for (; __first != __last; ++__first)
 if (!__pred(__first))
   {
     *__result = std::move(*__first);
     ++__result;
   }
      return __result;
    }
# 937 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
   
    inline _ForwardIterator
    remove(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __value)
    {

     

     

      ;

      return std::__remove_if(__first, __last,
  __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 971 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
   
    inline _ForwardIterator
    remove_if(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      return std::__remove_if(__first, __last,
         __gnu_cxx::__ops::__pred_iter(__pred));
    }

  template<typename _ForwardIterator, typename _BinaryPredicate>
   
    _ForwardIterator
    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
      _BinaryPredicate __binary_pred)
    {
      if (__first == __last)
 return __last;
      _ForwardIterator __next = __first;
      while (++__next != __last)
 {
   if (__binary_pred(__first, __next))
     return __first;
   __first = __next;
 }
      return __last;
    }

  template<typename _ForwardIterator, typename _BinaryPredicate>
   
    _ForwardIterator
    __unique(_ForwardIterator __first, _ForwardIterator __last,
      _BinaryPredicate __binary_pred)
    {

      __first = std::__adjacent_find(__first, __last, __binary_pred);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!__binary_pred(__dest, __first))
   *++__dest = std::move(*__first);
      return ++__dest;
    }
# 1040 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
   
    inline _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last)
    {

     

     

      ;

      return std::__unique(__first, __last,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 1071 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
   
    inline _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {

     

     


      ;

      return std::__unique(__first, __last,
      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }







  template<typename _ForwardIterator, typename _OutputIterator,
    typename _BinaryPredicate>
   
    _OutputIterator
    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    forward_iterator_tag, output_iterator_tag)
    {

     



      _ForwardIterator __next = __first;
      *__result = *__first;
      while (++__next != __last)
 if (!__binary_pred(__first, __next))
   {
     __first = __next;
     *++__result = *__first;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
   
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, output_iterator_tag)
    {

     



      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
 __rebound_pred
 = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
      *__result = __value;
      while (++__first != __last)
 if (!__rebound_pred(__first, __value))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
   
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, forward_iterator_tag)
    {

     


      *__result = *__first;
      while (++__first != __last)
 if (!__binary_pred(__result, __first))
   *++__result = *__first;
      return ++__result;
    }






  template<typename _BidirectionalIterator>
   
    void
    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {
      while (true)
 if (__first == __last || __first == --__last)
   return;
 else
   {
     std::iter_swap(__first, __last);
     ++__first;
   }
    }






  template<typename _RandomAccessIterator>
   
    void
    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
       random_access_iterator_tag)
    {
      if (__first == __last)
 return;
      --__last;
      while (__first < __last)
 {
   std::iter_swap(__first, __last);
   ++__first;
   --__last;
 }
    }
# 1232 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
   
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {

     

      ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1260 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _OutputIterator>
   
    _OutputIterator
    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
   _OutputIterator __result)
    {

     

     

      ;

      while (__first != __last)
 {
   --__last;
   *__result = *__last;
   ++__result;
 }
      return __result;
    }





  template<typename _EuclideanRingElement>
   
    _EuclideanRingElement
    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    {
      while (__n != 0)
 {
   _EuclideanRingElement __t = __m % __n;
   __m = __n;
   __n = __t;
 }
      return __m;
    }

  inline namespace _V2
  {


  template<typename _ForwardIterator>
   
    _ForwardIterator
    __rotate(_ForwardIterator __first,
      _ForwardIterator __middle,
      _ForwardIterator __last,
      forward_iterator_tag)
    {
      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      _ForwardIterator __first2 = __middle;
      do
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
 }
      while (__first2 != __last);

      _ForwardIterator __ret = __first;

      __first2 = __middle;

      while (__first2 != __last)
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
   else if (__first2 == __last)
     __first2 = __middle;
 }
      return __ret;
    }


  template<typename _BidirectionalIterator>
   
    _BidirectionalIterator
    __rotate(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {

     


      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      std::__reverse(__first, __middle, bidirectional_iterator_tag());
      std::__reverse(__middle, __last, bidirectional_iterator_tag());

      while (__first != __middle && __middle != __last)
 {
   std::iter_swap(__first, --__last);
   ++__first;
 }

      if (__first == __middle)
 {
   std::__reverse(__middle, __last, bidirectional_iterator_tag());
   return __last;
 }
      else
 {
   std::__reverse(__first, __middle, bidirectional_iterator_tag());
   return __first;
 }
    }


  template<typename _RandomAccessIterator>
   
    _RandomAccessIterator
    __rotate(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      random_access_iterator_tag)
    {

     


      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      _Distance __n = __last - __first;
      _Distance __k = __middle - __first;

      if (__k == __n - __k)
 {
   std::swap_ranges(__first, __middle, __middle);
   return __middle;
 }

      _RandomAccessIterator __p = __first;
      _RandomAccessIterator __ret = __first + (__last - __middle);

      for (;;)
 {
   if (__k < __n - __k)
     {
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = std::move(*__p);
    std::move(__p + 1, __p + __n, __p);
    *(__p + __n - 1) = std::move(__t);
    return __ret;
  }
       _RandomAccessIterator __q = __p + __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    std::iter_swap(__p, __q);
    ++__p;
    ++__q;
  }
       __n %= __k;
       if (__n == 0)
  return __ret;
       std::swap(__n, __k);
       __k = __n - __k;
     }
   else
     {
       __k = __n - __k;
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = std::move(*(__p + __n - 1));
    std::move_backward(__p, __p + __n - 1, __p + __n);
    *__p = std::move(__t);
    return __ret;
  }
       _RandomAccessIterator __q = __p + __n;
       __p = __q - __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    --__p;
    --__q;
    std::iter_swap(__p, __q);
  }
       __n %= __k;
       if (__n == 0)
  return __ret;
       std::swap(__n, __k);
     }
 }
    }
# 1492 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
   
    inline _ForwardIterator
    rotate(_ForwardIterator __first, _ForwardIterator __middle,
    _ForwardIterator __last)
    {

     

      ;
      ;

      return std::__rotate(__first, __middle, __last,
      std::__iterator_category(__first));
    }

  }
# 1530 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _OutputIterator>
   
    inline _OutputIterator
    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
  _ForwardIterator __last, _OutputIterator __result)
    {

     
     

      ;
      ;

      return std::copy(__first, __middle,
         std::copy(__middle, __last, __result));
    }


  template<typename _ForwardIterator, typename _Predicate>
   
    _ForwardIterator
    __partition(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred, forward_iterator_tag)
    {
      if (__first == __last)
 return __first;

      while (__pred(*__first))
 if (++__first == __last)
   return __first;

      _ForwardIterator __next = __first;

      while (++__next != __last)
 if (__pred(*__next))
   {
     std::iter_swap(__first, __next);
     ++__first;
   }

      return __first;
    }


  template<typename _BidirectionalIterator, typename _Predicate>
   
    _BidirectionalIterator
    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
  _Predicate __pred, bidirectional_iterator_tag)
    {
      while (true)
 {
   while (true)
     if (__first == __last)
       return __first;
     else if (__pred(*__first))
       ++__first;
     else
       break;
   --__last;
   while (true)
     if (__first == __last)
       return __first;
     else if (!bool(__pred(*__last)))
       --__last;
     else
       break;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }
# 1610 "/usr/include/c++/10/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()));
    }
# 1712 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    inline _ForwardIterator
    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      return std::__stable_partition(__first, __last,
         __gnu_cxx::__ops::__pred_iter(__pred));
    }


  template<typename _RandomAccessIterator, typename _Compare>
   
    void
    __heap_select(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last, _Compare __comp)
    {
      std::__make_heap(__first, __middle, __comp);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (__comp(__i, __first))
   std::__pop_heap(__first, __middle, __i, __comp);
    }



  template<typename _InputIterator, typename _RandomAccessIterator,
    typename _Compare>
   
    _RandomAccessIterator
    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
   _RandomAccessIterator __result_first,
   _RandomAccessIterator __result_last,
   _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _InputValueType;
      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
      typedef typename _RItTraits::difference_type _DistanceType;

      if (__result_first == __result_last)
 return __result_last;
      _RandomAccessIterator __result_real_last = __result_first;
      while (__first != __last && __result_real_last != __result_last)
 {
   *__result_real_last = *__first;
   ++__result_real_last;
   ++__first;
 }

      std::__make_heap(__result_first, __result_real_last, __comp);
      while (__first != __last)
 {
   if (__comp(__first, __result_first))
     std::__adjust_heap(__result_first, _DistanceType(0),
          _DistanceType(__result_real_last
          - __result_first),
          _InputValueType(*__first), __comp);
   ++__first;
 }
      std::__sort_heap(__result_first, __result_real_last, __comp);
      return __result_real_last;
    }
# 1800 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator>
   
    inline _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last)
    {
# 1815 "/usr/include/c++/10/bits/stl_algo.h" 3
     
     

     

     
      ;
      ;
      ;

      return std::__partial_sort_copy(__first, __last,
          __result_first, __result_last,
          __gnu_cxx::__ops::__iter_less_iter());
    }
# 1850 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator,
    typename _Compare>
   
    inline _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last,
        _Compare __comp)
    {
# 1867 "/usr/include/c++/10/bits/stl_algo.h" 3
     
     

     

     

     

      ;
      ;
      ;

      return std::__partial_sort_copy(__first, __last,
          __result_first, __result_last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }


  template<typename _RandomAccessIterator, typename _Compare>
   
    void
    __unguarded_linear_insert(_RandomAccessIterator __last,
         _Compare __comp)
    {
      typename iterator_traits<_RandomAccessIterator>::value_type
 __val = std::move(*__last);
      _RandomAccessIterator __next = __last;
      --__next;
      while (__comp(__val, __next))
 {
   *__last = std::move(*__next);
   __last = __next;
   --__next;
 }
      *__last = std::move(__val);
    }


  template<typename _RandomAccessIterator, typename _Compare>
   
    void
    __insertion_sort(_RandomAccessIterator __first,
       _RandomAccessIterator __last, _Compare __comp)
    {
      if (__first == __last) return;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   if (__comp(__i, __first))
     {
       typename iterator_traits<_RandomAccessIterator>::value_type
  __val = std::move(*__i);
       std::move_backward(__first, __i, __i + 1);
       *__first = std::move(__val);
     }
   else
     std::__unguarded_linear_insert(__i,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
 }
    }


  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    __unguarded_insertion_sort(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
    {
      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 std::__unguarded_linear_insert(__i,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }





  enum { _S_threshold = 16 };


  template<typename _RandomAccessIterator, typename _Compare>
   
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first > int(_S_threshold))
 {
   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
       __comp);
 }
      else
 std::__insertion_sort(__first, __last, __comp);
    }


  template<typename _RandomAccessIterator, typename _Compare>
   
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _RandomAccessIterator __pivot, _Compare __comp)
    {
      while (true)
 {
   while (__comp(__first, __pivot))
     ++__first;
   --__last;
   while (__comp(__pivot, __last))
     --__last;
   if (!(__first < __last))
     return __first;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }


  template<typename _RandomAccessIterator, typename _Compare>
   
    inline _RandomAccessIterator
    __unguarded_partition_pivot(_RandomAccessIterator __first,
    _RandomAccessIterator __last, _Compare __comp)
    {
      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
      __comp);
      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    __partial_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __middle,
     _RandomAccessIterator __last,
     _Compare __comp)
    {
      std::__heap_select(__first, __middle, __last, __comp);
      std::__sort_heap(__first, __middle, __comp);
    }


  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
   
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit, _Compare __comp)
    {
      while (__last - __first > int(_S_threshold))
 {
   if (__depth_limit == 0)
     {
       std::__partial_sort(__first, __last, __last, __comp);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
   __last = __cut;
 }
    }



  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {
      if (__first != __last)
 {
   std::__introsort_loop(__first, __last,
    std::__lg(__last - __first) * 2,
    __comp);
   std::__final_insertion_sort(__first, __last, __comp);
 }
    }

  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
   
    void
    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    _RandomAccessIterator __last, _Size __depth_limit,
    _Compare __comp)
    {
      while (__last - __first > 3)
 {
   if (__depth_limit == 0)
     {
       std::__heap_select(__first, __nth + 1, __last, __comp);

       std::iter_swap(__first, __nth);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last, __comp);
    }
# 2098 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
   
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {

     
     

     
                    ;

      return std::__lower_bound(__first, __last, __val,
    __gnu_cxx::__ops::__iter_comp_val(__comp));
    }

  template<typename _ForwardIterator, typename _Tp, typename _Compare>
   
    _ForwardIterator
    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__val, __middle))
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }
# 2154 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
   
    inline _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {

     
     

      ;

      return std::__upper_bound(__first, __last, __val,
    __gnu_cxx::__ops::__val_less_iter());
    }
# 2185 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
   
    inline _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {

     
     

     
                    ;

      return std::__upper_bound(__first, __last, __val,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Tp,
    typename _CompareItTp, typename _CompareTpIt>
   
    pair<_ForwardIterator, _ForwardIterator>
    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val,
    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp_it_val(__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__comp_val_it(__val, __middle))
     __len = __half;
   else
     {
       _ForwardIterator __left
  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
       std::advance(__first, __len);
       _ForwardIterator __right
  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 2258 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
   
    inline pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {

     
     

     

      ;
      ;

      return std::__equal_range(__first, __last, __val,
    __gnu_cxx::__ops::__iter_less_val(),
    __gnu_cxx::__ops::__val_less_iter());
    }
# 2295 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
   
    inline pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {

     
     

     

     
                    ;
     
                    ;

      return std::__equal_range(__first, __last, __val,
    __gnu_cxx::__ops::__iter_comp_val(__comp),
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }
# 2329 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
   
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val)
    {

     
     

      ;
      ;

      _ForwardIterator __i
 = std::__lower_bound(__first, __last, __val,
        __gnu_cxx::__ops::__iter_less_val());
      return __i != __last && !(__val < *__i);
    }
# 2363 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
   
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {

     
     

     
                    ;
     
                    ;

      _ForwardIterator __i
 = std::__lower_bound(__first, __last, __val,
        __gnu_cxx::__ops::__iter_comp_val(__comp));
      return __i != __last && !bool(__comp(__val, *__i));
    }




  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    void
    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = std::move(*__first2);
       ++__first2;
     }
   else
     {
       *__result = std::move(*__first1);
       ++__first1;
     }
   ++__result;
 }
      if (__first1 != __last1)
 std::move(__first1, __last1, __result);
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3, typename _Compare>
    void
    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result,
       _Compare __comp)
    {
      if (__first1 == __last1)
 {
   std::move_backward(__first2, __last2, __result);
   return;
 }
      else if (__first2 == __last2)
 return;

      --__last1;
      --__last2;
      while (true)
 {
   if (__comp(__last2, __last1))
     {
       *--__result = std::move(*__last1);
       if (__first1 == __last1)
  {
    std::move_backward(__first2, ++__last2, __result);
    return;
  }
       --__last1;
     }
   else
     {
       *--__result = std::move(*__last2);
       if (__first2 == __last2)
  return;
       --__last2;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _Distance>
    _BidirectionalIterator1
    __rotate_adaptive(_BidirectionalIterator1 __first,
        _BidirectionalIterator1 __middle,
        _BidirectionalIterator1 __last,
        _Distance __len1, _Distance __len2,
        _BidirectionalIterator2 __buffer,
        _Distance __buffer_size)
    {
      _BidirectionalIterator2 __buffer_end;
      if (__len1 > __len2 && __len2 <= __buffer_size)
 {
   if (__len2)
     {
       __buffer_end = std::move(__middle, __last, __buffer);
       std::move_backward(__first, __middle, __last);
       return std::move(__buffer, __buffer_end, __first);
     }
   else
     return __first;
 }
      else if (__len1 <= __buffer_size)
 {
   if (__len1)
     {
       __buffer_end = std::move(__first, __middle, __buffer);
       std::move(__middle, __last, __first);
       return std::move_backward(__buffer, __buffer_end, __last);
     }
   else
     return __last;
 }
      else
 return std::rotate(__first, __middle, __last);
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer, typename _Compare>
    void
    __merge_adaptive(_BidirectionalIterator __first,
       _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Distance __buffer_size,
       _Compare __comp)
    {
      if (__len1 <= __len2 && __len1 <= __buffer_size)
 {
   _Pointer __buffer_end = std::move(__first, __middle, __buffer);
   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
         __first, __comp);
 }
      else if (__len2 <= __buffer_size)
 {
   _Pointer __buffer_end = std::move(__middle, __last, __buffer);
   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
           __buffer_end, __last, __comp);
 }
      else
 {
   _BidirectionalIterator __first_cut = __first;
   _BidirectionalIterator __second_cut = __middle;
   _Distance __len11 = 0;
   _Distance __len22 = 0;
   if (__len1 > __len2)
     {
       __len11 = __len1 / 2;
       std::advance(__first_cut, __len11);
       __second_cut
  = std::__lower_bound(__middle, __last, *__first_cut,
         __gnu_cxx::__ops::__iter_comp_val(__comp));
       __len22 = std::distance(__middle, __second_cut);
     }
   else
     {
       __len22 = __len2 / 2;
       std::advance(__second_cut, __len22);
       __first_cut
  = std::__upper_bound(__first, __middle, *__second_cut,
         __gnu_cxx::__ops::__val_comp_iter(__comp));
       __len11 = std::distance(__first, __first_cut);
     }

   _BidirectionalIterator __new_middle
     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
         __len1 - __len11, __len22, __buffer,
         __buffer_size);
   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
    __len22, __buffer, __buffer_size, __comp);
   std::__merge_adaptive(__new_middle, __second_cut, __last,
    __len1 - __len11,
    __len2 - __len22, __buffer,
    __buffer_size, __comp);
 }
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Compare>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2,
      _Compare __comp)
    {
      if (__len1 == 0 || __len2 == 0)
 return;

      if (__len1 + __len2 == 2)
 {
   if (__comp(__middle, __first))
     std::iter_swap(__first, __middle);
   return;
 }

      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut
     = std::__lower_bound(__middle, __last, *__first_cut,
     __gnu_cxx::__ops::__iter_comp_val(__comp));
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut
     = std::__upper_bound(__first, __middle, *__second_cut,
     __gnu_cxx::__ops::__val_comp_iter(__comp));
   __len11 = std::distance(__first, __first_cut);
 }

      _BidirectionalIterator __new_middle
 = std::rotate(__first_cut, __middle, __second_cut);
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22, __comp);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22, __comp);
    }

  template<typename _BidirectionalIterator, typename _Compare>
    void
    __inplace_merge(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Compare __comp)
    {
      typedef typename iterator_traits<_BidirectionalIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
   _DistanceType;

      if (__first == __middle || __middle == __last)
 return;

      const _DistanceType __len1 = std::distance(__first, __middle);
      const _DistanceType __len2 = std::distance(__middle, __last);

      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
      _TmpBuf __buf(__first, __len1 + __len2);

      if (__buf.begin() == 0)
 std::__merge_without_buffer
   (__first, __middle, __last, __len1, __len2, __comp);
      else
 std::__merge_adaptive
   (__first, __middle, __last, __len1, __len2, __buf.begin(),
    _DistanceType(__buf.size()), __comp);
    }
# 2653 "/usr/include/c++/10/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());
    }
# 2694 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    inline void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
    {

     

     


      ;
      ;
      ;

      std::__inplace_merge(__first, __middle, __last,
      __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }



  template<typename _InputIterator, typename _OutputIterator,
    typename _Compare>
    _OutputIterator
    __move_merge(_InputIterator __first1, _InputIterator __last1,
   _InputIterator __first2, _InputIterator __last2,
   _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = std::move(*__first2);
       ++__first2;
     }
   else
     {
       *__result = std::move(*__first1);
       ++__first1;
     }
   ++__result;
 }
      return std::move(__first2, __last2, std::move(__first1, __last1, __result))

                  ;
    }

  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    typename _Distance, typename _Compare>
    void
    __merge_sort_loop(_RandomAccessIterator1 __first,
        _RandomAccessIterator1 __last,
        _RandomAccessIterator2 __result, _Distance __step_size,
        _Compare __comp)
    {
      const _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step)
 {
   __result = std::__move_merge(__first, __first + __step_size,
           __first + __step_size,
           __first + __two_step,
           __result, __comp);
   __first += __two_step;
 }
      __step_size = std::min(_Distance(__last - __first), __step_size);

      std::__move_merge(__first, __first + __step_size,
   __first + __step_size, __last, __result, __comp);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
   
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size, _Compare __comp)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size, __comp);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last, __comp);
    }

  enum { _S_chunk_size = 7 };

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
        _Pointer __buffer, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer,
     __step_size, __comp);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first,
     __step_size, __comp);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance, typename _Compare>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Pointer __buffer, _Distance __buffer_size,
      _Compare __comp)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive(__first, __middle, __buffer,
          __buffer_size, __comp);
   std::__stable_sort_adaptive(__middle, __last, __buffer,
          __buffer_size, __comp);
 }
      else
 {
   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
 }
      std::__merge_adaptive(__first, __middle, __last,
       _Distance(__middle - __first),
       _Distance(__last - __middle),
       __buffer, __buffer_size,
       __comp);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last, __comp);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle, __comp);
      std::__inplace_stable_sort(__middle, __last, __comp);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle,
      __comp);
    }
# 2867 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
   
    bool
    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(__first2, __first1))
   return false;
 else if (__comp(__first1, __first2))
   ++__first1;
 else
   {
     ++__first1;
     ++__first2;
   }

      return __first2 == __last2;
    }
# 2907 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
   
    inline bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {

     
     
     


     


      ;
      ;
      ;
      ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 2952 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
   
    inline bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
    {

     
     
     


     


      ;
      ;
      ;
      ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 2988 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
   
    bool
    __next_permutation(_BidirectionalIterator __first,
         _BidirectionalIterator __last, _Compare __comp)
    {
      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(__i, __ii))
     {
       _BidirectionalIterator __j = __last;
       while (!__comp(__i, --__j))
  {}
       std::iter_swap(__i, __j);
       std::__reverse(__ii, __last,
        std::__iterator_category(__first));
       return true;
     }
   if (__i == __first)
     {
       std::__reverse(__first, __last,
        std::__iterator_category(__first));
       return false;
     }
 }
    }
# 3038 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
   
    inline bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {

     

     

      ;
      ;

      return std::__next_permutation
 (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
    }
# 3071 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
   
    inline bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;
      ;

      return std::__next_permutation
 (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _BidirectionalIterator, typename _Compare>
   
    bool
    __prev_permutation(_BidirectionalIterator __first,
         _BidirectionalIterator __last, _Compare __comp)
    {
      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(__ii, __i))
     {
       _BidirectionalIterator __j = __last;
       while (!__comp(--__j, __i))
  {}
       std::iter_swap(__i, __j);
       std::__reverse(__ii, __last,
        std::__iterator_category(__first));
       return true;
     }
   if (__i == __first)
     {
       std::__reverse(__first, __last,
        std::__iterator_category(__first));
       return false;
     }
 }
    }
# 3141 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
   
    inline bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {

     

     

      ;
      ;

      return std::__prev_permutation(__first, __last,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 3174 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
   
    inline bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;
      ;

      return std::__prev_permutation(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }




  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
   
    _OutputIterator
    __replace_copy_if(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result,
        _Predicate __pred, const _Tp& __new_value)
    {
      for (; __first != __last; ++__first, (void)++__result)
 if (__pred(__first))
   *__result = __new_value;
 else
   *__result = *__first;
      return __result;
    }
# 3226 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
   
    inline _OutputIterator
    replace_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result,
   const _Tp& __old_value, const _Tp& __new_value)
    {

     
     

     

      ;

      return std::__replace_copy_if(__first, __last, __result,
   __gnu_cxx::__ops::__iter_equals_val(__old_value),
           __new_value);
    }
# 3261 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
   
    inline _OutputIterator
    replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
    {

     
     

     

      ;

      return std::__replace_copy_if(__first, __last, __result,
    __gnu_cxx::__ops::__pred_iter(__pred),
           __new_value);
    }

  template<typename _InputIterator, typename _Predicate>
   
    typename iterator_traits<_InputIterator>::difference_type
    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for (; __first != __last; ++__first)
 if (__pred(__first))
   ++__n;
      return __n;
    }
# 3302 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
   
    inline bool
    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
    { return std::is_sorted_until(__first, __last) == __last; }
# 3317 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
   
    inline bool
    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
       _Compare __comp)
    { return std::is_sorted_until(__first, __last, __comp) == __last; }

  template<typename _ForwardIterator, typename _Compare>
   
    _ForwardIterator
    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
        _Compare __comp)
    {
      if (__first == __last)
 return __last;

      _ForwardIterator __next = __first;
      for (++__next; __next != __last; __first = __next, (void)++__next)
 if (__comp(__next, __first))
   return __next;
      return __next;
    }
# 3348 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
   
    inline _ForwardIterator
    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;
      ;

      return std::__is_sorted_until(__first, __last,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 3373 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
   
    inline _ForwardIterator
    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
      _Compare __comp)
    {

     
     


      ;
      ;

      return std::__is_sorted_until(__first, __last,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 3399 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _Tp>
    constexpr
    inline pair<const _Tp&, const _Tp&>
    minmax(const _Tp& __a, const _Tp& __b)
    {

     

      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
         : pair<const _Tp&, const _Tp&>(__a, __b);
    }
# 3420 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    constexpr
    inline pair<const _Tp&, const _Tp&>
    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {
      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
         : pair<const _Tp&, const _Tp&>(__a, __b);
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    pair<_ForwardIterator, _ForwardIterator>
    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
       _Compare __comp)
    {
      _ForwardIterator __next = __first;
      if (__first == __last
   || ++__next == __last)
 return std::make_pair(__first, __first);

      _ForwardIterator __min{}, __max{};
      if (__comp(__next, __first))
 {
   __min = __next;
   __max = __first;
 }
      else
 {
   __min = __first;
   __max = __next;
 }

      __first = __next;
      ++__first;

      while (__first != __last)
 {
   __next = __first;
   if (++__next == __last)
     {
       if (__comp(__first, __min))
  __min = __first;
       else if (!__comp(__first, __max))
  __max = __first;
       break;
     }

   if (__comp(__next, __first))
     {
       if (__comp(__next, __min))
  __min = __next;
       if (!__comp(__first, __max))
  __max = __first;
     }
   else
     {
       if (__comp(__first, __min))
  __min = __first;
       if (!__comp(__next, __max))
  __max = __next;
     }

   __first = __next;
   ++__first;
 }

      return std::make_pair(__min, __max);
    }
# 3500 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;
      ;

      return std::__minmax_element(__first, __last,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 3528 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
    {

     
     


      ;
      ;

      return std::__minmax_element(__first, __last,
       __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }


  template<typename _Tp>
    constexpr
    inline _Tp
    min(initializer_list<_Tp> __l)
    { return *std::min_element(__l.begin(), __l.end()); }

  template<typename _Tp, typename _Compare>
    constexpr
    inline _Tp
    min(initializer_list<_Tp> __l, _Compare __comp)
    { return *std::min_element(__l.begin(), __l.end(), __comp); }

  template<typename _Tp>
    constexpr
    inline _Tp
    max(initializer_list<_Tp> __l)
    { return *std::max_element(__l.begin(), __l.end()); }

  template<typename _Tp, typename _Compare>
    constexpr
    inline _Tp
    max(initializer_list<_Tp> __l, _Compare __comp)
    { return *std::max_element(__l.begin(), __l.end(), __comp); }

  template<typename _Tp>
    constexpr
    inline pair<_Tp, _Tp>
    minmax(initializer_list<_Tp> __l)
    {
      pair<const _Tp*, const _Tp*> __p =
 std::minmax_element(__l.begin(), __l.end());
      return std::make_pair(*__p.first, *__p.second);
    }

  template<typename _Tp, typename _Compare>
    constexpr
    inline pair<_Tp, _Tp>
    minmax(initializer_list<_Tp> __l, _Compare __comp)
    {
      pair<const _Tp*, const _Tp*> __p =
 std::minmax_element(__l.begin(), __l.end(), __comp);
      return std::make_pair(*__p.first, *__p.second);
    }

  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    bool
    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
       _ForwardIterator2 __first2, _BinaryPredicate __pred)
    {


      for (; __first1 != __last1; ++__first1, (void)++__first2)
 if (!__pred(__first1, __first2))
   break;

      if (__first1 == __last1)
 return true;



      _ForwardIterator2 __last2 = __first2;
      std::advance(__last2, std::distance(__first1, __last1));
      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
 {
   if (__scan != std::__find_if(__first1, __scan,
     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
     continue;

   auto __matches
     = std::__count_if(__first2, __last2,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
   if (0 == __matches ||
       std::__count_if(__scan, __last1,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
       != __matches)
     return false;
 }
      return true;
    }
# 3641 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
   
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2)
    {

     
     
     


      ;

      return std::__is_permutation(__first1, __last1, __first2,
       __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 3673 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _BinaryPredicate __pred)
    {

     
     
     


      ;

      return std::__is_permutation(__first1, __last1, __first2,
       __gnu_cxx::__ops::__iter_comp_iter(__pred));
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    bool
    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
       _BinaryPredicate __pred)
    {
      using _Cat1
 = typename iterator_traits<_ForwardIterator1>::iterator_category;
      using _Cat2
 = typename iterator_traits<_ForwardIterator2>::iterator_category;
      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
      if (__ra_iters)
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 != __d2)
     return false;
 }



      for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
 if (!__pred(__first1, __first2))
   break;

      if (__ra_iters)
 {
   if (__first1 == __last1)
     return true;
 }
      else
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 == 0 && __d2 == 0)
     return true;
   if (__d1 != __d2)
     return false;
 }

      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
 {
   if (__scan != std::__find_if(__first1, __scan,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
     continue;

   auto __matches = std::__count_if(__first2, __last2,
  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
   if (0 == __matches
       || std::__count_if(__scan, __last1,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
       != __matches)
     return false;
 }
      return true;
    }
# 3768 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
   
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {
      ;
      ;

      return
 std::__is_permutation(__first1, __last1, __first2, __last2,
         __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 3796 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     _BinaryPredicate __pred)
    {
      ;
      ;

      return std::__is_permutation(__first1, __last1, __first2, __last2,
       __gnu_cxx::__ops::__iter_comp_iter(__pred));
    }
# 3823 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _Tp>
    constexpr const _Tp&
    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
    {
      do { if (! (!(__hi < __lo))) std::__replacement_assert("/usr/include/c++/10/bits/stl_algo.h", 3827, __PRETTY_FUNCTION__, "!(__hi < __lo)"); } while (false);
      return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
    }
# 3841 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    constexpr const _Tp&
    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
    {
      do { if (! (!__comp(__hi, __lo))) std::__replacement_assert("/usr/include/c++/10/bits/stl_algo.h", 3845, __PRETTY_FUNCTION__, "!__comp(__hi, __lo)"); } while (false);
      return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
    }
# 3873 "/usr/include/c++/10/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);
    }
# 3895 "/usr/include/c++/10/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)));
    }





# 3980 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Function>
   
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    {

     
      ;
      for (; __first != __last; ++__first)
 __f(*__first);
      return __f;
    }
# 4006 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Size, typename _Function>
    _InputIterator
    for_each_n(_InputIterator __first, _Size __n, _Function __f)
    {
      auto __n2 = std::__size_to_integer(__n);
      using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
      if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
 {
   if (__n2 <= 0)
     return __first;
   auto __last = __first + __n2;
   std::for_each(__first, __last, std::move(__f));
   return __last;
 }
      else
 {
   while (__n2-->0)
     {
       __f(*__first);
       ++__first;
     }
   return __first;
 }
    }
# 4041 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
   
    inline _InputIterator
    find(_InputIterator __first, _InputIterator __last,
  const _Tp& __val)
    {

     
     

      ;
      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__iter_equals_val(__val));
    }
# 4066 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
   
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {

     
     

      ;

      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 4098 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
   
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2)
    {

     
     
     


      ;
      ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (*__first1 == *__iter)
     return __first1;
      return __last1;
    }
# 4139 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
   
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2,
    _BinaryPredicate __comp)
    {

     
     
     


      ;
      ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (__comp(*__first1, *__iter))
     return __first1;
      return __last1;
    }
# 4172 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
   
    inline _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;

      return std::__adjacent_find(__first, __last,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 4198 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
   
    inline _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {

     
     


      ;

      return std::__adjacent_find(__first, __last,
   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }
# 4224 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
   
    inline typename iterator_traits<_InputIterator>::difference_type
    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
    {

     
     

      ;

      return std::__count_if(__first, __last,
        __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 4248 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
   
    inline typename iterator_traits<_InputIterator>::difference_type
    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {

     
     

      ;

      return std::__count_if(__first, __last,
        __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 4289 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
   
    inline _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {

     
     
     


      ;
      ;

      return std::__search(__first1, __last1, __first2, __last2,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 4329 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
   
    inline _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __predicate)
    {

     
     
     


      ;
      ;

      return std::__search(__first1, __last1, __first2, __last2,
      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
    }
# 4365 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp>
   
    inline _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val)
    {

     
     

      ;

      return std::__search_n(__first, __last, __count,
        __gnu_cxx::__ops::__iter_equals_val(__val));
    }
# 4399 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
    typename _BinaryPredicate>
   
    inline _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val,
      _BinaryPredicate __binary_pred)
    {

     
     

      ;

      return std::__search_n(__first, __last, __count,
  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
    }
# 4425 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Searcher>
    inline _ForwardIterator
    search(_ForwardIterator __first, _ForwardIterator __last,
    const _Searcher& __searcher)
    { return __searcher(__first, __last).first; }
# 4448 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _UnaryOperation>
   
    _OutputIterator
    transform(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _UnaryOperation __unary_op)
    {

     
     


      ;

      for (; __first != __last; ++__first, (void)++__result)
 *__result = __unary_op(*__first);
      return __result;
    }
# 4486 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _BinaryOperation>
   
    _OutputIterator
    transform(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _OutputIterator __result,
       _BinaryOperation __binary_op)
    {

     
     
     


      ;

      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
 *__result = __binary_op(*__first1, *__first2);
      return __result;
    }
# 4520 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
   
    void
    replace(_ForwardIterator __first, _ForwardIterator __last,
     const _Tp& __old_value, const _Tp& __new_value)
    {

     

     

     

      ;

      for (; __first != __last; ++__first)
 if (*__first == __old_value)
   *__first = __new_value;
    }
# 4553 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
   
    void
    replace_if(_ForwardIterator __first, _ForwardIterator __last,
        _Predicate __pred, const _Tp& __new_value)
    {

     

     

     

      ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   *__first = __new_value;
    }
# 4586 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
   
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {

     
     

      ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 4620 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _OutputIterator, typename _Size, typename _Generator>
   
    _OutputIterator
    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
    {

     



      typedef __decltype(std::__size_to_integer(__n)) _IntSize;
      for (_IntSize __niter = std::__size_to_integer(__n);
    __niter > 0; --__niter, (void) ++__first)
 *__first = __gen();
      return __first;
    }
# 4658 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
   
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {

     
     

     

      ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
    __gnu_cxx::__ops::__iter_equal_to_iter(),
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4699 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
   
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result,
  _BinaryPredicate __binary_pred)
    {

     
     

      ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4733 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

      ;

      if (__first != __last)
 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
   {

     _RandomAccessIterator __j = __first
     + std::rand() % ((__i - __first) + 1);
     if (__i != __j)
       std::iter_swap(__i, __j);
   }
    }
# 4768 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
    void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,

     _RandomNumberGenerator&& __rand)



    {

     

      ;

      if (__first == __last)
 return;
      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
   if (__i != __j)
     std::iter_swap(__i, __j);
 }
    }
# 4808 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
   
    inline _ForwardIterator
    partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      return std::__partition(__first, __last, __pred,
         std::__iterator_category(__first));
    }
# 4842 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
   
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last)
    {

     

     

      ;
      ;
      ;

      std::__partial_sort(__first, __middle, __last,
     __gnu_cxx::__ops::__iter_less_iter());
    }
# 4881 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
    {

     

     


      ;
      ;
      ;

      std::__partial_sort(__first, __middle, __last,
     __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 4918 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
   
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last)
    {

     

     

      ;
      ;
      ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 4958 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
  _RandomAccessIterator __last, _Compare __comp)
    {

     

     


      ;
      ;
      ;

      if (__first == __last || __nth == __last)
 return;

      std::__introselect(__first, __nth, __last,
    std::__lg(__last - __first) * 2,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 4996 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
   
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;
      ;

      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
    }
# 5027 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
   
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {

     

     


      ;
      ;

      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
   
    _OutputIterator
    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5090 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
   
    inline _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
    {

     
     
     

     

     


      ;
      ;
      ;
      ;

      return std::__merge(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 5141 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
   
    inline _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
    {

     
     
     

     

     


      ;
      ;
      ;
      ;

      return std::__merge(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
      _TmpBuf __buf(__first, std::distance(__first, __last));

      if (__buf.begin() == 0)
 std::__inplace_stable_sort(__first, __last, __comp);
      else
 std::__stable_sort_adaptive(__first, __last, __buf.begin(),
        _DistanceType(__buf.size()), __comp);
    }
# 5206 "/usr/include/c++/10/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());
    }
# 5240 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {

     

     


      ;
      ;

      std::__stable_sort(__first, __last,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
   
    _OutputIterator
    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
  _InputIterator2 __first2, _InputIterator2 __last2,
  _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first1, __first2))
     {
       *__result = *__first1;
       ++__first1;
     }
   else if (__comp(__first2, __first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
     }
   ++__result;
 }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5310 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
   
    inline _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {

     
     
     

     

     


     


      ;
      ;
      ;
      ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5361 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
   
    inline _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {

     
     
     

     

     


     


      ;
      ;
      ;
      ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
   
    _OutputIterator
    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
         _InputIterator2 __first2, _InputIterator2 __last2,
         _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(__first1, __first2))
   ++__first1;
 else if (__comp(__first2, __first1))
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 5434 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
   
    inline _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {

     
     
     

     


     


      ;
      ;
      ;
      ;

      return std::__set_intersection(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 5484 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
   
    inline _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {

     
     
     

     


     


      ;
      ;
      ;
      ;

      return std::__set_intersection(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
   
    _OutputIterator
    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(__first1, __first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(__first2, __first1))
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 5559 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
   
    inline _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
    {

     
     
     

     


     


      ;
      ;
      ;
      ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 5611 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
   
    inline _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {

     
     
     

     


     


      ;
      ;
      ;
      ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
   
    _OutputIterator
    __set_symmetric_difference(_InputIterator1 __first1,
          _InputIterator1 __last1,
          _InputIterator2 __first2,
          _InputIterator2 __last2,
          _OutputIterator __result,
          _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(__first1, __first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(__first2, __first1))
   {
     *__result = *__first2;
     ++__first2;
     ++__result;
   }
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5692 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
   
    inline _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result)
    {

     
     
     

     

     


     


      ;
      ;
      ;
      ;

      return std::__set_symmetric_difference(__first1, __last1,
     __first2, __last2, __result,
     __gnu_cxx::__ops::__iter_less_iter());
    }
# 5744 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
   
    inline _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result,
        _Compare __comp)
    {

     
     
     

     

     


     


      ;
      ;
      ;
      ;

      return std::__set_symmetric_difference(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __min_element(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
    {
      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(__first, __result))
   __result = __first;
      return __result;
    }
# 5798 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    constexpr
    _ForwardIterator
    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;
      ;

      return std::__min_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5823 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    constexpr
    inline _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {

     
     


      ;
      ;

      return std::__min_element(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __max_element(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
    {
      if (__first == __last) return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(__result, __first))
   __result = __first;
      return __result;
    }
# 5862 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    constexpr
    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;
      ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5887 "/usr/include/c++/10/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    constexpr
    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {

     
     


      ;
      ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }



  template<typename _InputIterator, typename _RandomAccessIterator,
           typename _Size, typename _UniformRandomBitGenerator>
    _RandomAccessIterator
    __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
      _RandomAccessIterator __out, random_access_iterator_tag,
      _Size __n, _UniformRandomBitGenerator&& __g)
    {
      using __distrib_type = uniform_int_distribution<_Size>;
      using __param_type = typename __distrib_type::param_type;
      __distrib_type __d{};
      _Size __sample_sz = 0;
      while (__first != __last && __sample_sz != __n)
 {
   __out[__sample_sz++] = *__first;
   ++__first;
 }
      for (auto __pop_sz = __sample_sz; __first != __last;
   ++__first, (void) ++__pop_sz)
 {
   const auto __k = __d(__g, __param_type{0, __pop_sz});
   if (__k < __n)
     __out[__k] = *__first;
 }
      return __out + __sample_sz;
    }


  template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
           typename _Size, typename _UniformRandomBitGenerator>
    _OutputIterator
    __sample(_ForwardIterator __first, _ForwardIterator __last,
      forward_iterator_tag,
      _OutputIterator __out, _Cat,
      _Size __n, _UniformRandomBitGenerator&& __g)
    {
      using __distrib_type = uniform_int_distribution<_Size>;
      using __param_type = typename __distrib_type::param_type;
      using _USize = make_unsigned_t<_Size>;
      using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
      using __uc_type = common_type_t<typename _Gen::result_type, _USize>;

      __distrib_type __d{};
      _Size __unsampled_sz = std::distance(__first, __last);
      __n = std::min(__n, __unsampled_sz);




      const __uc_type __urngrange = __g.max() - __g.min();
      if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))


        {
   while (__n != 0 && __unsampled_sz >= 2)
     {
       const pair<_Size, _Size> __p =
  __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);

       --__unsampled_sz;
       if (__p.first < __n)
  {
    *__out++ = *__first;
    --__n;
  }

       ++__first;

       if (__n == 0) break;

       --__unsampled_sz;
       if (__p.second < __n)
  {
    *__out++ = *__first;
    --__n;
  }

       ++__first;
     }
        }



      for (; __n != 0; ++__first)
 if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
   {
     *__out++ = *__first;
     --__n;
   }
      return __out;
    }




  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));
    }





}
# 63 "/usr/include/c++/10/algorithm" 2 3
# 71 "/usr/include/c++/10/algorithm" 3
# 1 "/usr/include/c++/10/pstl/glue_algorithm_defs.h" 1 3
# 13 "/usr/include/c++/10/pstl/glue_algorithm_defs.h" 3
# 1 "/usr/include/c++/10/functional" 1 3
# 46 "/usr/include/c++/10/functional" 3
       
# 47 "/usr/include/c++/10/functional" 3


# 1 "/usr/include/c++/10/bits/stl_function.h" 1 3
# 63 "/usr/include/c++/10/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 104 "/usr/include/c++/10/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    struct unary_function
    {

      typedef _Arg argument_type;


      typedef _Result result_type;
    };




  template<typename _Arg1, typename _Arg2, typename _Result>
    struct binary_function
    {

      typedef _Arg1 first_argument_type;


      typedef _Arg2 second_argument_type;


      typedef _Result result_type;
    };
# 144 "/usr/include/c++/10/bits/stl_function.h" 3
  struct __is_transparent;

  template<typename _Tp = void>
    struct plus;

  template<typename _Tp = void>
    struct minus;

  template<typename _Tp = void>
    struct multiplies;

  template<typename _Tp = void>
    struct divides;

  template<typename _Tp = void>
    struct modulus;

  template<typename _Tp = void>
    struct negate;



  template<typename _Tp>
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };


  template<typename _Tp>
    struct minus : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
    };


  template<typename _Tp>
    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x * __y; }
    };


  template<typename _Tp>
    struct divides : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x / __y; }
    };


  template<typename _Tp>
    struct modulus : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x % __y; }
    };


  template<typename _Tp>
    struct negate : public unary_function<_Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x) const
      { return -__x; }
    };





  template<>
    struct plus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct minus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct multiplies<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct divides<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct modulus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct negate<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(-std::forward<_Tp>(__t)))
 -> decltype(-std::forward<_Tp>(__t))
 { return -std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };
# 330 "/usr/include/c++/10/bits/stl_function.h" 3
  template<typename _Tp = void>
    struct equal_to;

  template<typename _Tp = void>
    struct not_equal_to;

  template<typename _Tp = void>
    struct greater;

  template<typename _Tp = void>
    struct less;

  template<typename _Tp = void>
    struct greater_equal;

  template<typename _Tp = void>
    struct less_equal;



  template<typename _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };


  template<typename _Tp>
    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
    };


  template<typename _Tp>
    struct greater : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x > __y; }
    };


  template<typename _Tp>
    struct less : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
    };


  template<typename _Tp>
    struct greater_equal : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >= __y; }
    };


  template<typename _Tp>
    struct less_equal : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
    };


  template<typename _Tp>
    struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {


 if (__builtin_is_constant_evaluated())



   return __x > __y;

 return (long unsigned int)__x > (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {


 if (__builtin_is_constant_evaluated())



   return __x < __y;

 return (long unsigned int)__x < (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {


 if (__builtin_is_constant_evaluated())



   return __x >= __y;

 return (long unsigned int)__x >= (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {


 if (__builtin_is_constant_evaluated())



   return __x <= __y;

 return (long unsigned int)__x <= (long unsigned int)__y;
      }
    };



  template<>
    struct equal_to<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct not_equal_to<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct greater<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return greater<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct less<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return less<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct greater_equal<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return greater_equal<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct less_equal<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return less_equal<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };
# 774 "/usr/include/c++/10/bits/stl_function.h" 3
  template<typename _Tp = void>
    struct logical_and;

  template<typename _Tp = void>
    struct logical_or;

  template<typename _Tp = void>
    struct logical_not;



  template<typename _Tp>
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


  template<typename _Tp>
    struct logical_or : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
    };


  template<typename _Tp>
    struct logical_not : public unary_function<_Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };



  template<>
    struct logical_and<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct logical_or<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct logical_not<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(!std::forward<_Tp>(__t)))
 -> decltype(!std::forward<_Tp>(__t))
 { return !std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };




  template<typename _Tp = void>
    struct bit_and;

  template<typename _Tp = void>
    struct bit_or;

  template<typename _Tp = void>
    struct bit_xor;

  template<typename _Tp = void>
    struct bit_not;




  template<typename _Tp>
    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x & __y; }
    };

  template<typename _Tp>
    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x | __y; }
    };

  template<typename _Tp>
    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x ^ __y; }
    };

  template<typename _Tp>
    struct bit_not : public unary_function<_Tp, _Tp>
    {
    constexpr
      _Tp
      operator()(const _Tp& __x) const
      { return ~__x; }
    };


  template <>
    struct bit_and<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_or<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_xor<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_not<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(~std::forward<_Tp>(__t)))
 -> decltype(~std::forward<_Tp>(__t))
 { return ~std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };
# 1002 "/usr/include/c++/10/bits/stl_function.h" 3
  template<typename _Predicate>
    class unary_negate
    : public unary_function<typename _Predicate::argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      constexpr
      explicit
      unary_negate(const _Predicate& __x) : _M_pred(__x) { }

      constexpr
      bool
      operator()(const typename _Predicate::argument_type& __x) const
      { return !_M_pred(__x); }
    };


  template<typename _Predicate>
    constexpr
    inline unary_negate<_Predicate>
    not1(const _Predicate& __pred)
    { return unary_negate<_Predicate>(__pred); }


  template<typename _Predicate>
    class binary_negate
    : public binary_function<typename _Predicate::first_argument_type,
        typename _Predicate::second_argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      constexpr
      explicit
      binary_negate(const _Predicate& __x) : _M_pred(__x) { }

      constexpr
      bool
      operator()(const typename _Predicate::first_argument_type& __x,
   const typename _Predicate::second_argument_type& __y) const
      { return !_M_pred(__x, __y); }
    };


  template<typename _Predicate>
    constexpr
    inline binary_negate<_Predicate>
    not2(const _Predicate& __pred)
    { return binary_negate<_Predicate>(__pred); }
# 1079 "/usr/include/c++/10/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    class pointer_to_unary_function : public unary_function<_Arg, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg);

    public:
      pointer_to_unary_function() { }

      explicit
      pointer_to_unary_function(_Result (*__x)(_Arg))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg __x) const
      { return _M_ptr(__x); }
    };


  template<typename _Arg, typename _Result>
    inline pointer_to_unary_function<_Arg, _Result>
    ptr_fun(_Result (*__x)(_Arg))
    { return pointer_to_unary_function<_Arg, _Result>(__x); }


  template<typename _Arg1, typename _Arg2, typename _Result>
    class pointer_to_binary_function
    : public binary_function<_Arg1, _Arg2, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg1, _Arg2);

    public:
      pointer_to_binary_function() { }

      explicit
      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg1 __x, _Arg2 __y) const
      { return _M_ptr(__x, __y); }
    };


  template<typename _Arg1, typename _Arg2, typename _Result>
    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }


  template<typename _Tp>
    struct _Identity
    : public unary_function<_Tp, _Tp>
    {
      _Tp&
      operator()(_Tp& __x) const
      { return __x; }

      const _Tp&
      operator()(const _Tp& __x) const
      { return __x; }
    };


  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };

  template<typename _Pair>
    struct _Select1st
    : public unary_function<_Pair, typename _Pair::first_type>
    {
      typename _Pair::first_type&
      operator()(_Pair& __x) const
      { return __x.first; }

      const typename _Pair::first_type&
      operator()(const _Pair& __x) const
      { return __x.first; }


      template<typename _Pair2>
        typename _Pair2::first_type&
        operator()(_Pair2& __x) const
        { return __x.first; }

      template<typename _Pair2>
        const typename _Pair2::first_type&
        operator()(const _Pair2& __x) const
        { return __x.first; }

    };

  template<typename _Pair>
    struct _Select2nd
    : public unary_function<_Pair, typename _Pair::second_type>
    {
      typename _Pair::second_type&
      operator()(_Pair& __x) const
      { return __x.second; }

      const typename _Pair::second_type&
      operator()(const _Pair& __x) const
      { return __x.second; }
    };
# 1202 "/usr/include/c++/10/bits/stl_function.h" 3
  template<typename _Ret, typename _Tp>
    class mem_fun_t : public unary_function<_Tp*, _Ret>
    {
    public:
      explicit
      mem_fun_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    };



  template<typename _Ret, typename _Tp>
    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
    {
    public:
      explicit
      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };



  template<typename _Ret, typename _Tp>
    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      mem_fun_ref_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
  };



  template<typename _Ret, typename _Tp>
    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };



  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };



  template<typename _Ret, typename _Tp>
    inline mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)())
    { return mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    inline const_mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    inline mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)())
    { return mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    inline const_mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }




}


# 1 "/usr/include/c++/10/backward/binders.h" 1 3
# 60 "/usr/include/c++/10/backward/binders.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

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

# 107 "/usr/include/c++/10/backward/binders.h" 3
  template<typename _Operation>
    class binder1st
    : public unary_function<typename _Operation::second_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::first_argument_type value;

    public:
      binder1st(const _Operation& __x,
  const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }



      typename _Operation::result_type
      operator()(typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }
    } __attribute__ ((__deprecated__));


  template<typename _Operation, typename _Tp>
    inline binder1st<_Operation>
    bind1st(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::first_argument_type _Arg1_type;
      return binder1st<_Operation>(__fn, _Arg1_type(__x));
    }


  template<typename _Operation>
    class binder2nd
    : public unary_function<typename _Operation::first_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::second_argument_type value;

    public:
      binder2nd(const _Operation& __x,
  const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }



      typename _Operation::result_type
      operator()(typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }
    } __attribute__ ((__deprecated__));


  template<typename _Operation, typename _Tp>
    inline binder2nd<_Operation>
    bind2nd(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::second_argument_type _Arg2_type;
      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
    }



}

#pragma GCC diagnostic pop
# 1393 "/usr/include/c++/10/bits/stl_function.h" 2 3
# 50 "/usr/include/c++/10/functional" 2 3




# 1 "/usr/include/c++/10/tuple" 1 3
# 32 "/usr/include/c++/10/tuple" 3
       
# 33 "/usr/include/c++/10/tuple" 3







# 1 "/usr/include/c++/10/bits/uses_allocator.h" 1 3
# 35 "/usr/include/c++/10/bits/uses_allocator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  struct __erased_type { };




  template<typename _Alloc, typename _Tp>
    using __is_erased_or_convertible
      = __or_<is_convertible<_Alloc, _Tp>, is_same<_Tp, __erased_type>>;


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

  inline constexpr allocator_arg_t allocator_arg =
    allocator_arg_t();

  template<typename _Tp, typename _Alloc, typename = __void_t<>>
    struct __uses_allocator_helper
    : false_type { };

  template<typename _Tp, typename _Alloc>
    struct __uses_allocator_helper<_Tp, _Alloc,
       __void_t<typename _Tp::allocator_type>>
    : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
    { };


  template<typename _Tp, typename _Alloc>
    struct uses_allocator
    : __uses_allocator_helper<_Tp, _Alloc>::type
    { };

  struct __uses_alloc_base { };

  struct __uses_alloc0 : __uses_alloc_base
  {
    struct _Sink { void operator=(const void*) { } } _M_a;
  };

  template<typename _Alloc>
    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };

  template<typename _Alloc>
    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };

  template<bool, typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc;

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
    : conditional<
        is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value,
        __uses_alloc1<_Alloc>,
        __uses_alloc2<_Alloc>>::type
    {


      static_assert(__or_<
   is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>,
   is_constructible<_Tp, _Args..., const _Alloc&>>::value,
   "construction with an allocator must be possible"
   " if uses_allocator is true");
    };

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
    : __uses_alloc0 { };

  template<typename _Tp, typename _Alloc, typename... _Args>
    using __uses_alloc_t =
      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;

  template<typename _Tp, typename _Alloc, typename... _Args>
   
    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
    __use_alloc(const _Alloc& __a)
    {
      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
      __ret._M_a = std::__addressof(__a);
      return __ret;
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void
    __use_alloc(const _Alloc&&) = delete;


  template <typename _Tp, typename _Alloc>
    inline constexpr bool uses_allocator_v =
      uses_allocator<_Tp, _Alloc>::value;


  template<template<typename...> class _Predicate,
    typename _Tp, typename _Alloc, typename... _Args>
    struct __is_uses_allocator_predicate
    : conditional<uses_allocator<_Tp, _Alloc>::value,
      __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
     _Predicate<_Tp, _Args..., _Alloc>>,
      _Predicate<_Tp, _Args...>>::type { };

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __is_uses_allocator_constructible
    : __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
    { };


  template<typename _Tp, typename _Alloc, typename... _Args>
    inline constexpr bool __is_uses_allocator_constructible_v =
      __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;


  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __is_nothrow_uses_allocator_constructible
    : __is_uses_allocator_predicate<is_nothrow_constructible,
        _Tp, _Alloc, _Args...>
    { };



  template<typename _Tp, typename _Alloc, typename... _Args>
    inline constexpr bool
    __is_nothrow_uses_allocator_constructible_v =
      __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;


  template<typename _Tp, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr,
      _Args&&... __args)
    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
      _Args&&... __args)
    {
      ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
          std::forward<_Args>(__args)...);
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
      _Args&&... __args)
    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
        _Args&&... __args)
    {
      std::__uses_allocator_construct_impl(
   std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr,
   std::forward<_Args>(__args)...);
    }


}
# 41 "/usr/include/c++/10/tuple" 2 3
# 1 "/usr/include/c++/10/bits/invoke.h" 1 3
# 33 "/usr/include/c++/10/bits/invoke.h" 3
       
# 34 "/usr/include/c++/10/bits/invoke.h" 3







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

# 52 "/usr/include/c++/10/bits/invoke.h" 3
  template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
    constexpr _Up&&
    __invfwd(typename remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Up&&>(__t); }

  template<typename _Res, typename _Fn, typename... _Args>
    constexpr _Res
    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }

  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
    constexpr _Res
    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
    _Args&&... __args)
    { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }

  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
    constexpr _Res
    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
    _Args&&... __args)
    {
      return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
    }

  template<typename _Res, typename _MemPtr, typename _Tp>
    constexpr _Res
    __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
    { return __invfwd<_Tp>(__t).*__f; }

  template<typename _Res, typename _MemPtr, typename _Tp>
    constexpr _Res
    __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
    { return (*std::forward<_Tp>(__t)).*__f; }


  template<typename _Callable, typename... _Args>
    constexpr typename __invoke_result<_Callable, _Args...>::type
    __invoke(_Callable&& __fn, _Args&&... __args)
    noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
    {
      using __result = __invoke_result<_Callable, _Args...>;
      using __type = typename __result::type;
      using __tag = typename __result::__invoke_type;
      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
     std::forward<_Args>(__args)...);
    }



  template<typename _Res, typename _Callable, typename... _Args>
    constexpr enable_if_t<is_invocable_r_v<_Res, _Callable, _Args...>, _Res>
    __invoke_r(_Callable&& __fn, _Args&&... __args)
    noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>)
    {
      using __result = __invoke_result<_Callable, _Args...>;
      using __type = typename __result::type;
      using __tag = typename __result::__invoke_type;
      if constexpr (is_void_v<_Res>)
 std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
     std::forward<_Args>(__args)...);
      else
 return std::__invoke_impl<__type>(__tag{},
       std::forward<_Callable>(__fn),
       std::forward<_Args>(__args)...);
    }
# 158 "/usr/include/c++/10/bits/invoke.h" 3

}
# 42 "/usr/include/c++/10/tuple" 2 3

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







  template<typename... _Elements>
    class tuple;

  template<typename _Tp>
    struct __is_empty_non_tuple : is_empty<_Tp> { };


  template<typename _El0, typename... _El>
    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };


  template<typename _Tp>
    using __empty_not_final
    = typename conditional<__is_final(_Tp), false_type,
      __is_empty_non_tuple<_Tp>>::type;

  template<std::size_t _Idx, typename _Head,
    bool = __empty_not_final<_Head>::value>
    struct _Head_base;

  template<std::size_t _Idx, typename _Head>
    struct _Head_base<_Idx, _Head, true>
    : public _Head
    {
      constexpr _Head_base()
      : _Head() { }

      constexpr _Head_base(const _Head& __h)
      : _Head(__h) { }

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

      template<typename _UHead>
        constexpr _Head_base(_UHead&& __h)
 : _Head(std::forward<_UHead>(__h)) { }

      _Head_base(allocator_arg_t, __uses_alloc0)
      : _Head() { }

      template<typename _Alloc>
 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 : _Head(allocator_arg, *__a._M_a) { }

      template<typename _Alloc>
 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 : _Head(*__a._M_a) { }

      template<typename _UHead>
 _Head_base(__uses_alloc0, _UHead&& __uhead)
 : _Head(std::forward<_UHead>(__uhead)) { }

      template<typename _Alloc, typename _UHead>
 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }

      template<typename _Alloc, typename _UHead>
 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }

      static constexpr _Head&
      _M_head(_Head_base& __b) noexcept { return __b; }

      static constexpr const _Head&
      _M_head(const _Head_base& __b) noexcept { return __b; }
    };

  template<std::size_t _Idx, typename _Head>
    struct _Head_base<_Idx, _Head, false>
    {
      constexpr _Head_base()
      : _M_head_impl() { }

      constexpr _Head_base(const _Head& __h)
      : _M_head_impl(__h) { }

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

      template<typename _UHead>
        constexpr _Head_base(_UHead&& __h)
 : _M_head_impl(std::forward<_UHead>(__h)) { }

     
      _Head_base(allocator_arg_t, __uses_alloc0)
      : _M_head_impl() { }

      template<typename _Alloc>
 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 : _M_head_impl(allocator_arg, *__a._M_a) { }

      template<typename _Alloc>
 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 : _M_head_impl(*__a._M_a) { }

      template<typename _UHead>

 _Head_base(__uses_alloc0, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead)) { }

      template<typename _Alloc, typename _UHead>
 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 { }

      template<typename _Alloc, typename _UHead>
 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

      static constexpr _Head&
      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

      static constexpr const _Head&
      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

      _Head _M_head_impl;
    };
# 178 "/usr/include/c++/10/tuple" 3
  template<std::size_t _Idx, typename... _Elements>
    struct _Tuple_impl;






  template<std::size_t _Idx, typename _Head, typename... _Tail>
    struct _Tuple_impl<_Idx, _Head, _Tail...>
    : public _Tuple_impl<_Idx + 1, _Tail...>,
      private _Head_base<_Idx, _Head>
    {
      template<std::size_t, typename...> friend class _Tuple_impl;

      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
      typedef _Head_base<_Idx, _Head> _Base;

      static constexpr _Head&
      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&
      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr _Inherited&
      _M_tail(_Tuple_impl& __t) noexcept { return __t; }

      static constexpr const _Inherited&
      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }

      constexpr _Tuple_impl()
      : _Inherited(), _Base() { }

      explicit
      constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
      : _Inherited(__tail...), _Base(__head) { }

      template<typename _UHead, typename... _UTail, typename = typename
               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
        explicit
        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 : _Inherited(std::forward<_UTail>(__tail)...),
   _Base(std::forward<_UHead>(__head)) { }

      constexpr _Tuple_impl(const _Tuple_impl&) = default;



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

      constexpr
      _Tuple_impl(_Tuple_impl&& __in)
      noexcept(__and_<is_nothrow_move_constructible<_Head>,
               is_nothrow_move_constructible<_Inherited>>::value)
      : _Inherited(std::move(_M_tail(__in))),
 _Base(std::forward<_Head>(_M_head(__in))) { }

      template<typename... _UElements>
        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }

      template<typename _UHead, typename... _UTails>
        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(std::forward<_UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }

      template<typename _Alloc>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 : _Inherited(__tag, __a),
          _Base(__tag, __use_alloc<_Head>(__a)) { }

      template<typename _Alloc>
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Head& __head, const _Tail&... __tail)
 : _Inherited(__tag, __a, __tail...),
          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }

      template<typename _Alloc, typename _UHead, typename... _UTail,
               typename = typename enable_if<sizeof...(_Tail)
          == sizeof...(_UTail)>::type>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             _UHead&& __head, _UTail&&... __tail)
 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
          _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
         std::forward<_UHead>(__head)) { }

      template<typename _Alloc>

        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             const _Tuple_impl& __in)
 : _Inherited(__tag, __a, _M_tail(__in)),
          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }

      template<typename _Alloc>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             _Tuple_impl&& __in)
 : _Inherited(__tag, __a, std::move(_M_tail(__in))),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
         std::forward<_Head>(_M_head(__in))) { }

      template<typename _Alloc, typename... _UElements>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             const _Tuple_impl<_Idx, _UElements...>& __in)
 : _Inherited(__tag, __a,
       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
  _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }

      template<typename _Alloc, typename _UHead, typename... _UTails>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(__tag, __a, std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
                std::forward<_UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }

      template<typename... _UElements>

        void
        _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
        {
   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
   _M_tail(*this)._M_assign(
       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
 }

      template<typename _UHead, typename... _UTails>

        void
        _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
        {
   _M_head(*this) = std::forward<_UHead>
     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
   _M_tail(*this)._M_assign(
       std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
 }

    protected:
     
      void
      _M_swap(_Tuple_impl& __in)
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
 _Inherited::_M_swap(_M_tail(__in));
      }
    };


  template<std::size_t _Idx, typename _Head>
    struct _Tuple_impl<_Idx, _Head>
    : private _Head_base<_Idx, _Head>
    {
      template<std::size_t, typename...> friend class _Tuple_impl;

      typedef _Head_base<_Idx, _Head> _Base;

      static constexpr _Head&
      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&
      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      constexpr _Tuple_impl()
      : _Base() { }

      explicit
      constexpr _Tuple_impl(const _Head& __head)
      : _Base(__head) { }

      template<typename _UHead>
        explicit
        constexpr _Tuple_impl(_UHead&& __head)
 : _Base(std::forward<_UHead>(__head)) { }

      constexpr _Tuple_impl(const _Tuple_impl&) = default;



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

      constexpr
      _Tuple_impl(_Tuple_impl&& __in)
      noexcept(is_nothrow_move_constructible<_Head>::value)
      : _Base(std::forward<_Head>(_M_head(__in))) { }

      template<typename _UHead>
        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }

      template<typename _UHead>
        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }

      template<typename _Alloc>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 : _Base(__tag, __use_alloc<_Head>(__a)) { }

      template<typename _Alloc>
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Head& __head)
 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }

      template<typename _Alloc, typename _UHead>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             _UHead&& __head)
 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
         std::forward<_UHead>(__head)) { }

      template<typename _Alloc>

        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             const _Tuple_impl& __in)
 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }

      template<typename _Alloc>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             _Tuple_impl&& __in)
 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
         std::forward<_Head>(_M_head(__in))) { }

      template<typename _Alloc, typename _UHead>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             const _Tuple_impl<_Idx, _UHead>& __in)
 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
  _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }

      template<typename _Alloc, typename _UHead>

 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
             _Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }

      template<typename _UHead>

        void
        _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
        {
   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
 }

      template<typename _UHead>

        void
        _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
        {
   _M_head(*this)
     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
 }

    protected:
     
      void
      _M_swap(_Tuple_impl& __in)
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
      }
    };



  template<bool, typename... _Types>
    struct _TupleConstraints
    {



      template<typename... _UTypes>
 static constexpr bool __is_implicitly_constructible()
 {
   return __and_<is_constructible<_Types, _UTypes>...,
   is_convertible<_UTypes, _Types>...
   >::value;
 }




      template<typename... _UTypes>
 static constexpr bool __is_explicitly_constructible()
 {
   return __and_<is_constructible<_Types, _UTypes>...,
   __not_<__and_<is_convertible<_UTypes, _Types>...>>
   >::value;
 }

      static constexpr bool __is_implicitly_default_constructible()
      {
 return __and_<std::__is_implicitly_default_constructible<_Types>...
        >::value;
      }

      static constexpr bool __is_explicitly_default_constructible()
      {
 return __and_<is_default_constructible<_Types>...,
        __not_<__and_<
   std::__is_implicitly_default_constructible<_Types>...>
        >>::value;
      }
    };



  template<typename... _Types>
    struct _TupleConstraints<false, _Types...>
    {
      template<typename... _UTypes>
 static constexpr bool __is_implicitly_constructible()
 { return false; }

      template<typename... _UTypes>
 static constexpr bool __is_explicitly_constructible()
 { return false; }
    };


  template<typename... _Elements>
    class tuple : public _Tuple_impl<0, _Elements...>
    {
      typedef _Tuple_impl<0, _Elements...> _Inherited;

      template<bool _Cond>
 using _TCC = _TupleConstraints<_Cond, _Elements...>;


      template<bool _Dummy>
 using _ImplicitDefaultCtor = __enable_if_t<
   _TCC<_Dummy>::__is_implicitly_default_constructible(),
   bool>;


      template<bool _Dummy>
 using _ExplicitDefaultCtor = __enable_if_t<
   _TCC<_Dummy>::__is_explicitly_default_constructible(),
   bool>;


      template<bool _Cond, typename... _Args>
 using _ImplicitCtor = __enable_if_t<
   _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(),
   bool>;


      template<bool _Cond, typename... _Args>
 using _ExplicitCtor = __enable_if_t<
   _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(),
   bool>;

      template<typename... _UElements>
 static constexpr
 __enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool>
 __assignable()
 { return __and_<is_assignable<_Elements&, _UElements>...>::value; }


      template<typename... _UElements>
 static constexpr bool __nothrow_assignable()
 {
   return
     __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value;
 }


      template<typename... _UElements>
 static constexpr bool __nothrow_constructible()
 {
   return
     __and_<is_nothrow_constructible<_Elements, _UElements>...>::value;
 }


      template<typename _Up>
 static constexpr bool __valid_args()
 {
   return sizeof...(_Elements) == 1
     && !is_same<tuple, __remove_cvref_t<_Up>>::value;
 }


      template<typename, typename, typename... _Tail>
 static constexpr bool __valid_args()
 { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); }
# 587 "/usr/include/c++/10/tuple" 3
      template<typename _Tuple, typename = tuple,
        typename = __remove_cvref_t<_Tuple>>
 struct _UseOtherCtor
 : false_type
 { };


      template<typename _Tuple, typename _Tp, typename _Up>
 struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>>
 : __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>>
 { };


      template<typename _Tuple, typename _Tp>
 struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>>
 : true_type
 { };




      template<typename _Tuple>
 static constexpr bool __use_other_ctor()
 { return _UseOtherCtor<_Tuple>::value; }

    public:
      template<typename _Dummy = void,
        _ImplicitDefaultCtor<is_void<_Dummy>::value> = true>
 constexpr
 tuple()
 noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
 : _Inherited() { }

      template<typename _Dummy = void,
        _ExplicitDefaultCtor<is_void<_Dummy>::value> = false>
 explicit constexpr
 tuple()
 noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
 : _Inherited() { }

      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
        _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
 constexpr
 tuple(const _Elements&... __elements)
 noexcept(__nothrow_constructible<const _Elements&...>())
 : _Inherited(__elements...) { }

      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
        _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
 explicit constexpr
 tuple(const _Elements&... __elements)
 noexcept(__nothrow_constructible<const _Elements&...>())
 : _Inherited(__elements...) { }

      template<typename... _UElements,
        bool _Valid = __valid_args<_UElements...>(),
        _ImplicitCtor<_Valid, _UElements...> = true>
 constexpr
 tuple(_UElements&&... __elements)
 noexcept(__nothrow_constructible<_UElements...>())
 : _Inherited(std::forward<_UElements>(__elements)...) { }

      template<typename... _UElements,
        bool _Valid = __valid_args<_UElements...>(),
        _ExplicitCtor<_Valid, _UElements...> = false>
 explicit constexpr
 tuple(_UElements&&... __elements)
 noexcept(__nothrow_constructible<_UElements...>())
 : _Inherited(std::forward<_UElements>(__elements)...) { }

      constexpr tuple(const tuple&) = default;

      constexpr tuple(tuple&&) = default;

      template<typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
      && !__use_other_ctor<const tuple<_UElements...>&>(),
        _ImplicitCtor<_Valid, const _UElements&...> = true>
 constexpr
 tuple(const tuple<_UElements...>& __in)
 noexcept(__nothrow_constructible<const _UElements&...>())
 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 { }

      template<typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
      && !__use_other_ctor<const tuple<_UElements...>&>(),
        _ExplicitCtor<_Valid, const _UElements&...> = false>
 explicit constexpr
 tuple(const tuple<_UElements...>& __in)
 noexcept(__nothrow_constructible<const _UElements&...>())
 : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 { }

      template<typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        && !__use_other_ctor<tuple<_UElements...>&&>(),
        _ImplicitCtor<_Valid, _UElements...> = true>
 constexpr
 tuple(tuple<_UElements...>&& __in)
 noexcept(__nothrow_constructible<_UElements...>())
 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }

      template<typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        && !__use_other_ctor<tuple<_UElements...>&&>(),
        _ExplicitCtor<_Valid, _UElements...> = false>
 explicit constexpr
 tuple(tuple<_UElements...>&& __in)
 noexcept(__nothrow_constructible<_UElements...>())
 : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }



      template<typename _Alloc,
        _ImplicitDefaultCtor<is_object<_Alloc>::value> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a)
 : _Inherited(__tag, __a) { }

      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
        _ImplicitCtor<_NotEmpty, const _Elements&...> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const _Elements&... __elements)
 : _Inherited(__tag, __a, __elements...) { }

      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
        _ExplicitCtor<_NotEmpty, const _Elements&...> = false>

 explicit
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const _Elements&... __elements)
 : _Inherited(__tag, __a, __elements...) { }

      template<typename _Alloc, typename... _UElements,
        bool _Valid = __valid_args<_UElements...>(),
        _ImplicitCtor<_Valid, _UElements...> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       _UElements&&... __elements)
 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
 { }

      template<typename _Alloc, typename... _UElements,
   bool _Valid = __valid_args<_UElements...>(),
        _ExplicitCtor<_Valid, _UElements...> = false>

 explicit
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       _UElements&&... __elements)
 : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
 { }

      template<typename _Alloc>

 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }

      template<typename _Alloc>

 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }

      template<typename _Alloc, typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        && !__use_other_ctor<const tuple<_UElements...>&>(),
        _ImplicitCtor<_Valid, const _UElements&...> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const tuple<_UElements...>& __in)
 : _Inherited(__tag, __a,
              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 { }

      template<typename _Alloc, typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        && !__use_other_ctor<const tuple<_UElements...>&>(),
        _ExplicitCtor<_Valid, const _UElements&...> = false>

 explicit
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const tuple<_UElements...>& __in)
 : _Inherited(__tag, __a,
              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 { }

      template<typename _Alloc, typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        && !__use_other_ctor<tuple<_UElements...>&&>(),
        _ImplicitCtor<_Valid, _UElements...> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       tuple<_UElements...>&& __in)
 : _Inherited(__tag, __a,
              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
 { }

      template<typename _Alloc, typename... _UElements,
        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        && !__use_other_ctor<tuple<_UElements...>&&>(),
        _ExplicitCtor<_Valid, _UElements...> = false>

 explicit
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       tuple<_UElements...>&& __in)
 : _Inherited(__tag, __a,
              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
 { }



     
      tuple&
      operator=(typename conditional<__assignable<const _Elements&...>(),
         const tuple&,
         const __nonesuch&>::type __in)
      noexcept(__nothrow_assignable<const _Elements&...>())
      {
 this->_M_assign(__in);
 return *this;
      }

     
      tuple&
      operator=(typename conditional<__assignable<_Elements...>(),
         tuple&&,
         __nonesuch&&>::type __in)
      noexcept(__nothrow_assignable<_Elements...>())
      {
 this->_M_assign(std::move(__in));
 return *this;
      }

      template<typename... _UElements>

 __enable_if_t<__assignable<const _UElements&...>(), tuple&>
 operator=(const tuple<_UElements...>& __in)
 noexcept(__nothrow_assignable<const _UElements&...>())
 {
   this->_M_assign(__in);
   return *this;
 }

      template<typename... _UElements>

 __enable_if_t<__assignable<_UElements...>(), tuple&>
 operator=(tuple<_UElements...>&& __in)
 noexcept(__nothrow_assignable<_UElements...>())
 {
   this->_M_assign(std::move(__in));
   return *this;
 }


     
      void
      swap(tuple& __in)
      noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
      { _Inherited::_M_swap(__in); }
    };


  template<typename... _UTypes>
    tuple(_UTypes...) -> tuple<_UTypes...>;
  template<typename _T1, typename _T2>
    tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
  template<typename _Alloc, typename... _UTypes>
    tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
  template<typename _Alloc, typename _T1, typename _T2>
    tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
  template<typename _Alloc, typename... _UTypes>
    tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;



  template<>
    class tuple<>
    {
    public:
      void swap(tuple&) noexcept { }


      tuple() = default;

      template<typename _Alloc>

 tuple(allocator_arg_t, const _Alloc&) noexcept { }
      template<typename _Alloc>

 tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
    };



  template<typename _T1, typename _T2>
    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
    {
      typedef _Tuple_impl<0, _T1, _T2> _Inherited;


      template<bool _Dummy, typename _U1, typename _U2>
 using _ImplicitDefaultCtor = __enable_if_t<
   _TupleConstraints<_Dummy, _U1, _U2>::
     __is_implicitly_default_constructible(),
   bool>;


      template<bool _Dummy, typename _U1, typename _U2>
 using _ExplicitDefaultCtor = __enable_if_t<
   _TupleConstraints<_Dummy, _U1, _U2>::
     __is_explicitly_default_constructible(),
   bool>;

      template<bool _Dummy>
 using _TCC = _TupleConstraints<_Dummy, _T1, _T2>;


      template<bool _Cond, typename _U1, typename _U2>
 using _ImplicitCtor = __enable_if_t<
   _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(),
   bool>;


      template<bool _Cond, typename _U1, typename _U2>
 using _ExplicitCtor = __enable_if_t<
   _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(),
   bool>;

      template<typename _U1, typename _U2>
 static constexpr bool __assignable()
 {
   return __and_<is_assignable<_T1&, _U1>,
   is_assignable<_T2&, _U2>>::value;
 }

      template<typename _U1, typename _U2>
 static constexpr bool __nothrow_assignable()
 {
   return __and_<is_nothrow_assignable<_T1&, _U1>,
   is_nothrow_assignable<_T2&, _U2>>::value;
 }

      template<typename _U1, typename _U2>
 static constexpr bool __nothrow_constructible()
 {
   return __and_<is_nothrow_constructible<_T1, _U1>,
       is_nothrow_constructible<_T2, _U2>>::value;
 }

      static constexpr bool __nothrow_default_constructible()
      {
 return __and_<is_nothrow_default_constructible<_T1>,
        is_nothrow_default_constructible<_T2>>::value;
      }

      template<typename _U1>
 static constexpr bool __is_alloc_arg()
 { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; }

    public:
      template<bool _Dummy = true,
        _ImplicitDefaultCtor<_Dummy, _T1, _T2> = true>
 constexpr
 tuple()
 noexcept(__nothrow_default_constructible())
 : _Inherited() { }

      template<bool _Dummy = true,
        _ExplicitDefaultCtor<_Dummy, _T1, _T2> = false>
 explicit constexpr
 tuple()
 noexcept(__nothrow_default_constructible())
 : _Inherited() { }

      template<bool _Dummy = true,
        _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
 constexpr
 tuple(const _T1& __a1, const _T2& __a2)
 noexcept(__nothrow_constructible<const _T1&, const _T2&>())
 : _Inherited(__a1, __a2) { }

      template<bool _Dummy = true,
        _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
 explicit constexpr
 tuple(const _T1& __a1, const _T2& __a2)
 noexcept(__nothrow_constructible<const _T1&, const _T2&>())
 : _Inherited(__a1, __a2) { }

      template<typename _U1, typename _U2,
        _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = true>
 constexpr
 tuple(_U1&& __a1, _U2&& __a2)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }

      template<typename _U1, typename _U2,
        _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = false>
 explicit constexpr
 tuple(_U1&& __a1, _U2&& __a2)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }

      constexpr tuple(const tuple&) = default;

      constexpr tuple(tuple&&) = default;

      template<typename _U1, typename _U2,
        _ImplicitCtor<true, const _U1&, const _U2&> = true>
 constexpr
 tuple(const tuple<_U1, _U2>& __in)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }

      template<typename _U1, typename _U2,
        _ExplicitCtor<true, const _U1&, const _U2&> = false>
 explicit constexpr
 tuple(const tuple<_U1, _U2>& __in)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }

      template<typename _U1, typename _U2,
        _ImplicitCtor<true, _U1, _U2> = true>
 constexpr
 tuple(tuple<_U1, _U2>&& __in)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }

      template<typename _U1, typename _U2,
        _ExplicitCtor<true, _U1, _U2> = false>
 explicit constexpr
 tuple(tuple<_U1, _U2>&& __in)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }

      template<typename _U1, typename _U2,
        _ImplicitCtor<true, const _U1&, const _U2&> = true>
 constexpr
 tuple(const pair<_U1, _U2>& __in)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(__in.first, __in.second) { }

      template<typename _U1, typename _U2,
        _ExplicitCtor<true, const _U1&, const _U2&> = false>
 explicit constexpr
 tuple(const pair<_U1, _U2>& __in)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(__in.first, __in.second) { }

      template<typename _U1, typename _U2,
        _ImplicitCtor<true, _U1, _U2> = true>
 constexpr
 tuple(pair<_U1, _U2>&& __in)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(std::forward<_U1>(__in.first),
       std::forward<_U2>(__in.second)) { }

      template<typename _U1, typename _U2,
        _ExplicitCtor<true, _U1, _U2> = false>
 explicit constexpr
 tuple(pair<_U1, _U2>&& __in)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(std::forward<_U1>(__in.first),
       std::forward<_U2>(__in.second)) { }



      template<typename _Alloc,
        _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a)
 : _Inherited(__tag, __a) { }

      template<typename _Alloc, bool _Dummy = true,
        _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const _T1& __a1, const _T2& __a2)
 : _Inherited(__tag, __a, __a1, __a2) { }

      template<typename _Alloc, bool _Dummy = true,
        _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
 explicit

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const _T1& __a1, const _T2& __a2)
 : _Inherited(__tag, __a, __a1, __a2) { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ImplicitCtor<true, _U1, _U2> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
              std::forward<_U2>(__a2)) { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ExplicitCtor<true, _U1, _U2> = false>
 explicit

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       _U1&& __a1, _U2&& __a2)
 : _Inherited(__tag, __a, std::forward<_U1>(__a1),
              std::forward<_U2>(__a2)) { }

      template<typename _Alloc>

 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }

      template<typename _Alloc>

 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ImplicitCtor<true, const _U1&, const _U2&> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const tuple<_U1, _U2>& __in)
 : _Inherited(__tag, __a,
              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
 { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ExplicitCtor<true, const _U1&, const _U2&> = false>
 explicit

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const tuple<_U1, _U2>& __in)
 : _Inherited(__tag, __a,
              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
 { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ImplicitCtor<true, _U1, _U2> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
 { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ExplicitCtor<true, _U1, _U2> = false>
 explicit

 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
 { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ImplicitCtor<true, const _U1&, const _U2&> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const pair<_U1, _U2>& __in)
 : _Inherited(__tag, __a, __in.first, __in.second) { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ExplicitCtor<true, const _U1&, const _U2&> = false>
 explicit

 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const pair<_U1, _U2>& __in)
 : _Inherited(__tag, __a, __in.first, __in.second) { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ImplicitCtor<true, _U1, _U2> = true>

 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
       std::forward<_U2>(__in.second)) { }

      template<typename _Alloc, typename _U1, typename _U2,
        _ExplicitCtor<true, _U1, _U2> = false>
 explicit

 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
 : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
       std::forward<_U2>(__in.second)) { }



     
      tuple&
      operator=(typename conditional<__assignable<const _T1&, const _T2&>(),
         const tuple&,
         const __nonesuch&>::type __in)
      noexcept(__nothrow_assignable<const _T1&, const _T2&>())
      {
 this->_M_assign(__in);
 return *this;
      }

     
      tuple&
      operator=(typename conditional<__assignable<_T1, _T2>(),
         tuple&&,
         __nonesuch&&>::type __in)
      noexcept(__nothrow_assignable<_T1, _T2>())
      {
 this->_M_assign(std::move(__in));
 return *this;
      }

      template<typename _U1, typename _U2>

 __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
 operator=(const tuple<_U1, _U2>& __in)
 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
 {
   this->_M_assign(__in);
   return *this;
 }

      template<typename _U1, typename _U2>

 __enable_if_t<__assignable<_U1, _U2>(), tuple&>
 operator=(tuple<_U1, _U2>&& __in)
 noexcept(__nothrow_assignable<_U1, _U2>())
 {
   this->_M_assign(std::move(__in));
   return *this;
 }

      template<typename _U1, typename _U2>

 __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
 operator=(const pair<_U1, _U2>& __in)
 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
 {
   this->_M_head(*this) = __in.first;
   this->_M_tail(*this)._M_head(*this) = __in.second;
   return *this;
 }

      template<typename _U1, typename _U2>

 __enable_if_t<__assignable<_U1, _U2>(), tuple&>
 operator=(pair<_U1, _U2>&& __in)
 noexcept(__nothrow_assignable<_U1, _U2>())
 {
   this->_M_head(*this) = std::forward<_U1>(__in.first);
   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
   return *this;
 }

     
      void
      swap(tuple& __in)
      noexcept(__and_<__is_nothrow_swappable<_T1>,
        __is_nothrow_swappable<_T2>>::value)
      { _Inherited::_M_swap(__in); }
    };



  template<typename... _Elements>
    struct tuple_size<tuple<_Elements...>>
    : public integral_constant<std::size_t, sizeof...(_Elements)> { };


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






  template<std::size_t __i, typename _Head, typename... _Tail>
    struct tuple_element<__i, tuple<_Head, _Tail...> >
    : tuple_element<__i - 1, tuple<_Tail...> > { };




  template<typename _Head, typename... _Tail>
    struct tuple_element<0, tuple<_Head, _Tail...> >
    {
      typedef _Head type;
    };




  template<size_t __i>
    struct tuple_element<__i, tuple<>>
    {
      static_assert(__i < tuple_size<tuple<>>::value,
   "tuple index is in range");
    };

  template<std::size_t __i, typename _Head, typename... _Tail>
    constexpr _Head&
    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

  template<std::size_t __i, typename _Head, typename... _Tail>
    constexpr const _Head&
    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }


  template<std::size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
    get(tuple<_Elements...>& __t) noexcept
    { return std::__get_helper<__i>(__t); }


  template<std::size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
    get(const tuple<_Elements...>& __t) noexcept
    { return std::__get_helper<__i>(__t); }


  template<std::size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
    get(tuple<_Elements...>&& __t) noexcept
    {
      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
      return std::forward<__element_type&&>(std::get<__i>(__t));
    }


  template<std::size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
    get(const tuple<_Elements...>&& __t) noexcept
    {
      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
      return std::forward<const __element_type&&>(std::get<__i>(__t));
    }





  template<typename _Head, size_t __i, typename... _Tail>
    constexpr _Head&
    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

  template<typename _Head, size_t __i, typename... _Tail>
    constexpr const _Head&
    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }


  template <typename _Tp, typename... _Types>
    constexpr _Tp&
    get(tuple<_Types...>& __t) noexcept
    { return std::__get_helper2<_Tp>(__t); }


  template <typename _Tp, typename... _Types>
    constexpr _Tp&&
    get(tuple<_Types...>&& __t) noexcept
    { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }


  template <typename _Tp, typename... _Types>
    constexpr const _Tp&
    get(const tuple<_Types...>& __t) noexcept
    { return std::__get_helper2<_Tp>(__t); }



  template <typename _Tp, typename... _Types>
    constexpr const _Tp&&
    get(const tuple<_Types...>&& __t) noexcept
    { return std::forward<const _Tp&&>(std::__get_helper2<_Tp>(__t)); }



  template<typename _Tp, typename _Up, size_t __i, size_t __size>
    struct __tuple_compare
    {
      static constexpr bool
      __eq(const _Tp& __t, const _Up& __u)
      {
 return bool(std::get<__i>(__t) == std::get<__i>(__u))
   && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
      }

      static constexpr bool
      __less(const _Tp& __t, const _Up& __u)
      {
 return bool(std::get<__i>(__t) < std::get<__i>(__u))
   || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
       && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
      }
    };

  template<typename _Tp, typename _Up, size_t __size>
    struct __tuple_compare<_Tp, _Up, __size, __size>
    {
      static constexpr bool
      __eq(const _Tp&, const _Up&) { return true; }

      static constexpr bool
      __less(const _Tp&, const _Up&) { return false; }
    };

  template<typename... _TElements, typename... _UElements>
    constexpr bool
    operator==(const tuple<_TElements...>& __t,
        const tuple<_UElements...>& __u)
    {
      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
   "tuple objects can only be compared if they have equal sizes.");
      using __compare = __tuple_compare<tuple<_TElements...>,
     tuple<_UElements...>,
     0, sizeof...(_TElements)>;
      return __compare::__eq(__t, __u);
    }

  template<typename... _TElements, typename... _UElements>
    constexpr bool
    operator<(const tuple<_TElements...>& __t,
       const tuple<_UElements...>& __u)
    {
      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
   "tuple objects can only be compared if they have equal sizes.");
      using __compare = __tuple_compare<tuple<_TElements...>,
     tuple<_UElements...>,
     0, sizeof...(_TElements)>;
      return __compare::__less(__t, __u);
    }

  template<typename... _TElements, typename... _UElements>
    constexpr bool
    operator!=(const tuple<_TElements...>& __t,
        const tuple<_UElements...>& __u)
    { return !(__t == __u); }

  template<typename... _TElements, typename... _UElements>
    constexpr bool
    operator>(const tuple<_TElements...>& __t,
       const tuple<_UElements...>& __u)
    { return __u < __t; }

  template<typename... _TElements, typename... _UElements>
    constexpr bool
    operator<=(const tuple<_TElements...>& __t,
        const tuple<_UElements...>& __u)
    { return !(__u < __t); }

  template<typename... _TElements, typename... _UElements>
    constexpr bool
    operator>=(const tuple<_TElements...>& __t,
        const tuple<_UElements...>& __u)
    { return !(__t < __u); }


  template<typename... _Elements>
    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
    make_tuple(_Elements&&... __args)
    {
      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
 __result_type;
      return __result_type(std::forward<_Elements>(__args)...);
    }




  template<typename... _Elements>
    constexpr tuple<_Elements&&...>
    forward_as_tuple(_Elements&&... __args) noexcept
    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }

  template<size_t, typename, typename, size_t>
    struct __make_tuple_impl;

  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
    : __make_tuple_impl<_Idx + 1,
   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
   _Tuple, _Nm>
    { };

  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
    {
      typedef tuple<_Tp...> __type;
    };

  template<typename _Tuple>
    struct __do_make_tuple
    : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
    { };


  template<typename _Tuple>
    struct __make_tuple
    : public __do_make_tuple<__remove_cvref_t<_Tuple>>
    { };


  template<typename...>
    struct __combine_tuples;

  template<>
    struct __combine_tuples<>
    {
      typedef tuple<> __type;
    };

  template<typename... _Ts>
    struct __combine_tuples<tuple<_Ts...>>
    {
      typedef tuple<_Ts...> __type;
    };

  template<typename... _T1s, typename... _T2s, typename... _Rem>
    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
    {
      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
     _Rem...>::__type __type;
    };


  template<typename... _Tpls>
    struct __tuple_cat_result
    {
      typedef typename __combine_tuples
        <typename __make_tuple<_Tpls>::__type...>::__type __type;
    };



  template<typename...>
    struct __make_1st_indices;

  template<>
    struct __make_1st_indices<>
    {
      typedef std::_Index_tuple<> __type;
    };

  template<typename _Tp, typename... _Tpls>
    struct __make_1st_indices<_Tp, _Tpls...>
    {
      typedef typename std::_Build_index_tuple<std::tuple_size<
 typename std::remove_reference<_Tp>::type>::value>::__type __type;
    };




  template<typename _Ret, typename _Indices, typename... _Tpls>
    struct __tuple_concater;

  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
    struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
    {
      template<typename... _Us>
        static constexpr _Ret
        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
        {
   typedef typename __make_1st_indices<_Tpls...>::__type __idx;
   typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
   return __next::_S_do(std::forward<_Tpls>(__tps)...,
          std::forward<_Us>(__us)...,
          std::get<_Is>(std::forward<_Tp>(__tp))...);
 }
    };

  template<typename _Ret>
    struct __tuple_concater<_Ret, std::_Index_tuple<>>
    {
      template<typename... _Us>
 static constexpr _Ret
 _S_do(_Us&&... __us)
        {
   return _Ret(std::forward<_Us>(__us)...);
 }
    };


  template<typename... _Tpls, typename = typename
           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
    constexpr auto
    tuple_cat(_Tpls&&... __tpls)
    -> typename __tuple_cat_result<_Tpls...>::__type
    {
      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
    }




  template<typename... _Elements>
    constexpr tuple<_Elements&...>
    tie(_Elements&... __args) noexcept
    { return tuple<_Elements&...>(__args...); }


  template<typename... _Elements>
   
    inline


    typename enable_if<__and_<__is_swappable<_Elements>...>::value
      >::type



    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }


  template<typename... _Elements>
   
    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;






  struct _Swallow_assign
  {
    template<class _Tp>
      constexpr const _Swallow_assign&
      operator=(const _Tp&) const
      { return *this; }
  };



  inline constexpr _Swallow_assign ignore{};


  template<typename... _Types, typename _Alloc>
    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
# 1635 "/usr/include/c++/10/tuple" 3
  template<class _T1, class _T2>
    template<typename... _Args1, typename... _Args2>
     
      inline
      pair<_T1, _T2>::
      pair(piecewise_construct_t,
    tuple<_Args1...> __first, tuple<_Args2...> __second)
      : pair(__first, __second,
      typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
      typename _Build_index_tuple<sizeof...(_Args2)>::__type())
      { }

  template<class _T1, class _T2>
    template<typename... _Args1, std::size_t... _Indexes1,
             typename... _Args2, std::size_t... _Indexes2>
      inline
      pair<_T1, _T2>::
      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
    _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
        second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
      { }







  template<template<typename...> class _Trait, typename _Tp, typename _Tuple>
    inline constexpr bool __unpack_std_tuple = false;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>>
      = _Trait<_Tp, _Up...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&>
      = _Trait<_Tp, _Up&...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>>
      = _Trait<_Tp, const _Up...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
      = _Trait<_Tp, const _Up&...>::value;



  template <typename _Fn, typename _Tuple, size_t... _Idx>
    constexpr decltype(auto)
    __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
    {
      return std::__invoke(std::forward<_Fn>(__f),
      std::get<_Idx>(std::forward<_Tuple>(__t))...);
    }

  template <typename _Fn, typename _Tuple>
    constexpr decltype(auto)
    apply(_Fn&& __f, _Tuple&& __t)
    noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>)
    {
      using _Indices
 = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>;
      return std::__apply_impl(std::forward<_Fn>(__f),
          std::forward<_Tuple>(__t),
          _Indices{});
    }



  template <typename _Tp, typename _Tuple, size_t... _Idx>
    constexpr _Tp
    __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
    { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }

  template <typename _Tp, typename _Tuple>
    constexpr _Tp
    make_from_tuple(_Tuple&& __t)
    noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>)
    {
      return __make_from_tuple_impl<_Tp>(
        std::forward<_Tuple>(__t),
 make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
    }





}
# 55 "/usr/include/c++/10/functional" 2 3

# 1 "/usr/include/c++/10/bits/functional_hash.h" 1 3
# 33 "/usr/include/c++/10/bits/functional_hash.h" 3
       
# 34 "/usr/include/c++/10/bits/functional_hash.h" 3



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

# 49 "/usr/include/c++/10/bits/functional_hash.h" 3
  template<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); }
    };
# 124 "/usr/include/c++/10/bits/functional_hash.h" 3
  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };







  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
# 192 "/usr/include/c++/10/bits/functional_hash.h" 3
  struct _Hash_impl
  {
    static size_t
    hash(const void* __ptr, size_t __clength,
  size_t __seed = static_cast<size_t>(0xc70f6907UL))
    { return _Hash_bytes(__ptr, __clength, __seed); }

    template<typename _Tp>
      static size_t
      hash(const _Tp& __val)
      { return hash(&__val, sizeof(__val)); }

    template<typename _Tp>
      static size_t
      __hash_combine(const _Tp& __val, size_t __hash)
      { return hash(&__val, sizeof(__val), __hash); }
  };


  struct _Fnv_hash_impl
  {
    static size_t
    hash(const void* __ptr, size_t __clength,
  size_t __seed = static_cast<size_t>(2166136261UL))
    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }

    template<typename _Tp>
      static size_t
      hash(const _Tp& __val)
      { return hash(&__val, sizeof(__val)); }

    template<typename _Tp>
      static size_t
      __hash_combine(const _Tp& __val, size_t __hash)
      { return hash(&__val, sizeof(__val), __hash); }
  };


  template<>
    struct hash<float> : public __hash_base<size_t, float>
    {
      size_t
      operator()(float __val) const noexcept
      {

 return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
      }
    };


  template<>
    struct hash<double> : public __hash_base<size_t, double>
    {
      size_t
      operator()(double __val) const noexcept
      {

 return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
      }
    };


  template<>
    struct hash<long double>
    : public __hash_base<size_t, long double>
    {
      __attribute__ ((__pure__)) size_t
      operator()(long double __val) const noexcept;
    };


  template<>
    struct hash<nullptr_t> : public __hash_base<size_t, nullptr_t>
    {
      size_t
      operator()(nullptr_t) const noexcept
      { return 0; }
    };
# 278 "/usr/include/c++/10/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
    { };


}
# 57 "/usr/include/c++/10/functional" 2 3

# 1 "/usr/include/c++/10/bits/refwrap.h" 1 3
# 33 "/usr/include/c++/10/bits/refwrap.h" 3
       
# 34 "/usr/include/c++/10/bits/refwrap.h" 3
# 43 "/usr/include/c++/10/bits/refwrap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 54 "/usr/include/c++/10/bits/refwrap.h" 3
  template<typename _Res, typename... _ArgTypes>
    struct _Maybe_unary_or_binary_function { };


  template<typename _Res, typename _T1>
    struct _Maybe_unary_or_binary_function<_Res, _T1>
    : std::unary_function<_T1, _Res> { };


  template<typename _Res, typename _T1, typename _T2>
    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
    : std::binary_function<_T1, _T2, _Res> { };

  template<typename _Signature>
    struct _Mem_fn_traits;

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Mem_fn_traits_base
    {
      using __result_type = _Res;
      using __maybe_type
 = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
    };
# 99 "/usr/include/c++/10/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>
    { };



  template<typename _Tp, typename = __void_t<>>
    struct _Refwrap_base_arg1
    { };


  template<typename _Tp>
    struct _Refwrap_base_arg1<_Tp,
         __void_t<typename _Tp::argument_type>>
    {
      typedef typename _Tp::argument_type argument_type;
    };


  template<typename _Tp, typename = __void_t<>>
    struct _Refwrap_base_arg2
    { };


  template<typename _Tp>
    struct _Refwrap_base_arg2<_Tp,
         __void_t<typename _Tp::first_argument_type,
           typename _Tp::second_argument_type>>
    {
      typedef typename _Tp::first_argument_type first_argument_type;
      typedef typename _Tp::second_argument_type second_argument_type;
    };







  template<typename _Tp>
    struct _Reference_wrapper_base
    : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
    { };


  template<typename _Res, typename _T1 , bool _NE>
    struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) volatile>
    : unary_function<_T1, _Res>
    { };

  template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const volatile>
    : unary_function<_T1, _Res>
    { };


  template<typename _Res, typename _T1, typename _T2 , bool _NE>
    struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
    : binary_function<_T1, _T2, _Res>
    { };


  template<typename _Res, typename _T1 , bool _NE>
    struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)>
    : unary_function<_T1, _Res>
    { };


  template<typename _Res, typename _T1, typename _T2 , bool _NE>
    struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)>
    : binary_function<_T1, _T2, _Res>
    { };

  template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
    struct _Reference_wrapper_base_memfun
    : _Reference_wrapper_base<_Tp>
    { };

  template<typename _MemFunPtr>
    struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
    : _Mem_fn_traits<_MemFunPtr>::__maybe_type
    {
      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
    };
# 293 "/usr/include/c++/10/bits/refwrap.h" 3
  template<typename _Tp>
    class reference_wrapper



    : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type>

    {
      _Tp* _M_data;

     
      static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }

      static void _S_fun(_Tp&&) = delete;

      template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>
 using __not_same
   = typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;

    public:
      typedef _Tp type;




      template<typename _Up, typename = __not_same<_Up>, typename
  = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>

 reference_wrapper(_Up&& __uref)
 noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
 : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
 { }

      reference_wrapper(const reference_wrapper&) = default;

      reference_wrapper&
      operator=(const reference_wrapper&) = default;

     
      operator _Tp&() const noexcept
      { return this->get(); }

     
      _Tp&
      get() const noexcept
      { return *_M_data; }

      template<typename... _Args>

 typename result_of<_Tp&(_Args&&...)>::type
 operator()(_Args&&... __args) const
 {



   return std::__invoke(get(), std::forward<_Args>(__args)...);
 }
    };


  template<typename _Tp>
    reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;





  template<typename _Tp>
   
    inline reference_wrapper<_Tp>
    ref(_Tp& __t) noexcept
    { return reference_wrapper<_Tp>(__t); }


  template<typename _Tp>
   
    inline reference_wrapper<const _Tp>
    cref(const _Tp& __t) noexcept
    { return reference_wrapper<const _Tp>(__t); }

  template<typename _Tp>
    void ref(const _Tp&&) = delete;

  template<typename _Tp>
    void cref(const _Tp&&) = delete;


  template<typename _Tp>
   
    inline reference_wrapper<_Tp>
    ref(reference_wrapper<_Tp> __t) noexcept
    { return __t; }


  template<typename _Tp>
   
    inline reference_wrapper<const _Tp>
    cref(reference_wrapper<_Tp> __t) noexcept
    { return { __t.get() }; }




}
# 59 "/usr/include/c++/10/functional" 2 3
# 1 "/usr/include/c++/10/bits/std_function.h" 1 3
# 33 "/usr/include/c++/10/bits/std_function.h" 3
       
# 34 "/usr/include/c++/10/bits/std_function.h" 3
# 47 "/usr/include/c++/10/bits/std_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  class bad_function_call : public std::exception
  {
  public:
    virtual ~bad_function_call() noexcept;

    const char* what() const noexcept;
  };







  template<typename _Tp>
    struct __is_location_invariant
    : is_trivially_copyable<_Tp>::type
    { };

  class _Undefined_class;

  union _Nocopy_types
  {
    void* _M_object;
    const void* _M_const_object;
    void (*_M_function_pointer)();
    void (_Undefined_class::*_M_member_pointer)();
  };

  union [[gnu::may_alias]] _Any_data
  {
    void* _M_access() { return &_M_pod_data[0]; }
    const void* _M_access() const { return &_M_pod_data[0]; }

    template<typename _Tp>
      _Tp&
      _M_access()
      { return *static_cast<_Tp*>(_M_access()); }

    template<typename _Tp>
      const _Tp&
      _M_access() const
      { return *static_cast<const _Tp*>(_M_access()); }

    _Nocopy_types _M_unused;
    char _M_pod_data[sizeof(_Nocopy_types)];
  };

  enum _Manager_operation
  {
    __get_type_info,
    __get_functor_ptr,
    __clone_functor,
    __destroy_functor
  };

  template<typename _Signature>
    class function;


  class _Function_base
  {
  public:
    static const size_t _M_max_size = sizeof(_Nocopy_types);
    static const size_t _M_max_align = __alignof__(_Nocopy_types);

    template<typename _Functor>
      class _Base_manager
      {
      protected:
 static const bool __stored_locally =
 (__is_location_invariant<_Functor>::value
  && sizeof(_Functor) <= _M_max_size
  && __alignof__(_Functor) <= _M_max_align
  && (_M_max_align % __alignof__(_Functor) == 0));

 typedef integral_constant<bool, __stored_locally> _Local_storage;


 static _Functor*
 _M_get_pointer(const _Any_data& __source)
 {
   if constexpr (__stored_locally)
     {
       const _Functor& __f = __source._M_access<_Functor>();
       return const_cast<_Functor*>(std::__addressof(__f));
     }
   else
     return __source._M_access<_Functor*>();
 }



 static void
 _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
 {
   ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
 }



 static void
 _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
 {
   __dest._M_access<_Functor*>() =
     new _Functor(*__source._M_access<const _Functor*>());
 }



 static void
 _M_destroy(_Any_data& __victim, true_type)
 {
   __victim._M_access<_Functor>().~_Functor();
 }


 static void
 _M_destroy(_Any_data& __victim, false_type)
 {
   delete __victim._M_access<_Functor*>();
 }

      public:
 static bool
 _M_manager(_Any_data& __dest, const _Any_data& __source,
     _Manager_operation __op)
 {
   switch (__op)
     {

     case __get_type_info:
       __dest._M_access<const type_info*>() = &typeid(_Functor);
       break;

     case __get_functor_ptr:
       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
       break;

     case __clone_functor:
       _M_clone(__dest, __source, _Local_storage());
       break;

     case __destroy_functor:
       _M_destroy(__dest, _Local_storage());
       break;
     }
   return false;
 }

 static void
 _M_init_functor(_Any_data& __functor, _Functor&& __f)
 { _M_init_functor(__functor, std::move(__f), _Local_storage()); }

 template<typename _Signature>
   static bool
   _M_not_empty_function(const function<_Signature>& __f)
   { return static_cast<bool>(__f); }

 template<typename _Tp>
   static bool
   _M_not_empty_function(_Tp* __fp)
   { return __fp != nullptr; }

 template<typename _Class, typename _Tp>
   static bool
   _M_not_empty_function(_Tp _Class::* __mp)
   { return __mp != nullptr; }

 template<typename _Tp>
   static bool
   _M_not_empty_function(const _Tp&)
   { return true; }

      private:
 static void
 _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
 { ::new (__functor._M_access()) _Functor(std::move(__f)); }

 static void
 _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
 { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
      };

    _Function_base() : _M_manager(nullptr) { }

    ~_Function_base()
    {
      if (_M_manager)
 _M_manager(_M_functor, _M_functor, __destroy_functor);
    }

    bool _M_empty() const { return !_M_manager; }

    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
      _Manager_operation);

    _Any_data _M_functor;
    _Manager_type _M_manager;
  };

  template<typename _Signature, typename _Functor>
    class _Function_handler;

  template<typename _Res, typename _Functor, typename... _ArgTypes>
    class _Function_handler<_Res(_ArgTypes...), _Functor>
    : public _Function_base::_Base_manager<_Functor>
    {
      typedef _Function_base::_Base_manager<_Functor> _Base;

    public:
      static bool
      _M_manager(_Any_data& __dest, const _Any_data& __source,
   _Manager_operation __op)
      {
 switch (__op)
   {

   case __get_type_info:
     __dest._M_access<const type_info*>() = &typeid(_Functor);
     break;

   case __get_functor_ptr:
     __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
     break;

   default:
     _Base::_M_manager(__dest, __source, __op);
   }
 return false;
      }

      static _Res
      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
      {
 return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor),
         std::forward<_ArgTypes>(__args)...);
      }
    };







  template<typename _Res, typename... _ArgTypes>
    class function<_Res(_ArgTypes...)>
    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
      private _Function_base
    {
      template<typename _Func,
        typename _Res2 = __invoke_result<_Func&, _ArgTypes...>>
 struct _Callable
 : __is_invocable_impl<_Res2, _Res>::type
 { };



      template<typename _Tp>
 struct _Callable<function, _Tp> : false_type { };

      template<typename _Cond, typename _Tp>
 using _Requires = typename enable_if<_Cond::value, _Tp>::type;

    public:
      typedef _Res result_type;







      function() noexcept
      : _Function_base() { }





      function(nullptr_t) noexcept
      : _Function_base() { }
# 348 "/usr/include/c++/10/bits/std_function.h" 3
      function(const function& __x);
# 357 "/usr/include/c++/10/bits/std_function.h" 3
      function(function&& __x) noexcept : _Function_base()
      {
 __x.swap(*this);
      }
# 378 "/usr/include/c++/10/bits/std_function.h" 3
      template<typename _Functor,
        typename = _Requires<__not_<is_same<_Functor, function>>, void>,
        typename = _Requires<_Callable<_Functor>, void>>
 function(_Functor);
# 395 "/usr/include/c++/10/bits/std_function.h" 3
      function&
      operator=(const function& __x)
      {
 function(__x).swap(*this);
 return *this;
      }
# 413 "/usr/include/c++/10/bits/std_function.h" 3
      function&
      operator=(function&& __x) noexcept
      {
 function(std::move(__x)).swap(*this);
 return *this;
      }
# 427 "/usr/include/c++/10/bits/std_function.h" 3
      function&
      operator=(nullptr_t) noexcept
      {
 if (_M_manager)
   {
     _M_manager(_M_functor, _M_functor, __destroy_functor);
     _M_manager = nullptr;
     _M_invoker = nullptr;
   }
 return *this;
      }
# 455 "/usr/include/c++/10/bits/std_function.h" 3
      template<typename _Functor>
 _Requires<_Callable<typename decay<_Functor>::type>, function&>
 operator=(_Functor&& __f)
 {
   function(std::forward<_Functor>(__f)).swap(*this);
   return *this;
 }


      template<typename _Functor>
 function&
 operator=(reference_wrapper<_Functor> __f) noexcept
 {
   function(__f).swap(*this);
   return *this;
 }
# 481 "/usr/include/c++/10/bits/std_function.h" 3
      void swap(function& __x) noexcept
      {
 std::swap(_M_functor, __x._M_functor);
 std::swap(_M_manager, __x._M_manager);
 std::swap(_M_invoker, __x._M_invoker);
      }
# 498 "/usr/include/c++/10/bits/std_function.h" 3
      explicit operator bool() const noexcept
      { return !_M_empty(); }
# 511 "/usr/include/c++/10/bits/std_function.h" 3
      _Res operator()(_ArgTypes... __args) const;
# 524 "/usr/include/c++/10/bits/std_function.h" 3
      const type_info& target_type() const noexcept;
# 537 "/usr/include/c++/10/bits/std_function.h" 3
      template<typename _Functor> _Functor* target() noexcept;

      template<typename _Functor> const _Functor* target() const noexcept;



    private:
      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
      _Invoker_type _M_invoker;
  };


  template<typename>
    struct __function_guide_helper
    { };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) & noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) const noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename... _ArgTypes>
    function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;

  template<typename _Functor, typename _Signature = typename
    __function_guide_helper<decltype(&_Functor::operator())>::type>
    function(_Functor) -> function<_Signature>;



  template<typename _Res, typename... _ArgTypes>
    function<_Res(_ArgTypes...)>::
    function(const function& __x)
    : _Function_base()
    {
      if (static_cast<bool>(__x))
 {
   __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
   _M_invoker = __x._M_invoker;
   _M_manager = __x._M_manager;
 }
    }

  template<typename _Res, typename... _ArgTypes>
    template<typename _Functor, typename, typename>
      function<_Res(_ArgTypes...)>::
      function(_Functor __f)
      : _Function_base()
      {
 typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;

 if (_My_handler::_M_not_empty_function(__f))
   {
     _My_handler::_M_init_functor(_M_functor, std::move(__f));
     _M_invoker = &_My_handler::_M_invoke;
     _M_manager = &_My_handler::_M_manager;
   }
      }

  template<typename _Res, typename... _ArgTypes>
    _Res
    function<_Res(_ArgTypes...)>::
    operator()(_ArgTypes... __args) const
    {
      if (_M_empty())
 __throw_bad_function_call();
      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
    }


  template<typename _Res, typename... _ArgTypes>
    const type_info&
    function<_Res(_ArgTypes...)>::
    target_type() const noexcept
    {
      if (_M_manager)
 {
   _Any_data __typeinfo_result;
   _M_manager(__typeinfo_result, _M_functor, __get_type_info);
   return *__typeinfo_result._M_access<const type_info*>();
 }
      else
 return typeid(void);
    }

  template<typename _Res, typename... _ArgTypes>
    template<typename _Functor>
      _Functor*
      function<_Res(_ArgTypes...)>::
      target() noexcept
      {
 const function* __const_this = this;
 const _Functor* __func = __const_this->template target<_Functor>();
 return const_cast<_Functor*>(__func);
      }

  template<typename _Res, typename... _ArgTypes>
    template<typename _Functor>
      const _Functor*
      function<_Res(_ArgTypes...)>::
      target() const noexcept
      {
 if (typeid(_Functor) == target_type() && _M_manager)
   {
     _Any_data __ptr;
     _M_manager(__ptr, _M_functor, __get_functor_ptr);
     return __ptr._M_access<const _Functor*>();
   }
 else
   return nullptr;
      }
# 678 "/usr/include/c++/10/bits/std_function.h" 3
  template<typename _Res, typename... _Args>
    inline bool
    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
    { return !static_cast<bool>(__f); }


  template<typename _Res, typename... _Args>
    inline bool
    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
    { return !static_cast<bool>(__f); }
# 696 "/usr/include/c++/10/bits/std_function.h" 3
  template<typename _Res, typename... _Args>
    inline bool
    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
    { return static_cast<bool>(__f); }


  template<typename _Res, typename... _Args>
    inline bool
    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
    { return static_cast<bool>(__f); }
# 717 "/usr/include/c++/10/bits/std_function.h" 3
  template<typename _Res, typename... _Args>
    inline void
    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
    { __x.swap(__y); }


  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Signature>
      struct _Never_valueless_alt<std::function<_Signature>>
      : std::true_type
      { };
  }



}
# 60 "/usr/include/c++/10/functional" 2 3

# 1 "/usr/include/c++/10/unordered_map" 1 3
# 32 "/usr/include/c++/10/unordered_map" 3
       
# 33 "/usr/include/c++/10/unordered_map" 3







# 1 "/usr/include/c++/10/bits/allocator.h" 1 3
# 46 "/usr/include/c++/10/bits/allocator.h" 3
# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++allocator.h" 1 3
# 33 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++allocator.h" 3
# 1 "/usr/include/c++/10/ext/new_allocator.h" 1 3
# 40 "/usr/include/c++/10/ext/new_allocator.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{

# 54 "/usr/include/c++/10/ext/new_allocator.h" 3
  template<typename _Tp>
    class new_allocator
    {
    public:
      typedef _Tp value_type;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;

      typedef _Tp* pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      typedef const _Tp& const_reference;

      template<typename _Tp1>
 struct rebind
 { typedef new_allocator<_Tp1> other; };





      typedef std::true_type propagate_on_container_move_assignment;


     
      new_allocator() noexcept { }

     
      new_allocator(const new_allocator&) noexcept { }

      template<typename _Tp1>

 new_allocator(const new_allocator<_Tp1>&) noexcept { }


      ~new_allocator() noexcept { }

      pointer
      address(reference __x) const noexcept
      { return std::__addressof(__x); }

      const_pointer
      address(const_reference __x) const noexcept
      { return std::__addressof(__x); }




      [[__nodiscard__]] _Tp*
      allocate(size_type __n, const void* = static_cast<const void*>(0))
      {
 if (__n > this->_M_max_size())
   std::__throw_bad_alloc();


 if (alignof(_Tp) > 16)
   {
     std::align_val_t __al = std::align_val_t(alignof(_Tp));
     return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
   }

 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
      }


      void
      deallocate(_Tp* __p, size_type __t)
      {

 if (alignof(_Tp) > 16)
   {
     ::operator delete(__p,

         __t * sizeof(_Tp),

         std::align_val_t(alignof(_Tp)));
     return;
   }

 ::operator delete(__p

     , __t * sizeof(_Tp)

    );
      }


      size_type
      max_size() const noexcept
      { return _M_max_size(); }


      template<typename _Up, typename... _Args>
 void
 construct(_Up* __p, _Args&&... __args)
 noexcept(noexcept(::new((void *)__p)
       _Up(std::forward<_Args>(__args)...)))
 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }

      template<typename _Up>
 void
 destroy(_Up* __p)
 noexcept(noexcept( __p->~_Up()))
 { __p->~_Up(); }
# 170 "/usr/include/c++/10/ext/new_allocator.h" 3
      template<typename _Up>
 friend bool
 operator==(const new_allocator&, const new_allocator<_Up>&)
 noexcept
 { return true; }

      template<typename _Up>
 friend bool
 operator!=(const new_allocator&, const new_allocator<_Up>&)
 noexcept
 { return false; }

    private:
      constexpr size_type
      _M_max_size() const noexcept
      {

 return std::size_t(0x7fffffffffffffffL) / sizeof(_Tp);



      }
    };


}
# 34 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++allocator.h" 2 3


namespace std
{
# 47 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++allocator.h" 3
  template<typename _Tp>
    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
}
# 47 "/usr/include/c++/10/bits/allocator.h" 2 3
# 1 "/usr/include/c++/10/bits/memoryfwd.h" 1 3
# 46 "/usr/include/c++/10/bits/memoryfwd.h" 3
       
# 47 "/usr/include/c++/10/bits/memoryfwd.h" 3



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

# 63 "/usr/include/c++/10/bits/memoryfwd.h" 3
  template<typename>
    class allocator;


  template<>
    class allocator<void>;




  template<typename, typename>
    struct uses_allocator;





}
# 48 "/usr/include/c++/10/bits/allocator.h" 2 3
# 57 "/usr/include/c++/10/bits/allocator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{








  template<>
    class allocator<void>
    {
    public:
      typedef void value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;

      typedef void* pointer;
      typedef const void* const_pointer;

      template<typename _Tp1>
 struct rebind
 { typedef allocator<_Tp1> other; };
# 92 "/usr/include/c++/10/bits/allocator.h" 3
      typedef true_type propagate_on_container_move_assignment;

      typedef true_type is_always_equal;

      template<typename _Up, typename... _Args>
 void
 construct(_Up* __p, _Args&&... __args)
 noexcept(noexcept(::new((void *)__p)
       _Up(std::forward<_Args>(__args)...)))
 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }

      template<typename _Up>
 void
 destroy(_Up* __p)
 noexcept(noexcept(__p->~_Up()))
 { __p->~_Up(); }

    };
# 119 "/usr/include/c++/10/bits/allocator.h" 3
  template<typename _Tp>
    class allocator : public __allocator_base<_Tp>
    {
    public:
      typedef _Tp value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;

      typedef _Tp* pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      typedef const _Tp& const_reference;

      template<typename _Tp1>
 struct rebind
 { typedef allocator<_Tp1> other; };





      typedef true_type propagate_on_container_move_assignment;

      typedef true_type is_always_equal;




     
      allocator() noexcept { }

     
      allocator(const allocator& __a) noexcept
      : __allocator_base<_Tp>(__a) { }



      allocator& operator=(const allocator&) = default;


      template<typename _Tp1>

 allocator(const allocator<_Tp1>&) noexcept { }




      ~allocator() noexcept { }
# 195 "/usr/include/c++/10/bits/allocator.h" 3
      friend bool
      operator==(const allocator&, const allocator&) noexcept
      { return true; }

      friend bool
      operator!=(const allocator&, const allocator&) noexcept
      { return false; }


    };

  template<typename _T1, typename _T2>
    inline bool
    operator==(const allocator<_T1>&, const allocator<_T2>&)
    noexcept
    { return true; }

  template<typename _T1, typename _T2>
    inline bool
    operator!=(const allocator<_T1>&, const allocator<_T2>&)
    noexcept
    { return false; }



  template<typename _Tp>
    class allocator<const _Tp>
    {
    public:
      typedef _Tp value_type;
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };

  template<typename _Tp>
    class allocator<volatile _Tp>
    {
    public:
      typedef _Tp value_type;
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };

  template<typename _Tp>
    class allocator<const volatile _Tp>
    {
    public:
      typedef _Tp value_type;
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };






  extern template class allocator<char>;
  extern template class allocator<wchar_t>;






  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_swap
    { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };

  template<typename _Alloc>
    struct __alloc_swap<_Alloc, false>
    {
      static void
      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
      {

 if (__one != __two)
   swap(__one, __two);
      }
    };


  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_neq
    {
      static bool
      _S_do_it(const _Alloc&, const _Alloc&)
      { return false; }
    };

  template<typename _Alloc>
    struct __alloc_neq<_Alloc, false>
    {
      static bool
      _S_do_it(const _Alloc& __one, const _Alloc& __two)
      { return __one != __two; }
    };


  template<typename _Tp, bool
    = __or_<is_copy_constructible<typename _Tp::value_type>,
            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
    struct __shrink_to_fit_aux
    { static bool _S_do_it(_Tp&) noexcept { return false; } };

  template<typename _Tp>
    struct __shrink_to_fit_aux<_Tp, true>
    {
      static bool
      _S_do_it(_Tp& __c) noexcept
      {

 try
   {
     _Tp(__make_move_if_noexcept_iterator(__c.begin()),
  __make_move_if_noexcept_iterator(__c.end()),
  __c.get_allocator()).swap(__c);
     return true;
   }
 catch(...)
   { return false; }



      }
    };



}
# 41 "/usr/include/c++/10/unordered_map" 2 3
# 1 "/usr/include/c++/10/ext/alloc_traits.h" 1 3
# 32 "/usr/include/c++/10/ext/alloc_traits.h" 3
       
# 33 "/usr/include/c++/10/ext/alloc_traits.h" 3

# 1 "/usr/include/c++/10/bits/alloc_traits.h" 1 3
# 41 "/usr/include/c++/10/bits/alloc_traits.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{





  struct __allocator_traits_base
  {
    template<typename _Tp, typename _Up, typename = void>
      struct __rebind : __replace_first_arg<_Tp, _Up> { };

    template<typename _Tp, typename _Up>
      struct __rebind<_Tp, _Up,
        __void_t<typename _Tp::template rebind<_Up>::other>>
      { using type = typename _Tp::template rebind<_Up>::other; };

  protected:
    template<typename _Tp>
      using __pointer = typename _Tp::pointer;
    template<typename _Tp>
      using __c_pointer = typename _Tp::const_pointer;
    template<typename _Tp>
      using __v_pointer = typename _Tp::void_pointer;
    template<typename _Tp>
      using __cv_pointer = typename _Tp::const_void_pointer;
    template<typename _Tp>
      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
    template<typename _Tp>
      using __pocma = typename _Tp::propagate_on_container_move_assignment;
    template<typename _Tp>
      using __pocs = typename _Tp::propagate_on_container_swap;
    template<typename _Tp>
      using __equal = typename _Tp::is_always_equal;
  };

  template<typename _Alloc, typename _Up>
    using __alloc_rebind
      = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;





  template<typename _Alloc>
    struct allocator_traits : __allocator_traits_base
    {

      typedef _Alloc allocator_type;

      typedef typename _Alloc::value_type value_type;






      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;

    private:

      template<template<typename> class _Func, typename _Tp, typename = void>
 struct _Ptr
 {
   using type = typename pointer_traits<pointer>::template rebind<_Tp>;
 };

      template<template<typename> class _Func, typename _Tp>
 struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
 {
   using type = _Func<_Alloc>;
 };


      template<typename _A2, typename _PtrT, typename = void>
 struct _Diff
 { using type = typename pointer_traits<_PtrT>::difference_type; };

      template<typename _A2, typename _PtrT>
 struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
 { using type = typename _A2::difference_type; };


      template<typename _A2, typename _DiffT, typename = void>
 struct _Size : make_unsigned<_DiffT> { };

      template<typename _A2, typename _DiffT>
 struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
 { using type = typename _A2::size_type; };

    public:






      using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;







      using void_pointer = typename _Ptr<__v_pointer, void>::type;







      using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;







      using difference_type = typename _Diff<_Alloc, pointer>::type;







      using size_type = typename _Size<_Alloc, difference_type>::type;







      using propagate_on_container_copy_assignment
 = __detected_or_t<false_type, __pocca, _Alloc>;







      using propagate_on_container_move_assignment
 = __detected_or_t<false_type, __pocma, _Alloc>;







      using propagate_on_container_swap
 = __detected_or_t<false_type, __pocs, _Alloc>;







      using is_always_equal
 = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;

      template<typename _Tp>
 using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
      template<typename _Tp>
 using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;

    private:
      template<typename _Alloc2>
 static constexpr auto
 _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
 -> decltype(__a.allocate(__n, __hint))
 { return __a.allocate(__n, __hint); }

      template<typename _Alloc2>
 static constexpr pointer
 _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
 { return __a.allocate(__n); }

      template<typename _Tp, typename... _Args>
 struct __construct_helper
 {
   template<typename _Alloc2,
     typename = decltype(std::declval<_Alloc2*>()->construct(
    std::declval<_Tp*>(), std::declval<_Args>()...))>
     static true_type __test(int);

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

   using type = decltype(__test<_Alloc>(0));
 };

      template<typename _Tp, typename... _Args>
 using __has_construct
   = typename __construct_helper<_Tp, _Args...>::type;

      template<typename _Tp, typename... _Args>
 static constexpr _Require<__has_construct<_Tp, _Args...>>
 _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
 noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
 { __a.construct(__p, std::forward<_Args>(__args)...); }

      template<typename _Tp, typename... _Args>
 static constexpr
 _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
          is_constructible<_Tp, _Args...>>>
 _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
 noexcept(noexcept(::new((void*)__p)
     _Tp(std::forward<_Args>(__args)...)))
 { std::_Construct(__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(noexcept(__p->~_Tp()))
 { 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:
# 307 "/usr/include/c++/10/bits/alloc_traits.h" 3
      [[__nodiscard__]] static pointer
      allocate(_Alloc& __a, size_type __n)
      { return __a.allocate(__n); }
# 322 "/usr/include/c++/10/bits/alloc_traits.h" 3
      [[__nodiscard__]] static pointer
      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
      { return _S_allocate(__a, __n, __hint, 0); }
# 334 "/usr/include/c++/10/bits/alloc_traits.h" 3
      static void
      deallocate(_Alloc& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 349 "/usr/include/c++/10/bits/alloc_traits.h" 3
      template<typename _Tp, typename... _Args>
 static auto
 construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
 noexcept(noexcept(_S_construct(__a, __p,
           std::forward<_Args>(__args)...)))
 -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
 { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
# 365 "/usr/include/c++/10/bits/alloc_traits.h" 3
      template<typename _Tp>
 static void
 destroy(_Alloc& __a, _Tp* __p)
 noexcept(noexcept(_S_destroy(__a, __p, 0)))
 { _S_destroy(__a, __p, 0); }
# 379 "/usr/include/c++/10/bits/alloc_traits.h" 3
      static size_type
      max_size(const _Alloc& __a) noexcept
      { return _S_max_size(__a, 0); }
# 391 "/usr/include/c++/10/bits/alloc_traits.h" 3
      static _Alloc
      select_on_container_copy_construction(const _Alloc& __rhs)
      { return _S_select(__rhs, 0); }
    };






  template<typename _Tp>
    struct allocator_traits<allocator<_Tp>>
    {

      using allocator_type = allocator<_Tp>;


      using value_type = _Tp;


      using pointer = _Tp*;


      using const_pointer = const _Tp*;


      using void_pointer = void*;


      using const_void_pointer = const void*;


      using difference_type = std::ptrdiff_t;


      using size_type = std::size_t;


      using propagate_on_container_copy_assignment = false_type;


      using propagate_on_container_move_assignment = true_type;


      using propagate_on_container_swap = false_type;


      using is_always_equal = true_type;

      template<typename _Up>
 using rebind_alloc = allocator<_Up>;

      template<typename _Up>
 using rebind_traits = allocator_traits<allocator<_Up>>;
# 453 "/usr/include/c++/10/bits/alloc_traits.h" 3
      [[__nodiscard__]] static pointer
      allocate(allocator_type& __a, size_type __n)
      { return __a.allocate(__n); }
# 467 "/usr/include/c++/10/bits/alloc_traits.h" 3
      [[__nodiscard__]] static pointer
      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
      {

 return __a.allocate(__n, __hint);



      }
# 485 "/usr/include/c++/10/bits/alloc_traits.h" 3
      static void
      deallocate(allocator_type& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 500 "/usr/include/c++/10/bits/alloc_traits.h" 3
      template<typename _Up, typename... _Args>
 static void
 construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
    _Args&&... __args)
 noexcept(noexcept(::new((void*)__p) _Up(std::declval<_Args>()...)))
 {

   __a.construct(__p, std::forward<_Args>(__args)...);



 }
# 520 "/usr/include/c++/10/bits/alloc_traits.h" 3
      template<typename _Up>
 static void
 destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
 noexcept(is_nothrow_destructible<_Up>::value)
 {

   __a.destroy(__p);



 }






      static size_type
      max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
      {

 return __a.max_size();



      }






      static allocator_type
      select_on_container_copy_construction(const allocator_type& __rhs)
      { return __rhs; }
    };
# 569 "/usr/include/c++/10/bits/alloc_traits.h" 3
  template<typename _Alloc>
    constexpr inline void
    __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
    {
      typedef allocator_traits<_Alloc> __traits;
      typedef typename __traits::propagate_on_container_copy_assignment __pocca;

      if constexpr (__pocca::value)
 __one = __two;



    }

  template<typename _Alloc>
    constexpr _Alloc
    __alloc_on_copy(const _Alloc& __a)
    {
      typedef allocator_traits<_Alloc> __traits;
      return __traits::select_on_container_copy_construction(__a);
    }
# 601 "/usr/include/c++/10/bits/alloc_traits.h" 3
  template<typename _Alloc>
    constexpr inline void
    __alloc_on_move(_Alloc& __one, _Alloc& __two)
    {
      typedef allocator_traits<_Alloc> __traits;
      typedef typename __traits::propagate_on_container_move_assignment __pocma;

      if constexpr (__pocma::value)
 __one = std::move(__two);



    }
# 628 "/usr/include/c++/10/bits/alloc_traits.h" 3
  template<typename _Alloc>
    constexpr inline void
    __alloc_on_swap(_Alloc& __one, _Alloc& __two)
    {
      typedef allocator_traits<_Alloc> __traits;
      typedef typename __traits::propagate_on_container_swap __pocs;

      if constexpr (__pocs::value)
 {
   using std::swap;
   swap(__one, __two);
 }



    }

  template<typename _Alloc, typename _Tp,
    typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
    typename = void>
    struct __is_alloc_insertable_impl
    : false_type
    { };

  template<typename _Alloc, typename _Tp, typename _ValueT>
    struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
      __void_t<decltype(allocator_traits<_Alloc>::construct(
     std::declval<_Alloc&>(), std::declval<_ValueT*>(),
     std::declval<_Tp>()))>>
    : true_type
    { };




  template<typename _Alloc>
    struct __is_copy_insertable
    : __is_alloc_insertable_impl<_Alloc,
     typename _Alloc::value_type const&>::type
    { };


  template<typename _Tp>
    struct __is_copy_insertable<allocator<_Tp>>
    : is_copy_constructible<_Tp>
    { };




  template<typename _Alloc>
    struct __is_move_insertable
    : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
    { };


  template<typename _Tp>
    struct __is_move_insertable<allocator<_Tp>>
    : is_move_constructible<_Tp>
    { };


  template<typename _Alloc, typename = void>
    struct __is_allocator : false_type { };

  template<typename _Alloc>
    struct __is_allocator<_Alloc,
      __void_t<typename _Alloc::value_type,
        decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
    : true_type { };

  template<typename _Alloc>
    using _RequireAllocator
      = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;

  template<typename _Alloc>
    using _RequireNotAllocator
      = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;
# 714 "/usr/include/c++/10/bits/alloc_traits.h" 3
  template<typename _ForwardIterator, typename _Allocator>
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      _Allocator& __alloc)
    {
      for (; __first != __last; ++__first)



 allocator_traits<_Allocator>::destroy(__alloc,
           std::__addressof(*__first));

    }

  template<typename _ForwardIterator, typename _Tp>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      allocator<_Tp>&)
    {
      _Destroy(__first, __last);
    }


}
# 35 "/usr/include/c++/10/ext/alloc_traits.h" 2 3




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






template<typename _Alloc, typename = typename _Alloc::value_type>
  struct __alloc_traits

  : std::allocator_traits<_Alloc>

  {
    typedef _Alloc allocator_type;

    typedef std::allocator_traits<_Alloc> _Base_type;
    typedef typename _Base_type::value_type value_type;
    typedef typename _Base_type::pointer pointer;
    typedef typename _Base_type::const_pointer const_pointer;
    typedef typename _Base_type::size_type size_type;
    typedef typename _Base_type::difference_type difference_type;

    typedef value_type& reference;
    typedef const value_type& const_reference;
    using _Base_type::allocate;
    using _Base_type::deallocate;
    using _Base_type::construct;
    using _Base_type::destroy;
    using _Base_type::max_size;

  private:
    template<typename _Ptr>
      using __is_custom_pointer
 = std::__and_<std::is_same<pointer, _Ptr>,
        std::__not_<std::is_pointer<_Ptr>>>;

  public:

    template<typename _Ptr, typename... _Args>
      static constexpr
      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
      noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p),
           std::forward<_Args>(__args)...)))
      {
 _Base_type::construct(__a, std::__to_address(__p),
         std::forward<_Args>(__args)...);
      }


    template<typename _Ptr>
      static constexpr
      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
      destroy(_Alloc& __a, _Ptr __p)
      noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p))))
      { _Base_type::destroy(__a, std::__to_address(__p)); }

    static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
    { return _Base_type::select_on_container_copy_construction(__a); }

    static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b)
    { std::__alloc_on_swap(__a, __b); }

    static constexpr bool _S_propagate_on_copy_assign()
    { return _Base_type::propagate_on_container_copy_assignment::value; }

    static constexpr bool _S_propagate_on_move_assign()
    { return _Base_type::propagate_on_container_move_assignment::value; }

    static constexpr bool _S_propagate_on_swap()
    { return _Base_type::propagate_on_container_swap::value; }

    static constexpr bool _S_always_equal()
    { return _Base_type::is_always_equal::value; }

    static constexpr bool _S_nothrow_move()
    { return _S_propagate_on_move_assign() || _S_always_equal(); }

    template<typename _Tp>
      struct rebind
      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
# 166 "/usr/include/c++/10/ext/alloc_traits.h" 3
  };


}
# 42 "/usr/include/c++/10/unordered_map" 2 3
# 1 "/usr/include/c++/10/ext/aligned_buffer.h" 1 3
# 32 "/usr/include/c++/10/ext/aligned_buffer.h" 3
       
# 33 "/usr/include/c++/10/ext/aligned_buffer.h" 3







namespace __gnu_cxx
{




  template<typename _Tp>
    struct __aligned_membuf
    {





      struct _Tp2 { _Tp _M_t; };

      alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];

      __aligned_membuf() = default;


      __aligned_membuf(std::nullptr_t) { }

      void*
      _M_addr() noexcept
      { return static_cast<void*>(&_M_storage); }

      const void*
      _M_addr() const noexcept
      { return static_cast<const void*>(&_M_storage); }

      _Tp*
      _M_ptr() noexcept
      { return static_cast<_Tp*>(_M_addr()); }

      const _Tp*
      _M_ptr() const noexcept
      { return static_cast<const _Tp*>(_M_addr()); }
    };
# 89 "/usr/include/c++/10/ext/aligned_buffer.h" 3
  template<typename _Tp>
    struct __aligned_buffer
    : std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>
    {
      typename
 std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>::type _M_storage;

      __aligned_buffer() = default;


      __aligned_buffer(std::nullptr_t) { }

      void*
      _M_addr() noexcept
      {
        return static_cast<void*>(&_M_storage);
      }

      const void*
      _M_addr() const noexcept
      {
        return static_cast<const void*>(&_M_storage);
      }

      _Tp*
      _M_ptr() noexcept
      { return static_cast<_Tp*>(_M_addr()); }

      const _Tp*
      _M_ptr() const noexcept
      { return static_cast<const _Tp*>(_M_addr()); }
    };


}
# 43 "/usr/include/c++/10/unordered_map" 2 3



# 1 "/usr/include/c++/10/bits/hashtable.h" 1 3
# 33 "/usr/include/c++/10/bits/hashtable.h" 3
       
# 34 "/usr/include/c++/10/bits/hashtable.h" 3

# 1 "/usr/include/c++/10/bits/hashtable_policy.h" 1 3
# 39 "/usr/include/c++/10/bits/hashtable_policy.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    class _Hashtable;

namespace __detail
{





  template<typename _Key, typename _Value,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _Traits>
    struct _Hashtable_base;



  template<class _Iterator>
    inline typename std::iterator_traits<_Iterator>::difference_type
    __distance_fw(_Iterator __first, _Iterator __last,
    std::input_iterator_tag)
    { return __first != __last ? 1 : 0; }

  template<class _Iterator>
    inline typename std::iterator_traits<_Iterator>::difference_type
    __distance_fw(_Iterator __first, _Iterator __last,
    std::forward_iterator_tag)
    { return std::distance(__first, __last); }

  template<class _Iterator>
    inline typename std::iterator_traits<_Iterator>::difference_type
    __distance_fw(_Iterator __first, _Iterator __last)
    { return __distance_fw(__first, __last,
      std::__iterator_category(__first)); }

  struct _Identity
  {
    template<typename _Tp>
      _Tp&&
      operator()(_Tp&& __x) const
      { return std::forward<_Tp>(__x); }
  };

  struct _Select1st
  {
    template<typename _Tp>
      auto
      operator()(_Tp&& __x) const
      -> decltype(std::get<0>(std::forward<_Tp>(__x)))
      { return std::get<0>(std::forward<_Tp>(__x)); }
  };

  template<typename _NodeAlloc>
    struct _Hashtable_alloc;



  template<typename _NodeAlloc>
    struct _ReuseOrAllocNode
    {
    private:
      using __node_alloc_type = _NodeAlloc;
      using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
      using __node_alloc_traits =
 typename __hashtable_alloc::__node_alloc_traits;
      using __node_type = typename __hashtable_alloc::__node_type;

    public:
      _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h)
      : _M_nodes(__nodes), _M_h(__h) { }
      _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;

      ~_ReuseOrAllocNode()
      { _M_h._M_deallocate_nodes(_M_nodes); }

      template<typename _Arg>
 __node_type*
 operator()(_Arg&& __arg) const
 {
   if (_M_nodes)
     {
       __node_type* __node = _M_nodes;
       _M_nodes = _M_nodes->_M_next();
       __node->_M_nxt = nullptr;
       auto& __a = _M_h._M_node_allocator();
       __node_alloc_traits::destroy(__a, __node->_M_valptr());
       try
  {
    __node_alloc_traits::construct(__a, __node->_M_valptr(),
       std::forward<_Arg>(__arg));
  }
       catch(...)
  {
    _M_h._M_deallocate_node_ptr(__node);
    throw;
  }
       return __node;
     }
   return _M_h._M_allocate_node(std::forward<_Arg>(__arg));
 }

    private:
      mutable __node_type* _M_nodes;
      __hashtable_alloc& _M_h;
    };



  template<typename _NodeAlloc>
    struct _AllocNode
    {
    private:
      using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;
      using __node_type = typename __hashtable_alloc::__node_type;

    public:
      _AllocNode(__hashtable_alloc& __h)
      : _M_h(__h) { }

      template<typename _Arg>
 __node_type*
 operator()(_Arg&& __arg) const
 { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); }

    private:
      __hashtable_alloc& _M_h;
    };
# 199 "/usr/include/c++/10/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>;
    };
# 215 "/usr/include/c++/10/bits/hashtable_policy.h" 3
  struct _Hash_node_base
  {
    _Hash_node_base* _M_nxt;

    _Hash_node_base() noexcept : _M_nxt() { }

    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
  };






  template<typename _Value>
    struct _Hash_node_value_base : _Hash_node_base
    {
      typedef _Value value_type;

      __gnu_cxx::__aligned_buffer<_Value> _M_storage;

      _Value*
      _M_valptr() noexcept
      { return _M_storage._M_ptr(); }

      const _Value*
      _M_valptr() const noexcept
      { return _M_storage._M_ptr(); }

      _Value&
      _M_v() noexcept
      { return *_M_valptr(); }

      const _Value&
      _M_v() const noexcept
      { return *_M_valptr(); }
    };




  template<typename _Value, bool _Cache_hash_code>
    struct _Hash_node;






  template<typename _Value>
    struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value>
    {
      std::size_t _M_hash_code;

      _Hash_node*
      _M_next() const noexcept
      { return static_cast<_Hash_node*>(this->_M_nxt); }
    };






  template<typename _Value>
    struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
    {
      _Hash_node*
      _M_next() const noexcept
      { return static_cast<_Hash_node*>(this->_M_nxt); }
    };


  template<typename _Value, bool _Cache_hash_code>
    struct _Node_iterator_base
    {
      using __node_type = _Hash_node<_Value, _Cache_hash_code>;

      __node_type* _M_cur;

      _Node_iterator_base(__node_type* __p) noexcept
      : _M_cur(__p) { }

      void
      _M_incr() noexcept
      { _M_cur = _M_cur->_M_next(); }
    };

  template<typename _Value, bool _Cache_hash_code>
    inline bool
    operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
        const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
    noexcept
    { return __x._M_cur == __y._M_cur; }

  template<typename _Value, bool _Cache_hash_code>
    inline bool
    operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
        const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
    noexcept
    { return __x._M_cur != __y._M_cur; }


  template<typename _Value, bool __constant_iterators, bool __cache>
    struct _Node_iterator
    : public _Node_iterator_base<_Value, __cache>
    {
    private:
      using __base_type = _Node_iterator_base<_Value, __cache>;
      using __node_type = typename __base_type::__node_type;

    public:
      typedef _Value value_type;
      typedef std::ptrdiff_t difference_type;
      typedef std::forward_iterator_tag iterator_category;

      using pointer = typename std::conditional<__constant_iterators,
      const _Value*, _Value*>::type;

      using reference = typename std::conditional<__constant_iterators,
        const _Value&, _Value&>::type;

      _Node_iterator() noexcept
      : __base_type(0) { }

      explicit
      _Node_iterator(__node_type* __p) noexcept
      : __base_type(__p) { }

      reference
      operator*() const noexcept
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const noexcept
      { return this->_M_cur->_M_valptr(); }

      _Node_iterator&
      operator++() noexcept
      {
 this->_M_incr();
 return *this;
      }

      _Node_iterator
      operator++(int) noexcept
      {
 _Node_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };


  template<typename _Value, bool __constant_iterators, bool __cache>
    struct _Node_const_iterator
    : public _Node_iterator_base<_Value, __cache>
    {
    private:
      using __base_type = _Node_iterator_base<_Value, __cache>;
      using __node_type = typename __base_type::__node_type;

    public:
      typedef _Value value_type;
      typedef std::ptrdiff_t difference_type;
      typedef std::forward_iterator_tag iterator_category;

      typedef const _Value* pointer;
      typedef const _Value& reference;

      _Node_const_iterator() noexcept
      : __base_type(0) { }

      explicit
      _Node_const_iterator(__node_type* __p) noexcept
      : __base_type(__p) { }

      _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
      __cache>& __x) noexcept
      : __base_type(__x._M_cur) { }

      reference
      operator*() const noexcept
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const noexcept
      { return this->_M_cur->_M_valptr(); }

      _Node_const_iterator&
      operator++() noexcept
      {
 this->_M_incr();
 return *this;
      }

      _Node_const_iterator
      operator++(int) noexcept
      {
 _Node_const_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };






  struct _Mod_range_hashing
  {
    typedef std::size_t first_argument_type;
    typedef std::size_t second_argument_type;
    typedef std::size_t result_type;

    result_type
    operator()(first_argument_type __num,
        second_argument_type __den) const noexcept
    { return __num % __den; }
  };






  struct _Default_ranged_hash { };



  struct _Prime_rehash_policy
  {
    using __has_load_factor = true_type;

    _Prime_rehash_policy(float __z = 1.0) noexcept
    : _M_max_load_factor(__z), _M_next_resize(0) { }

    float
    max_load_factor() const noexcept
    { return _M_max_load_factor; }


    std::size_t
    _M_next_bkt(std::size_t __n) const;


    std::size_t
    _M_bkt_for_elements(std::size_t __n) const
    { return __builtin_ceill(__n / (long double)_M_max_load_factor); }





    std::pair<bool, std::size_t>
    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
     std::size_t __n_ins) const;

    typedef std::size_t _State;

    _State
    _M_state() const
    { return _M_next_resize; }

    void
    _M_reset() noexcept
    { _M_next_resize = 0; }

    void
    _M_reset(_State __state)
    { _M_next_resize = __state; }

    static const std::size_t _S_growth_factor = 2;

    float _M_max_load_factor;
    mutable std::size_t _M_next_resize;
  };


  struct _Mask_range_hashing
  {
    typedef std::size_t first_argument_type;
    typedef std::size_t second_argument_type;
    typedef std::size_t result_type;

    result_type
    operator()(first_argument_type __num,
        second_argument_type __den) const noexcept
    { return __num & (__den - 1); }
  };


  inline std::size_t
  __clp2(std::size_t __n) noexcept
  {

    if (__n < 2)
      return __n;
    const unsigned __lz = sizeof(size_t) > sizeof(long)
      ? __builtin_clzll(__n - 1ull)
      : __builtin_clzl(__n - 1ul);

    return (size_t(1) << (numeric_limits<size_t>::digits - __lz - 1)) << 1;
  }



  struct _Power2_rehash_policy
  {
    using __has_load_factor = true_type;

    _Power2_rehash_policy(float __z = 1.0) noexcept
    : _M_max_load_factor(__z), _M_next_resize(0) { }

    float
    max_load_factor() const noexcept
    { return _M_max_load_factor; }



    std::size_t
    _M_next_bkt(std::size_t __n) noexcept
    {
      if (__n == 0)



 return 1;

      const auto __max_width = std::min<size_t>(sizeof(size_t), 8);
      const auto __max_bkt = size_t(1) << (__max_width * 8 - 1);
      std::size_t __res = __clp2(__n);

      if (__res == 0)
 __res = __max_bkt;
      else if (__res == 1)



 __res = 2;

      if (__res == __max_bkt)



 _M_next_resize = numeric_limits<size_t>::max();
      else
 _M_next_resize
   = __builtin_floorl(__res * (long double)_M_max_load_factor);

      return __res;
    }


    std::size_t
    _M_bkt_for_elements(std::size_t __n) const noexcept
    { return __builtin_ceill(__n / (long double)_M_max_load_factor); }





    std::pair<bool, std::size_t>
    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
     std::size_t __n_ins) noexcept
    {
      if (__n_elt + __n_ins > _M_next_resize)
 {



   long double __min_bkts
     = std::max<std::size_t>(__n_elt + __n_ins, _M_next_resize ? 0 : 11)
       / (long double)_M_max_load_factor;
   if (__min_bkts >= __n_bkt)
     return { true,
       _M_next_bkt(std::max<std::size_t>(__builtin_floorl(__min_bkts) + 1,
      __n_bkt * _S_growth_factor)) };

   _M_next_resize
     = __builtin_floorl(__n_bkt * (long double)_M_max_load_factor);
   return { false, 0 };
 }
      else
 return { false, 0 };
    }

    typedef std::size_t _State;

    _State
    _M_state() const noexcept
    { return _M_next_resize; }

    void
    _M_reset() noexcept
    { _M_next_resize = 0; }

    void
    _M_reset(_State __state) noexcept
    { _M_next_resize = __state; }

    static const std::size_t _S_growth_factor = 2;

    float _M_max_load_factor;
    std::size_t _M_next_resize;
  };
# 641 "/usr/include/c++/10/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits,
    bool _Unique_keys = _Traits::__unique_keys::value>
    struct _Map_base { };


  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
    {
      using mapped_type = typename std::tuple_element<1, _Pair>::type;
    };


  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
    {
    private:
      using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair,
        _Select1st,
       _Equal, _H1, _H2, _Hash,
         _Traits>;

      using __hashtable = _Hashtable<_Key, _Pair, _Alloc,
         _Select1st, _Equal,
         _H1, _H2, _Hash, _RehashPolicy, _Traits>;

      using __hash_code = typename __hashtable_base::__hash_code;
      using __node_type = typename __hashtable_base::__node_type;

    public:
      using key_type = typename __hashtable_base::key_type;
      using iterator = typename __hashtable_base::iterator;
      using mapped_type = typename std::tuple_element<1, _Pair>::type;

      mapped_type&
      operator[](const key_type& __k);

      mapped_type&
      operator[](key_type&& __k);



      mapped_type&
      at(const key_type& __k);

      const mapped_type&
      at(const key_type& __k) const;
    };

  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
    operator[](const key_type& __k)
    -> mapped_type&
    {
      __hashtable* __h = static_cast<__hashtable*>(this);
      __hash_code __code = __h->_M_hash_code(__k);
      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
      if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code))
 return __node->_M_v().second;

      typename __hashtable::_Scoped_node __node {
 __h,
 std::piecewise_construct,
 std::tuple<const key_type&>(__k),
 std::tuple<>()
      };
      auto __pos
 = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node);
      __node._M_node = nullptr;
      return __pos->second;
    }

  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
    operator[](key_type&& __k)
    -> mapped_type&
    {
      __hashtable* __h = static_cast<__hashtable*>(this);
      __hash_code __code = __h->_M_hash_code(__k);
      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
      if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code))
 return __node->_M_v().second;

      typename __hashtable::_Scoped_node __node {
 __h,
 std::piecewise_construct,
 std::forward_as_tuple(std::move(__k)),
 std::tuple<>()
      };
      auto __pos
 = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node);
      __node._M_node = nullptr;
      return __pos->second;
    }

  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
    at(const key_type& __k)
    -> mapped_type&
    {
      __hashtable* __h = static_cast<__hashtable*>(this);
      __hash_code __code = __h->_M_hash_code(__k);
      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
      __node_type* __p = __h->_M_find_node(__bkt, __k, __code);

      if (!__p)
 __throw_out_of_range(("_Map_base::at"));
      return __p->_M_v().second;
    }

  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
    at(const key_type& __k) const
    -> const mapped_type&
    {
      const __hashtable* __h = static_cast<const __hashtable*>(this);
      __hash_code __code = __h->_M_hash_code(__k);
      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
      __node_type* __p = __h->_M_find_node(__bkt, __k, __code);

      if (!__p)
 __throw_out_of_range(("_Map_base::at"));
      return __p->_M_v().second;
    }






  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Insert_base
    {
    protected:
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
         _Equal, _H1, _H2, _Hash,
         _RehashPolicy, _Traits>;

      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
            _Equal, _H1, _H2, _Hash,
            _Traits>;

      using value_type = typename __hashtable_base::value_type;
      using iterator = typename __hashtable_base::iterator;
      using const_iterator = typename __hashtable_base::const_iterator;
      using size_type = typename __hashtable_base::size_type;

      using __unique_keys = typename __hashtable_base::__unique_keys;
      using __ireturn_type = typename __hashtable_base::__ireturn_type;
      using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>;
      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
      using __node_gen_type = _AllocNode<__node_alloc_type>;

      __hashtable&
      _M_conjure_hashtable()
      { return *(static_cast<__hashtable*>(this)); }

      template<typename _InputIterator, typename _NodeGetter>
 void
 _M_insert_range(_InputIterator __first, _InputIterator __last,
   const _NodeGetter&, true_type);

      template<typename _InputIterator, typename _NodeGetter>
 void
 _M_insert_range(_InputIterator __first, _InputIterator __last,
   const _NodeGetter&, false_type);

    public:
      __ireturn_type
      insert(const value_type& __v)
      {
 __hashtable& __h = _M_conjure_hashtable();
 __node_gen_type __node_gen(__h);
 return __h._M_insert(__v, __node_gen, __unique_keys());
      }

      iterator
      insert(const_iterator __hint, const value_type& __v)
      {
 __hashtable& __h = _M_conjure_hashtable();
 __node_gen_type __node_gen(__h);
 return __h._M_insert(__hint, __v, __node_gen, __unique_keys());
      }

      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }

      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 {
   __hashtable& __h = _M_conjure_hashtable();
   __node_gen_type __node_gen(__h);
   return _M_insert_range(__first, __last, __node_gen, __unique_keys());
 }
    };

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator, typename _NodeGetter>
      void
      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
      _RehashPolicy, _Traits>::
      _M_insert_range(_InputIterator __first, _InputIterator __last,
        const _NodeGetter& __node_gen, true_type)
      {
 size_type __n_elt = __detail::__distance_fw(__first, __last);
 if (__n_elt == 0)
   return;

 __hashtable& __h = _M_conjure_hashtable();
 for (; __first != __last; ++__first)
   {
     if (__h._M_insert(*__first, __node_gen, __unique_keys(),
         __n_elt).second)
       __n_elt = 1;
     else if (__n_elt != 1)
       --__n_elt;
   }
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator, typename _NodeGetter>
      void
      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
      _RehashPolicy, _Traits>::
      _M_insert_range(_InputIterator __first, _InputIterator __last,
        const _NodeGetter& __node_gen, false_type)
      {
 using __rehash_type = typename __hashtable::__rehash_type;
 using __rehash_state = typename __hashtable::__rehash_state;
 using pair_type = std::pair<bool, std::size_t>;

 size_type __n_elt = __detail::__distance_fw(__first, __last);
 if (__n_elt == 0)
   return;

 __hashtable& __h = _M_conjure_hashtable();
 __rehash_type& __rehash = __h._M_rehash_policy;
 const __rehash_state& __saved_state = __rehash._M_state();
 pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count,
       __h._M_element_count,
       __n_elt);

 if (__do_rehash.first)
   __h._M_rehash(__do_rehash.second, __saved_state);

 for (; __first != __last; ++__first)
   __h._M_insert(*__first, __node_gen, __unique_keys());
      }







  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits,
    bool _Constant_iterators = _Traits::__constant_iterators::value>
    struct _Insert;


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
     _RehashPolicy, _Traits, true>
    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
      _H1, _H2, _Hash, _RehashPolicy, _Traits>
    {
      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
     _Equal, _H1, _H2, _Hash,
     _RehashPolicy, _Traits>;

      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
            _Equal, _H1, _H2, _Hash,
            _Traits>;

      using value_type = typename __base_type::value_type;
      using iterator = typename __base_type::iterator;
      using const_iterator = typename __base_type::const_iterator;

      using __unique_keys = typename __base_type::__unique_keys;
      using __ireturn_type = typename __hashtable_base::__ireturn_type;
      using __hashtable = typename __base_type::__hashtable;
      using __node_gen_type = typename __base_type::__node_gen_type;

      using __base_type::insert;

      __ireturn_type
      insert(value_type&& __v)
      {
 __hashtable& __h = this->_M_conjure_hashtable();
 __node_gen_type __node_gen(__h);
 return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
      }

      iterator
      insert(const_iterator __hint, value_type&& __v)
      {
 __hashtable& __h = this->_M_conjure_hashtable();
 __node_gen_type __node_gen(__h);
 return __h._M_insert(__hint, std::move(__v), __node_gen,
        __unique_keys());
      }
    };


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
     _RehashPolicy, _Traits, false>
    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
      _H1, _H2, _Hash, _RehashPolicy, _Traits>
    {
      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
           _Equal, _H1, _H2, _Hash,
           _RehashPolicy, _Traits>;
      using value_type = typename __base_type::value_type;
      using iterator = typename __base_type::iterator;
      using const_iterator = typename __base_type::const_iterator;

      using __unique_keys = typename __base_type::__unique_keys;
      using __hashtable = typename __base_type::__hashtable;
      using __ireturn_type = typename __base_type::__ireturn_type;

      using __base_type::insert;

      template<typename _Pair>
 using __is_cons = std::is_constructible<value_type, _Pair&&>;

      template<typename _Pair>
 using _IFcons = std::enable_if<__is_cons<_Pair>::value>;

      template<typename _Pair>
 using _IFconsp = typename _IFcons<_Pair>::type;

      template<typename _Pair, typename = _IFconsp<_Pair>>
 __ireturn_type
 insert(_Pair&& __v)
 {
   __hashtable& __h = this->_M_conjure_hashtable();
   return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v));
 }

      template<typename _Pair, typename = _IFconsp<_Pair>>
 iterator
 insert(const_iterator __hint, _Pair&& __v)
 {
   __hashtable& __h = this->_M_conjure_hashtable();
   return __h._M_emplace(__hint, __unique_keys(),
    std::forward<_Pair>(__v));
 }
   };

  template<typename _Policy>
    using __has_load_factor = typename _Policy::__has_load_factor;







  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits,
    typename =
      __detected_or_t<false_type, __has_load_factor, _RehashPolicy>>
    struct _Rehash_base;


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits,
        false_type>
    {
    };


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits,
   true_type>
    {
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
         _Equal, _H1, _H2, _Hash,
         _RehashPolicy, _Traits>;

      float
      max_load_factor() const noexcept
      {
 const __hashtable* __this = static_cast<const __hashtable*>(this);
 return __this->__rehash_policy().max_load_factor();
      }

      void
      max_load_factor(float __z)
      {
 __hashtable* __this = static_cast<__hashtable*>(this);
 __this->__rehash_policy(_RehashPolicy(__z));
      }

      void
      reserve(std::size_t __n)
      {
 __hashtable* __this = static_cast<__hashtable*>(this);
 __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n));
      }
    };







  template<int _Nm, typename _Tp,
    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
    struct _Hashtable_ebo_helper;


  template<int _Nm, typename _Tp>
    struct _Hashtable_ebo_helper<_Nm, _Tp, true>
    : private _Tp
    {
      _Hashtable_ebo_helper() = default;

      template<typename _OtherTp>
 _Hashtable_ebo_helper(_OtherTp&& __tp)
 : _Tp(std::forward<_OtherTp>(__tp))
 { }

      const _Tp& _M_cget() const { return static_cast<const _Tp&>(*this); }
      _Tp& _M_get() { return static_cast<_Tp&>(*this); }
    };


  template<int _Nm, typename _Tp>
    struct _Hashtable_ebo_helper<_Nm, _Tp, false>
    {
      _Hashtable_ebo_helper() = default;

      template<typename _OtherTp>
 _Hashtable_ebo_helper(_OtherTp&& __tp)
 : _M_tp(std::forward<_OtherTp>(__tp))
 { }

      const _Tp& _M_cget() const { return _M_tp; }
      _Tp& _M_get() { return _M_tp; }

    private:
      _Tp _M_tp;
    };







  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash,
    bool __cache_hash_code>
    struct _Local_iterator_base;
# 1173 "/usr/include/c++/10/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash,
    bool __cache_hash_code>
    struct _Hash_code_base;



  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash>
    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>
    : private _Hashtable_ebo_helper<0, _ExtractKey>,
      private _Hashtable_ebo_helper<1, _Hash>
    {
    private:
      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
      using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;

    protected:
      typedef void* __hash_code;
      typedef _Hash_node<_Value, false> __node_type;



      _Hash_code_base() = default;

      _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&,
        const _Hash& __h)
      : __ebo_extract_key(__ex), __ebo_hash(__h) { }

      __hash_code
      _M_hash_code(const _Key& __key) const
      { return 0; }

      std::size_t
      _M_bucket_index(const _Key& __k, __hash_code,
        std::size_t __bkt_count) const
      { return _M_ranged_hash()(__k, __bkt_count); }

      std::size_t
      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
 noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>(),
         (std::size_t)0)) )
      { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __bkt_count); }

      void
      _M_store_code(__node_type*, __hash_code) const
      { }

      void
      _M_copy_code(__node_type*, const __node_type*) const
      { }

      void
      _M_swap(_Hash_code_base& __x)
      {
 std::swap(__ebo_extract_key::_M_get(),
    __x.__ebo_extract_key::_M_get());
 std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get());
      }

      const _ExtractKey&
      _M_extract() const { return __ebo_extract_key::_M_cget(); }

      const _Hash&
      _M_ranged_hash() const { return __ebo_hash::_M_cget(); }
    };







  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash>
    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>;




  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2>
    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
      _Default_ranged_hash, false>
    : private _Hashtable_ebo_helper<0, _ExtractKey>,
      private _Hashtable_ebo_helper<1, _H1>,
      private _Hashtable_ebo_helper<2, _H2>
    {
    private:
      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;


      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
      _Default_ranged_hash, false>;

    public:
      typedef _H1 hasher;

      hasher
      hash_function() const
      { return _M_h1(); }

    protected:
      typedef std::size_t __hash_code;
      typedef _Hash_node<_Value, false> __node_type;



      _Hash_code_base() = default;

      _Hash_code_base(const _ExtractKey& __ex,
        const _H1& __h1, const _H2& __h2,
        const _Default_ranged_hash&)
      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }

      __hash_code
      _M_hash_code(const _Key& __k) const
      {
 static_assert(__is_invocable<const _H1&, const _Key&>{},
     "hash function must be invocable with an argument of key type");
 return _M_h1()(__k);
      }

      std::size_t
      _M_bucket_index(const _Key&, __hash_code __c,
        std::size_t __bkt_count) const
      { return _M_h2()(__c, __bkt_count); }

      std::size_t
      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
 noexcept( noexcept(declval<const _H1&>()(declval<const _Key&>()))
    && noexcept(declval<const _H2&>()((__hash_code)0,
          (std::size_t)0)) )
      { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __bkt_count); }

      void
      _M_store_code(__node_type*, __hash_code) const
      { }

      void
      _M_copy_code(__node_type*, const __node_type*) const
      { }

      void
      _M_swap(_Hash_code_base& __x)
      {
 std::swap(__ebo_extract_key::_M_get(),
    __x.__ebo_extract_key::_M_get());
 std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get());
 std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get());
      }

      const _ExtractKey&
      _M_extract() const { return __ebo_extract_key::_M_cget(); }

      const _H1&
      _M_h1() const { return __ebo_h1::_M_cget(); }

      const _H2&
      _M_h2() const { return __ebo_h2::_M_cget(); }
    };




  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2>
    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
      _Default_ranged_hash, true>
    : private _Hashtable_ebo_helper<0, _ExtractKey>,
      private _Hashtable_ebo_helper<1, _H1>,
      private _Hashtable_ebo_helper<2, _H2>
    {
    private:

      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
      _Default_ranged_hash, true>;

      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;

    public:
      typedef _H1 hasher;

      hasher
      hash_function() const
      { return _M_h1(); }

    protected:
      typedef std::size_t __hash_code;
      typedef _Hash_node<_Value, true> __node_type;


      _Hash_code_base() = default;
      _Hash_code_base(const _ExtractKey& __ex,
        const _H1& __h1, const _H2& __h2,
        const _Default_ranged_hash&)
      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }

      __hash_code
      _M_hash_code(const _Key& __k) const
      {
 static_assert(__is_invocable<const _H1&, const _Key&>{},
     "hash function must be invocable with an argument of key type");
 return _M_h1()(__k);
      }

      std::size_t
      _M_bucket_index(const _Key&, __hash_code __c,
        std::size_t __bkt_count) const
      { return _M_h2()(__c, __bkt_count); }

      std::size_t
      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
 noexcept( noexcept(declval<const _H2&>()((__hash_code)0,
       (std::size_t)0)) )
      { return _M_h2()(__p->_M_hash_code, __bkt_count); }

      void
      _M_store_code(__node_type* __n, __hash_code __c) const
      { __n->_M_hash_code = __c; }

      void
      _M_copy_code(__node_type* __to, const __node_type* __from) const
      { __to->_M_hash_code = __from->_M_hash_code; }

      void
      _M_swap(_Hash_code_base& __x)
      {
 std::swap(__ebo_extract_key::_M_get(),
    __x.__ebo_extract_key::_M_get());
 std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get());
 std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get());
      }

      const _ExtractKey&
      _M_extract() const { return __ebo_extract_key::_M_cget(); }

      const _H1&
      _M_h1() const { return __ebo_h1::_M_cget(); }

      const _H2&
      _M_h2() const { return __ebo_h2::_M_cget(); }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash>
    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
    _H1, _H2, _Hash, true>
    : private _Hashtable_ebo_helper<0, _H2>
    {
    protected:
      using __base_type = _Hashtable_ebo_helper<0, _H2>;
      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
            _H1, _H2, _Hash, true>;

      _Local_iterator_base() = default;
      _Local_iterator_base(const __hash_code_base& __base,
      _Hash_node<_Value, true>* __p,
      std::size_t __bkt, std::size_t __bkt_count)
      : __base_type(__base._M_h2()),
 _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }

      void
      _M_incr()
      {
 _M_cur = _M_cur->_M_next();
 if (_M_cur)
   {
     std::size_t __bkt
       = __base_type::_M_get()(_M_cur->_M_hash_code,
        _M_bucket_count);
     if (__bkt != _M_bucket)
       _M_cur = nullptr;
   }
      }

      _Hash_node<_Value, true>* _M_cur;
      std::size_t _M_bucket;
      std::size_t _M_bucket_count;

    public:
      const void*
      _M_curr() const { return _M_cur; }

      std::size_t
      _M_get_bucket() const { return _M_bucket; }
    };





  template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value>
    struct _Hash_code_storage
    {
      __gnu_cxx::__aligned_buffer<_Tp> _M_storage;

      _Tp*
      _M_h() { return _M_storage._M_ptr(); }

      const _Tp*
      _M_h() const { return _M_storage._M_ptr(); }
    };


  template<typename _Tp>
    struct _Hash_code_storage<_Tp, true>
    {
      static_assert( std::is_empty<_Tp>::value, "Type must be empty" );



      _Tp*
      _M_h() { return reinterpret_cast<_Tp*>(this); }

      const _Tp*
      _M_h() const { return reinterpret_cast<const _Tp*>(this); }
    };

  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash>
    using __hash_code_for_local_iter
      = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey,
        _H1, _H2, _Hash, false>>;


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash>
    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
    _H1, _H2, _Hash, false>
    : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash>
    {
    protected:
      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
            _H1, _H2, _Hash, false>;

      _Local_iterator_base() : _M_bucket_count(-1) { }

      _Local_iterator_base(const __hash_code_base& __base,
      _Hash_node<_Value, false>* __p,
      std::size_t __bkt, std::size_t __bkt_count)
      : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
      { _M_init(__base); }

      ~_Local_iterator_base()
      {
 if (_M_bucket_count != -1)
   _M_destroy();
      }

      _Local_iterator_base(const _Local_iterator_base& __iter)
      : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket),
        _M_bucket_count(__iter._M_bucket_count)
      {
 if (_M_bucket_count != -1)
   _M_init(*__iter._M_h());
      }

      _Local_iterator_base&
      operator=(const _Local_iterator_base& __iter)
      {
 if (_M_bucket_count != -1)
   _M_destroy();
 _M_cur = __iter._M_cur;
 _M_bucket = __iter._M_bucket;
 _M_bucket_count = __iter._M_bucket_count;
 if (_M_bucket_count != -1)
   _M_init(*__iter._M_h());
 return *this;
      }

      void
      _M_incr()
      {
 _M_cur = _M_cur->_M_next();
 if (_M_cur)
   {
     std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur,
             _M_bucket_count);
     if (__bkt != _M_bucket)
       _M_cur = nullptr;
   }
      }

      _Hash_node<_Value, false>* _M_cur;
      std::size_t _M_bucket;
      std::size_t _M_bucket_count;

      void
      _M_init(const __hash_code_base& __base)
      { ::new(this->_M_h()) __hash_code_base(__base); }

      void
      _M_destroy() { this->_M_h()->~__hash_code_base(); }

    public:
      const void*
      _M_curr() const { return _M_cur; }

      std::size_t
      _M_get_bucket() const { return _M_bucket; }
    };

  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash, bool __cache>
    inline bool
    operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey,
       _H1, _H2, _Hash, __cache>& __x,
        const _Local_iterator_base<_Key, _Value, _ExtractKey,
       _H1, _H2, _Hash, __cache>& __y)
    { return __x._M_curr() == __y._M_curr(); }

  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash, bool __cache>
    inline bool
    operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey,
       _H1, _H2, _Hash, __cache>& __x,
        const _Local_iterator_base<_Key, _Value, _ExtractKey,
       _H1, _H2, _Hash, __cache>& __y)
    { return __x._M_curr() != __y._M_curr(); }


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash,
    bool __constant_iterators, bool __cache>
    struct _Local_iterator
    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
      _H1, _H2, _Hash, __cache>
    {
    private:
      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
            _H1, _H2, _Hash, __cache>;
      using __hash_code_base = typename __base_type::__hash_code_base;
    public:
      typedef _Value value_type;
      typedef typename std::conditional<__constant_iterators,
     const _Value*, _Value*>::type
             pointer;
      typedef typename std::conditional<__constant_iterators,
     const _Value&, _Value&>::type
             reference;
      typedef std::ptrdiff_t difference_type;
      typedef std::forward_iterator_tag iterator_category;

      _Local_iterator() = default;

      _Local_iterator(const __hash_code_base& __base,
        _Hash_node<_Value, __cache>* __n,
        std::size_t __bkt, std::size_t __bkt_count)
      : __base_type(__base, __n, __bkt, __bkt_count)
      { }

      reference
      operator*() const
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const
      { return this->_M_cur->_M_valptr(); }

      _Local_iterator&
      operator++()
      {
 this->_M_incr();
 return *this;
      }

      _Local_iterator
      operator++(int)
      {
 _Local_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _H1, typename _H2, typename _Hash,
    bool __constant_iterators, bool __cache>
    struct _Local_const_iterator
    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
      _H1, _H2, _Hash, __cache>
    {
    private:
      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
            _H1, _H2, _Hash, __cache>;
      using __hash_code_base = typename __base_type::__hash_code_base;

    public:
      typedef _Value value_type;
      typedef const _Value* pointer;
      typedef const _Value& reference;
      typedef std::ptrdiff_t difference_type;
      typedef std::forward_iterator_tag iterator_category;

      _Local_const_iterator() = default;

      _Local_const_iterator(const __hash_code_base& __base,
       _Hash_node<_Value, __cache>* __n,
       std::size_t __bkt, std::size_t __bkt_count)
      : __base_type(__base, __n, __bkt, __bkt_count)
      { }

      _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
        _H1, _H2, _Hash,
        __constant_iterators,
        __cache>& __x)
      : __base_type(__x)
      { }

      reference
      operator*() const
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const
      { return this->_M_cur->_M_valptr(); }

      _Local_const_iterator&
      operator++()
      {
 this->_M_incr();
 return *this;
      }

      _Local_const_iterator
      operator++(int)
      {
 _Local_const_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };
# 1723 "/usr/include/c++/10/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _Traits>
  struct _Hashtable_base
  : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
      _Traits::__hash_cached::value>,
    private _Hashtable_ebo_helper<0, _Equal>
  {
  public:
    typedef _Key key_type;
    typedef _Value value_type;
    typedef _Equal key_equal;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;

    using __traits_type = _Traits;
    using __hash_cached = typename __traits_type::__hash_cached;
    using __constant_iterators = typename __traits_type::__constant_iterators;
    using __unique_keys = typename __traits_type::__unique_keys;

    using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
          _H1, _H2, _Hash,
          __hash_cached::value>;

    using __hash_code = typename __hash_code_base::__hash_code;
    using __node_type = typename __hash_code_base::__node_type;

    using iterator = __detail::_Node_iterator<value_type,
           __constant_iterators::value,
           __hash_cached::value>;

    using const_iterator = __detail::_Node_const_iterator<value_type,
         __constant_iterators::value,
         __hash_cached::value>;

    using local_iterator = __detail::_Local_iterator<key_type, value_type,
        _ExtractKey, _H1, _H2, _Hash,
        __constant_iterators::value,
           __hash_cached::value>;

    using const_local_iterator = __detail::_Local_const_iterator<key_type,
         value_type,
     _ExtractKey, _H1, _H2, _Hash,
     __constant_iterators::value,
     __hash_cached::value>;

    using __ireturn_type = typename std::conditional<__unique_keys::value,
           std::pair<iterator, bool>,
           iterator>::type;
  private:
    using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>;

    template<typename _NodeT>
      struct _Equal_hash_code
      {
       static bool
       _S_equals(__hash_code, const _NodeT&)
       { return true; }
      };

    template<typename _Ptr2>
      struct _Equal_hash_code<_Hash_node<_Ptr2, true>>
      {
       static bool
       _S_equals(__hash_code __c, const _Hash_node<_Ptr2, true>& __n)
       { return __c == __n._M_hash_code; }
      };

  protected:
    _Hashtable_base() = default;
    _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2,
      const _Hash& __hash, const _Equal& __eq)
    : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq)
    { }

    bool
    _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const
    {
      static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
   "key equality predicate must be invocable with two arguments of "
   "key type");
      return _Equal_hash_code<__node_type>::_S_equals(__c, *__n)
 && _M_eq()(__k, this->_M_extract()(__n->_M_v()));
    }

    void
    _M_swap(_Hashtable_base& __x)
    {
      __hash_code_base::_M_swap(__x);
      std::swap(_EqualEBO::_M_get(), __x._EqualEBO::_M_get());
    }

    const _Equal&
    _M_eq() const { return _EqualEBO::_M_cget(); }
  };
# 1827 "/usr/include/c++/10/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits,
    bool _Unique_keys = _Traits::__unique_keys::value>
    struct _Equality;


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
    {
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
         _H1, _H2, _Hash, _RehashPolicy, _Traits>;

      bool
      _M_equal(const __hashtable&) const;
    };

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    bool
    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
    _M_equal(const __hashtable& __other) const
    {
      using __node_base = typename __hashtable::__node_base;
      using __node_type = typename __hashtable::__node_type;
      const __hashtable* __this = static_cast<const __hashtable*>(this);
      if (__this->size() != __other.size())
 return false;

      for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx)
 {
   std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur);
   __node_base* __prev_n = __other._M_buckets[__ybkt];
   if (!__prev_n)
     return false;

   for (__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);;
        __n = __n->_M_next())
     {
       if (__n->_M_v() == *__itx)
  break;

       if (!__n->_M_nxt
    || __other._M_bucket_index(__n->_M_next()) != __ybkt)
  return false;
     }
 }

      return true;
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
    {
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
         _H1, _H2, _Hash, _RehashPolicy, _Traits>;

      bool
      _M_equal(const __hashtable&) const;
    };

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    bool
    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>::
    _M_equal(const __hashtable& __other) const
    {
      using __node_base = typename __hashtable::__node_base;
      using __node_type = typename __hashtable::__node_type;
      const __hashtable* __this = static_cast<const __hashtable*>(this);
      if (__this->size() != __other.size())
 return false;

      for (auto __itx = __this->begin(); __itx != __this->end();)
 {
   std::size_t __x_count = 1;
   auto __itx_end = __itx;
   for (++__itx_end; __itx_end != __this->end()
   && __this->key_eq()(_ExtractKey()(*__itx),
         _ExtractKey()(*__itx_end));
        ++__itx_end)
     ++__x_count;

   std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur);
   __node_base* __y_prev_n = __other._M_buckets[__ybkt];
   if (!__y_prev_n)
     return false;

   __node_type* __y_n = static_cast<__node_type*>(__y_prev_n->_M_nxt);
   for (;; __y_n = __y_n->_M_next())
     {
       if (__this->key_eq()(_ExtractKey()(__y_n->_M_v()),
       _ExtractKey()(*__itx)))
  break;

       if (!__y_n->_M_nxt
    || __other._M_bucket_index(__y_n->_M_next()) != __ybkt)
  return false;
     }

   typename __hashtable::const_iterator __ity(__y_n);
   for (auto __ity_end = __ity; __ity_end != __other.end(); ++__ity_end)
     if (--__x_count == 0)
       break;

   if (__x_count != 0)
     return false;

   if (!std::is_permutation(__itx, __itx_end, __ity))
     return false;

   __itx = __itx_end;
 }
      return true;
    }





  template<typename _NodeAlloc>
    struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc>
    {
    private:
      using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>;
    public:
      using __node_type = typename _NodeAlloc::value_type;
      using __node_alloc_type = _NodeAlloc;

      using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;

      using __value_alloc_traits = typename __node_alloc_traits::template
 rebind_traits<typename __node_type::value_type>;

      using __node_base = __detail::_Hash_node_base;
      using __bucket_type = __node_base*;
      using __bucket_alloc_type =
 __alloc_rebind<__node_alloc_type, __bucket_type>;
      using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>;

      _Hashtable_alloc() = default;
      _Hashtable_alloc(const _Hashtable_alloc&) = default;
      _Hashtable_alloc(_Hashtable_alloc&&) = default;

      template<typename _Alloc>
 _Hashtable_alloc(_Alloc&& __a)
 : __ebo_node_alloc(std::forward<_Alloc>(__a))
 { }

      __node_alloc_type&
      _M_node_allocator()
      { return __ebo_node_alloc::_M_get(); }

      const __node_alloc_type&
      _M_node_allocator() const
      { return __ebo_node_alloc::_M_cget(); }


      template<typename... _Args>
 __node_type*
 _M_allocate_node(_Args&&... __args);


      void
      _M_deallocate_node(__node_type* __n);


      void
      _M_deallocate_node_ptr(__node_type* __n);



      void
      _M_deallocate_nodes(__node_type* __n);

      __bucket_type*
      _M_allocate_buckets(std::size_t __bkt_count);

      void
      _M_deallocate_buckets(__bucket_type*, std::size_t __bkt_count);
    };



  template<typename _NodeAlloc>
    template<typename... _Args>
      auto
      _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
      -> __node_type*
      {
 auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1);
 __node_type* __n = std::__to_address(__nptr);
 try
   {
     ::new ((void*)__n) __node_type;
     __node_alloc_traits::construct(_M_node_allocator(),
        __n->_M_valptr(),
        std::forward<_Args>(__args)...);
     return __n;
   }
 catch(...)
   {
     __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1);
     throw;
   }
      }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n)
    {
      __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr());
      _M_deallocate_node_ptr(__n);
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_type* __n)
    {
      typedef typename __node_alloc_traits::pointer _Ptr;
      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
      __n->~__node_type();
      __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n)
    {
      while (__n)
 {
   __node_type* __tmp = __n;
   __n = __n->_M_next();
   _M_deallocate_node(__tmp);
 }
    }

  template<typename _NodeAlloc>
    typename _Hashtable_alloc<_NodeAlloc>::__bucket_type*
    _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_count)
    {
      __bucket_alloc_type __alloc(_M_node_allocator());

      auto __ptr = __bucket_alloc_traits::allocate(__alloc, __bkt_count);
      __bucket_type* __p = std::__to_address(__ptr);
      __builtin_memset(__p, 0, __bkt_count * sizeof(__bucket_type));
      return __p;
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts,
       std::size_t __bkt_count)
    {
      typedef typename __bucket_alloc_traits::pointer _Ptr;
      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
      __bucket_alloc_type __alloc(_M_node_allocator());
      __bucket_alloc_traits::deallocate(__alloc, __ptr, __bkt_count);
    }


}

}
# 36 "/usr/include/c++/10/bits/hashtable.h" 2 3

# 1 "/usr/include/c++/10/bits/node_handle.h" 1 3
# 34 "/usr/include/c++/10/bits/node_handle.h" 3
       
# 35 "/usr/include/c++/10/bits/node_handle.h" 3




# 1 "/usr/include/c++/10/optional" 1 3
# 32 "/usr/include/c++/10/optional" 3
       
# 33 "/usr/include/c++/10/optional" 3
# 43 "/usr/include/c++/10/optional" 3
# 1 "/usr/include/c++/10/bits/enable_special_members.h" 1 3
# 33 "/usr/include/c++/10/bits/enable_special_members.h" 3
       
# 34 "/usr/include/c++/10/bits/enable_special_members.h" 3

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


  struct _Enable_default_constructor_tag
  {
    explicit constexpr _Enable_default_constructor_tag() = default;
  };






template<bool _Switch, typename _Tag = void>
  struct _Enable_default_constructor
  {
    constexpr _Enable_default_constructor() noexcept = default;
    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
      noexcept = default;
    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
      noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor const&) noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor&&) noexcept = default;


    constexpr explicit
    _Enable_default_constructor(_Enable_default_constructor_tag) { }
  };







template<bool _Switch, typename _Tag = void>
  struct _Enable_destructor { };






template<bool _Copy, bool _CopyAssignment,
         bool _Move, bool _MoveAssignment,
         typename _Tag = void>
  struct _Enable_copy_move { };
# 93 "/usr/include/c++/10/bits/enable_special_members.h" 3
template<bool _Default, bool _Destructor,
         bool _Copy, bool _CopyAssignment,
         bool _Move, bool _MoveAssignment,
         typename _Tag = void>
  struct _Enable_special_members
  : private _Enable_default_constructor<_Default, _Tag>,
    private _Enable_destructor<_Destructor, _Tag>,
    private _Enable_copy_move<_Copy, _CopyAssignment,
                              _Move, _MoveAssignment,
                              _Tag>
  { };



template<typename _Tag>
  struct _Enable_default_constructor<false, _Tag>
  {
    constexpr _Enable_default_constructor() noexcept = delete;
    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
      noexcept = default;
    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
      noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor const&) noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor&&) noexcept = default;


    constexpr explicit
    _Enable_default_constructor(_Enable_default_constructor_tag) { }
  };

template<typename _Tag>
  struct _Enable_destructor<false, _Tag>
  { ~_Enable_destructor() noexcept = delete; };

template<typename _Tag>
  struct _Enable_copy_move<false, true, true, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, true, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, true, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, true, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, true, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, true, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, true, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, true, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, true, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };


}
# 44 "/usr/include/c++/10/optional" 2 3

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

# 56 "/usr/include/c++/10/optional" 3
  template<typename _Tp>
    class optional;


  struct nullopt_t
  {





    enum class _Construct { _Token };


    explicit constexpr nullopt_t(_Construct) { }
  };


  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };






  class bad_optional_access : public exception
  {
  public:
    bad_optional_access() { }

    virtual const char* what() const noexcept override
    { return "bad optional access"; }

    virtual ~bad_optional_access() noexcept = default;
  };

  void
  __throw_bad_optional_access()
  __attribute__((__noreturn__));


  inline void
  __throw_bad_optional_access()
  { (throw (bad_optional_access())); }



  template <typename _Tp>
    struct _Optional_payload_base
    {
      using _Stored_type = remove_const_t<_Tp>;

      _Optional_payload_base() = default;
      ~_Optional_payload_base() = default;

      template<typename... _Args>
 constexpr
 _Optional_payload_base(in_place_t __tag, _Args&&... __args)
 : _M_payload(__tag, std::forward<_Args>(__args)...),
   _M_engaged(true)
 { }

      template<typename _Up, typename... _Args>
 constexpr
 _Optional_payload_base(std::initializer_list<_Up> __il,
          _Args&&... __args)
 : _M_payload(__il, std::forward<_Args>(__args)...),
   _M_engaged(true)
 { }



      constexpr
      _Optional_payload_base(bool __engaged,
        const _Optional_payload_base& __other)
      {
 if (__other._M_engaged)
   this->_M_construct(__other._M_get());
      }



      constexpr
      _Optional_payload_base(bool __engaged,
        _Optional_payload_base&& __other)
      {
 if (__other._M_engaged)
   this->_M_construct(std::move(__other._M_get()));
      }



      _Optional_payload_base(const _Optional_payload_base&) = default;



      _Optional_payload_base(_Optional_payload_base&&) = default;

      _Optional_payload_base&
      operator=(const _Optional_payload_base&) = default;

      _Optional_payload_base&
      operator=(_Optional_payload_base&&) = default;


      constexpr void
      _M_copy_assign(const _Optional_payload_base& __other)
      {
        if (this->_M_engaged && __other._M_engaged)
          this->_M_get() = __other._M_get();
        else
   {
     if (__other._M_engaged)
       this->_M_construct(__other._M_get());
     else
       this->_M_reset();
   }
      }


      constexpr void
      _M_move_assign(_Optional_payload_base&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 if (this->_M_engaged && __other._M_engaged)
   this->_M_get() = std::move(__other._M_get());
 else
   {
     if (__other._M_engaged)
       this->_M_construct(std::move(__other._M_get()));
     else
       this->_M_reset();
   }
      }

      struct _Empty_byte { };

      template<typename _Up, bool = is_trivially_destructible_v<_Up>>
 union _Storage
 {
   constexpr _Storage() noexcept : _M_empty() { }

   template<typename... _Args>
     constexpr
     _Storage(in_place_t, _Args&&... __args)
     : _M_value(std::forward<_Args>(__args)...)
     { }

   template<typename _Vp, typename... _Args>
     constexpr
     _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
     : _M_value(__il, std::forward<_Args>(__args)...)
     { }

   _Empty_byte _M_empty;
          _Up _M_value;
 };

      template<typename _Up>
 union _Storage<_Up, false>
 {
   constexpr _Storage() noexcept : _M_empty() { }

   template<typename... _Args>
     constexpr
     _Storage(in_place_t, _Args&&... __args)
     : _M_value(std::forward<_Args>(__args)...)
     { }

   template<typename _Vp, typename... _Args>
     constexpr
     _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
     : _M_value(__il, std::forward<_Args>(__args)...)
     { }


   ~_Storage() { }

   _Empty_byte _M_empty;
          _Up _M_value;
 };

      _Storage<_Stored_type> _M_payload;

      bool _M_engaged = false;

      template<typename... _Args>
        void
        _M_construct(_Args&&... __args)
        noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
        {
          ::new ((void *) std::__addressof(this->_M_payload))
            _Stored_type(std::forward<_Args>(__args)...);
          this->_M_engaged = true;
        }

      constexpr void
      _M_destroy() noexcept
      {
 _M_engaged = false;
 _M_payload._M_value.~_Stored_type();
      }





      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload._M_value; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload._M_value; }


      constexpr void
      _M_reset() noexcept
      {
 if (this->_M_engaged)
   _M_destroy();
      }
    };


  template <typename _Tp,
     bool =
       is_trivially_destructible_v<_Tp>,
     bool =
       is_trivially_copy_assignable_v<_Tp>
       && is_trivially_copy_constructible_v<_Tp>,
     bool =
       is_trivially_move_assignable_v<_Tp>
       && is_trivially_move_constructible_v<_Tp>>
    struct _Optional_payload;


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, true>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, true>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(_Optional_payload&&) = default;


      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
 this->_M_copy_assign(__other);
 return *this;
      }
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, false>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(const _Optional_payload&) = default;


      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 this->_M_move_assign(std::move(__other));
 return *this;
      }
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, false>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;


      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
 this->_M_copy_assign(__other);
 return *this;
      }


      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 this->_M_move_assign(std::move(__other));
 return *this;
      }
    };


  template <typename _Tp, bool _Copy, bool _Move>
    struct _Optional_payload<_Tp, false, _Copy, _Move>
    : _Optional_payload<_Tp, true, false, false>
    {

      using _Optional_payload<_Tp, true, false, false>::_Optional_payload;
      _Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(const _Optional_payload&) = default;
      _Optional_payload& operator=(_Optional_payload&&) = default;


      ~_Optional_payload() { this->_M_reset(); }
    };



  template<typename _Tp, typename _Dp>
    class _Optional_base_impl
    {
    protected:
      using _Stored_type = remove_const_t<_Tp>;



      template<typename... _Args>
 void
 _M_construct(_Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
 {
   ::new
     (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
     _Stored_type(std::forward<_Args>(__args)...);
   static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
 }

      void
      _M_destruct() noexcept
      { static_cast<_Dp*>(this)->_M_payload._M_destroy(); }


      constexpr void
      _M_reset() noexcept
      { static_cast<_Dp*>(this)->_M_payload._M_reset(); }

      constexpr bool _M_is_engaged() const noexcept
      { return static_cast<const _Dp*>(this)->_M_payload._M_engaged; }


      constexpr _Tp&
      _M_get() noexcept
      {
 do { if (! (this->_M_is_engaged())) std::__replacement_assert("/usr/include/c++/10/optional", 438, __PRETTY_FUNCTION__, "this->_M_is_engaged()"); } while (false);
 return static_cast<_Dp*>(this)->_M_payload._M_get();
      }

      constexpr const _Tp&
      _M_get() const noexcept
      {
 do { if (! (this->_M_is_engaged())) std::__replacement_assert("/usr/include/c++/10/optional", 445, __PRETTY_FUNCTION__, "this->_M_is_engaged()"); } while (false);
 return static_cast<const _Dp*>(this)->_M_payload._M_get();
      }
    };
# 468 "/usr/include/c++/10/optional" 3
  template<typename _Tp,
    bool = is_trivially_copy_constructible_v<_Tp>,
    bool = is_trivially_move_constructible_v<_Tp>>
    struct _Optional_base
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
       std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
       __il, std::forward<_Args>(__args)...)
        { }


      constexpr _Optional_base(const _Optional_base& __other)
 : _M_payload(__other._M_payload._M_engaged,
       __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible_v<_Tp>)
 : _M_payload(__other._M_payload._M_engaged,
       std::move(__other._M_payload))
      { }


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    struct _Optional_base<_Tp, false, true>
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
       std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
       __il, std::forward<_Args>(__args)...)
        { }


      constexpr _Optional_base(const _Optional_base& __other)
 : _M_payload(__other._M_payload._M_engaged,
       __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other) = default;


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    struct _Optional_base<_Tp, true, false>
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
       std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
       __il, std::forward<_Args>(__args)...)
        { }


      constexpr _Optional_base(const _Optional_base& __other) = default;

      constexpr _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible_v<_Tp>)
 : _M_payload(__other._M_payload._M_engaged,
       std::move(__other._M_payload))
      { }


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    struct _Optional_base<_Tp, true, true>
      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
        : _M_payload(in_place,
       std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
               enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args&&...>, bool> = false>
        constexpr explicit _Optional_base(in_place_t,
                                          initializer_list<_Up> __il,
                                          _Args&&... __args)
        : _M_payload(in_place,
       __il, std::forward<_Args>(__args)...)
        { }


      constexpr _Optional_base(const _Optional_base& __other) = default;
      constexpr _Optional_base(_Optional_base&& __other) = default;


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
  class optional;

  template<typename _Tp, typename _Up>
    using __converts_from_optional =
      __or_<is_constructible<_Tp, const optional<_Up>&>,
     is_constructible<_Tp, optional<_Up>&>,
     is_constructible<_Tp, const optional<_Up>&&>,
     is_constructible<_Tp, optional<_Up>&&>,
     is_convertible<const optional<_Up>&, _Tp>,
     is_convertible<optional<_Up>&, _Tp>,
     is_convertible<const optional<_Up>&&, _Tp>,
     is_convertible<optional<_Up>&&, _Tp>>;

  template<typename _Tp, typename _Up>
    using __assigns_from_optional =
      __or_<is_assignable<_Tp&, const optional<_Up>&>,
     is_assignable<_Tp&, optional<_Up>&>,
     is_assignable<_Tp&, const optional<_Up>&&>,
     is_assignable<_Tp&, optional<_Up>&&>>;




  template<typename _Tp>
    class optional
    : private _Optional_base<_Tp>,
      private _Enable_copy_move<

 is_copy_constructible_v<_Tp>,

 __and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,

 is_move_constructible_v<_Tp>,

 __and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,

 optional<_Tp>>
    {
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
      static_assert(!is_reference_v<_Tp>);

    private:
      using _Base = _Optional_base<_Tp>;


      template<typename _Up>
 using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
      template<typename _Up>
 using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
      template<typename... _Cond>
 using _Requires = enable_if_t<__and_v<_Cond...>, bool>;

    public:
      using value_type = _Tp;

      constexpr optional() = default;

      constexpr optional(nullopt_t) noexcept { }


      template<typename _Up = _Tp,
        _Requires<__not_self<_Up>, __not_tag<_Up>,
    is_constructible<_Tp, _Up&&>,
    is_convertible<_Up&&, _Tp>> = true>
 constexpr
 optional(_Up&& __t)
 : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template<typename _Up = _Tp,
        _Requires<__not_self<_Up>, __not_tag<_Up>,
    is_constructible<_Tp, _Up&&>,
    __not_<is_convertible<_Up&&, _Tp>>> = false>
 explicit constexpr
 optional(_Up&& __t)
        : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template<typename _Up,
        _Requires<__not_<is_same<_Tp, _Up>>,
    is_constructible<_Tp, const _Up&>,
    is_convertible<const _Up&, _Tp>,
    __not_<__converts_from_optional<_Tp, _Up>>> = true>
 constexpr
 optional(const optional<_Up>& __t)
 {
   if (__t)
     emplace(*__t);
 }

      template<typename _Up,
        _Requires<__not_<is_same<_Tp, _Up>>,
    is_constructible<_Tp, const _Up&>,
    __not_<is_convertible<const _Up&, _Tp>>,
    __not_<__converts_from_optional<_Tp, _Up>>> = false>
 explicit constexpr
 optional(const optional<_Up>& __t)
 {
   if (__t)
     emplace(*__t);
 }

      template <typename _Up,
  _Requires<__not_<is_same<_Tp, _Up>>,
     is_constructible<_Tp, _Up&&>,
     is_convertible<_Up&&, _Tp>,
     __not_<__converts_from_optional<_Tp, _Up>>> = true>
 constexpr
 optional(optional<_Up>&& __t)
 {
   if (__t)
     emplace(std::move(*__t));
 }

      template <typename _Up,
  _Requires<__not_<is_same<_Tp, _Up>>,
     is_constructible<_Tp, _Up&&>,
     __not_<is_convertible<_Up&&, _Tp>>,
     __not_<__converts_from_optional<_Tp, _Up>>> = false>
 explicit constexpr
 optional(optional<_Up>&& __t)
 {
   if (__t)
     emplace(std::move(*__t));
 }

      template<typename... _Args,
        _Requires<is_constructible<_Tp, _Args&&...>> = false>
 explicit constexpr
 optional(in_place_t, _Args&&... __args)
 : _Base(std::in_place, std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
        _Requires<is_constructible<_Tp,
       initializer_list<_Up>&,
       _Args&&...>> = false>
 explicit constexpr
 optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
 : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }


      optional&
      operator=(nullopt_t) noexcept
      {
 this->_M_reset();
 return *this;
      }

      template<typename _Up = _Tp>
 enable_if_t<__and_v<__not_self<_Up>,
       __not_<__and_<is_scalar<_Tp>,
       is_same<_Tp, decay_t<_Up>>>>,
       is_constructible<_Tp, _Up>,
       is_assignable<_Tp&, _Up>>,
      optional&>
 operator=(_Up&& __u)
 {
   if (this->_M_is_engaged())
     this->_M_get() = std::forward<_Up>(__u);
   else
     this->_M_construct(std::forward<_Up>(__u));

   return *this;
 }

      template<typename _Up>
 enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
       is_constructible<_Tp, const _Up&>,
       is_assignable<_Tp&, _Up>,
       __not_<__converts_from_optional<_Tp, _Up>>,
       __not_<__assigns_from_optional<_Tp, _Up>>>,
      optional&>
 operator=(const optional<_Up>& __u)
 {
   if (__u)
     {
       if (this->_M_is_engaged())
  this->_M_get() = *__u;
       else
  this->_M_construct(*__u);
     }
   else
     {
       this->_M_reset();
     }
   return *this;
 }

      template<typename _Up>
        enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
       is_constructible<_Tp, _Up>,
       is_assignable<_Tp&, _Up>,
       __not_<__converts_from_optional<_Tp, _Up>>,
       __not_<__assigns_from_optional<_Tp, _Up>>>,
      optional&>
 operator=(optional<_Up>&& __u)
 {
   if (__u)
     {
       if (this->_M_is_engaged())
  this->_M_get() = std::move(*__u);
       else
  this->_M_construct(std::move(*__u));
     }
   else
     {
       this->_M_reset();
     }

   return *this;
 }

      template<typename... _Args>
 enable_if_t<is_constructible_v<_Tp, _Args&&...>, _Tp&>
 emplace(_Args&&... __args)
 {
   this->_M_reset();
   this->_M_construct(std::forward<_Args>(__args)...);
   return this->_M_get();
 }

      template<typename _Up, typename... _Args>
 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&,
           _Args&&...>, _Tp&>
 emplace(initializer_list<_Up> __il, _Args&&... __args)
 {
   this->_M_reset();
   this->_M_construct(__il, std::forward<_Args>(__args)...);
   return this->_M_get();
 }




      void
      swap(optional& __other)
      noexcept(is_nothrow_move_constructible_v<_Tp>
        && is_nothrow_swappable_v<_Tp>)
      {
 using std::swap;

 if (this->_M_is_engaged() && __other._M_is_engaged())
   swap(this->_M_get(), __other._M_get());
 else if (this->_M_is_engaged())
   {
     __other._M_construct(std::move(this->_M_get()));
     this->_M_destruct();
   }
 else if (__other._M_is_engaged())
   {
     this->_M_construct(std::move(__other._M_get()));
     __other._M_destruct();
   }
      }


      constexpr const _Tp*
      operator->() const
      { return std::__addressof(this->_M_get()); }

      constexpr _Tp*
      operator->()
      { return std::__addressof(this->_M_get()); }

      constexpr const _Tp&
      operator*() const&
      { return this->_M_get(); }

      constexpr _Tp&
      operator*()&
      { return this->_M_get(); }

      constexpr _Tp&&
      operator*()&&
      { return std::move(this->_M_get()); }

      constexpr const _Tp&&
      operator*() const&&
      { return std::move(this->_M_get()); }

      constexpr explicit operator bool() const noexcept
      { return this->_M_is_engaged(); }

      constexpr bool has_value() const noexcept
      { return this->_M_is_engaged(); }

      constexpr const _Tp&
      value() const&
      {
 return this->_M_is_engaged()
   ? this->_M_get()
   : (__throw_bad_optional_access(), this->_M_get());
      }

      constexpr _Tp&
      value()&
      {
 return this->_M_is_engaged()
   ? this->_M_get()
   : (__throw_bad_optional_access(), this->_M_get());
      }

      constexpr _Tp&&
      value()&&
      {
 return this->_M_is_engaged()
   ? std::move(this->_M_get())
   : (__throw_bad_optional_access(), std::move(this->_M_get()));
      }

      constexpr const _Tp&&
      value() const&&
      {
 return this->_M_is_engaged()
   ? std::move(this->_M_get())
   : (__throw_bad_optional_access(), std::move(this->_M_get()));
      }

      template<typename _Up>
 constexpr _Tp
 value_or(_Up&& __u) const&
 {
   static_assert(is_copy_constructible_v<_Tp>);
   static_assert(is_convertible_v<_Up&&, _Tp>);

   return this->_M_is_engaged()
     ? this->_M_get() : static_cast<_Tp>(std::forward<_Up>(__u));
 }

      template<typename _Up>
 constexpr _Tp
 value_or(_Up&& __u) &&
 {
   static_assert(is_move_constructible_v<_Tp>);
   static_assert(is_convertible_v<_Up&&, _Tp>);

   return this->_M_is_engaged()
     ? std::move(this->_M_get())
     : static_cast<_Tp>(std::forward<_Up>(__u));
 }

      void reset() noexcept { this->_M_reset(); }
    };

  template<typename _Tp>
    using __optional_relop_t =
      enable_if_t<is_convertible<_Tp, bool>::value, bool>;


  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    {
      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
      && (!__lhs || *__lhs == *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    {
      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
 || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    {
      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    {
      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    {
      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    {
      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
    }


  template<typename _Tp>
    constexpr bool
    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }

  template<typename _Tp>
    constexpr bool
    operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator<(const optional<_Tp>& , nullopt_t) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return static_cast<bool>(__rhs); }

  template<typename _Tp>
    constexpr bool
    operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return static_cast<bool>(__lhs); }

  template<typename _Tp>
    constexpr bool
    operator>(nullopt_t, const optional<_Tp>& ) noexcept
    { return false; }

  template<typename _Tp>
    constexpr bool
    operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }

  template<typename _Tp>
    constexpr bool
    operator<=(nullopt_t, const optional<_Tp>& ) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(const optional<_Tp>& , nullopt_t) noexcept
    { return true; }

  template<typename _Tp>
    constexpr bool
    operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
    { return !__rhs; }


  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
    { return __lhs && *__lhs == __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
    { return __rhs && __lhs == *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
    { return !__lhs || *__lhs != __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
    { return !__rhs || __lhs != *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
    { return !__lhs || *__lhs < __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
    { return __rhs && __lhs < *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
    { return __lhs && *__lhs > __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
    { return !__rhs || __lhs > *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
    { return !__lhs || *__lhs <= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
    { return __rhs && __lhs <= *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
    { return __lhs && *__lhs >= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
    { return !__rhs || __lhs >= *__rhs; }





  template<typename _Tp>
    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename _Tp>
    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
    swap(optional<_Tp>&, optional<_Tp>&) = delete;

  template<typename _Tp>
    constexpr optional<decay_t<_Tp>>
    make_optional(_Tp&& __t)
    { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }

  template<typename _Tp, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(_Args&&... __args)
    { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }

  template<typename _Tp, typename _Up, typename ..._Args>
    constexpr optional<_Tp>
    make_optional(initializer_list<_Up> __il, _Args&&... __args)
    { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }



  template<typename _Tp, typename _Up = remove_const_t<_Tp>,
           bool = __poison_hash<_Up>::__enable_hash_call>
    struct __optional_hash_call_base
    {
      size_t
      operator()(const optional<_Tp>& __t) const
      noexcept(noexcept(hash<_Up>{}(*__t)))
      {


        constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
        return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
      }
    };

  template<typename _Tp, typename _Up>
    struct __optional_hash_call_base<_Tp, _Up, false> {};

  template<typename _Tp>
    struct hash<optional<_Tp>>
    : private __poison_hash<remove_const_t<_Tp>>,
      public __optional_hash_call_base<_Tp>
    {
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = optional<_Tp>;
    };

  template<typename _Tp>
    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
    { };




  template <typename _Tp> optional(_Tp) -> optional<_Tp>;



}
# 40 "/usr/include/c++/10/bits/node_handle.h" 2 3



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



  template<typename _Val, typename _NodeAlloc>
    class _Node_handle_common
    {
      using _AllocTraits = allocator_traits<_NodeAlloc>;

    public:
      using allocator_type = __alloc_rebind<_NodeAlloc, _Val>;

      allocator_type
      get_allocator() const noexcept
      {
 do { if (! (!this->empty())) std::__replacement_assert("/usr/include/c++/10/bits/node_handle.h", 59, __PRETTY_FUNCTION__, "!this->empty()"); } while (false);
 return allocator_type(*_M_alloc);
      }

      explicit operator bool() const noexcept { return _M_ptr != nullptr; }

      [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; }

    protected:
      constexpr _Node_handle_common() noexcept : _M_ptr(), _M_alloc() {}

      ~_Node_handle_common() { _M_destroy(); }

      _Node_handle_common(_Node_handle_common&& __nh) noexcept
      : _M_ptr(__nh._M_ptr), _M_alloc(std::move(__nh._M_alloc))
      {
 __nh._M_ptr = nullptr;
 __nh._M_alloc = nullopt;
      }

      _Node_handle_common&
      operator=(_Node_handle_common&& __nh) noexcept
      {
 _M_destroy();
 _M_ptr = __nh._M_ptr;
 if constexpr (is_move_assignable_v<_NodeAlloc>)
   {
     if (_AllocTraits::propagate_on_container_move_assignment::value
  || !this->_M_alloc)
       this->_M_alloc = std::move(__nh._M_alloc);
     else
       {
  do { if (! (this->_M_alloc == __nh._M_alloc)) std::__replacement_assert("/usr/include/c++/10/bits/node_handle.h", 91, __PRETTY_FUNCTION__, "this->_M_alloc == __nh._M_alloc"); } while (false);
       }
   }
 else
   {
     do { if (! (_M_alloc)) std::__replacement_assert("/usr/include/c++/10/bits/node_handle.h", 96, __PRETTY_FUNCTION__, "_M_alloc"); } while (false);
   }
 __nh._M_ptr = nullptr;
 __nh._M_alloc = nullopt;
 return *this;
      }

      _Node_handle_common(typename _AllocTraits::pointer __ptr,
     const _NodeAlloc& __alloc)
      : _M_ptr(__ptr), _M_alloc(__alloc) { }

      void
      _M_swap(_Node_handle_common& __nh) noexcept
      {
 using std::swap;
 swap(_M_ptr, __nh._M_ptr);
 if (_AllocTraits::propagate_on_container_swap::value
     || !_M_alloc || !__nh._M_alloc)
   _M_alloc.swap(__nh._M_alloc);
 else
   {
     do { if (! (_M_alloc == __nh._M_alloc)) std::__replacement_assert("/usr/include/c++/10/bits/node_handle.h", 117, __PRETTY_FUNCTION__, "_M_alloc == __nh._M_alloc"); } while (false);
   }
      }

    private:
      void
      _M_destroy() noexcept
      {
 if (_M_ptr != nullptr)
   {
     allocator_type __alloc(*_M_alloc);
     allocator_traits<allocator_type>::destroy(__alloc,
            _M_ptr->_M_valptr());
     _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1);
   }
      }

    protected:
      typename _AllocTraits::pointer _M_ptr;
    private:
      optional<_NodeAlloc> _M_alloc;

      template<typename _Key2, typename _Value2, typename _KeyOfValue,
        typename _Compare, typename _ValueAlloc>
 friend class _Rb_tree;
    };


  template<typename _Key, typename _Value, typename _NodeAlloc>
    class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc>
    {
    public:
      constexpr _Node_handle() noexcept = default;
      ~_Node_handle() = default;
      _Node_handle(_Node_handle&&) noexcept = default;

      _Node_handle&
      operator=(_Node_handle&&) noexcept = default;

      using key_type = _Key;
      using mapped_type = typename _Value::second_type;

      key_type&
      key() const noexcept
      {
 do { if (! (!this->empty())) std::__replacement_assert("/usr/include/c++/10/bits/node_handle.h", 162, __PRETTY_FUNCTION__, "!this->empty()"); } while (false);
 return *_M_pkey;
      }

      mapped_type&
      mapped() const noexcept
      {
 do { if (! (!this->empty())) std::__replacement_assert("/usr/include/c++/10/bits/node_handle.h", 169, __PRETTY_FUNCTION__, "!this->empty()"); } 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 _H1, typename _H2, typename _Hash,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;
    };


  template<typename _Value, typename _NodeAlloc>
    class _Node_handle<_Value, _Value, _NodeAlloc>
    : public _Node_handle_common<_Value, _NodeAlloc>
    {
    public:
      constexpr _Node_handle() noexcept = default;
      ~_Node_handle() = default;
      _Node_handle(_Node_handle&&) noexcept = default;

      _Node_handle&
      operator=(_Node_handle&&) noexcept = default;

      using value_type = _Value;

      value_type&
      value() const noexcept
      {
 do { if (! (!this->empty())) std::__replacement_assert("/usr/include/c++/10/bits/node_handle.h", 252, __PRETTY_FUNCTION__, "!this->empty()"); } 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 _H1, typename _H2, typename _Hash,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;
    };


  template<typename _Iterator, typename _NodeHandle>
    struct _Node_insert_return
    {
      _Iterator position = _Iterator();
      bool inserted = false;
      _NodeHandle node;
    };


}
# 38 "/usr/include/c++/10/bits/hashtable.h" 2 3


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


  template<typename _Tp, typename _Hash>
    using __cache_default
      = __not_<__and_<
         __is_fast_hash<_Hash>,

         __is_nothrow_invocable<const _Hash&, const _Tp&>>>;
# 169 "/usr/include/c++/10/bits/hashtable.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash,
    typename _RehashPolicy, typename _Traits>
    class _Hashtable
    : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
           _H1, _H2, _Hash, _Traits>,
      public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
      public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
          _H1, _H2, _Hash, _RehashPolicy, _Traits>,
      public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>,
      public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
      private __detail::_Hashtable_alloc<
 __alloc_rebind<_Alloc,
         __detail::_Hash_node<_Value,
         _Traits::__hash_cached::value>>>
    {
      static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value,
   "unordered container must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Value>{},
   "unordered container must have the same value_type as its allocator");


      using __traits_type = _Traits;
      using __hash_cached = typename __traits_type::__hash_cached;
      using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;

      using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;

      using __value_alloc_traits =
 typename __hashtable_alloc::__value_alloc_traits;
      using __node_alloc_traits =
 typename __hashtable_alloc::__node_alloc_traits;
      using __node_base = typename __hashtable_alloc::__node_base;
      using __bucket_type = typename __hashtable_alloc::__bucket_type;

    public:
      typedef _Key key_type;
      typedef _Value value_type;
      typedef _Alloc allocator_type;
      typedef _Equal key_equal;



      typedef typename __value_alloc_traits::pointer pointer;
      typedef typename __value_alloc_traits::const_pointer const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;

    private:
      using __rehash_type = _RehashPolicy;
      using __rehash_state = typename __rehash_type::_State;

      using __constant_iterators = typename __traits_type::__constant_iterators;
      using __unique_keys = typename __traits_type::__unique_keys;

      using __key_extract = typename std::conditional<
          __constant_iterators::value,
                 __detail::_Identity,
          __detail::_Select1st>::type;

      using __hashtable_base = __detail::
          _Hashtable_base<_Key, _Value, _ExtractKey,
           _Equal, _H1, _H2, _Hash, _Traits>;

      using __hash_code_base = typename __hashtable_base::__hash_code_base;
      using __hash_code = typename __hashtable_base::__hash_code;
      using __ireturn_type = typename __hashtable_base::__ireturn_type;

      using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
          _Equal, _H1, _H2, _Hash,
          _RehashPolicy, _Traits>;

      using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
         _ExtractKey, _Equal,
         _H1, _H2, _Hash,
         _RehashPolicy, _Traits>;

      using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey,
         _Equal, _H1, _H2, _Hash,
         _RehashPolicy, _Traits>;

      using __reuse_or_alloc_node_gen_t =
 __detail::_ReuseOrAllocNode<__node_alloc_type>;
      using __alloc_node_gen_t =
 __detail::_AllocNode<__node_alloc_type>;


      struct _Scoped_node
      {

 _Scoped_node(__node_type* __n, __hashtable_alloc* __h)
 : _M_h(__h), _M_node(__n) { }


 template<typename... _Args>
   _Scoped_node(__hashtable_alloc* __h, _Args&&... __args)
   : _M_h(__h),
     _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...))
   { }


 ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); };

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

 __hashtable_alloc* _M_h;
 __node_type* _M_node;
      };

      template<typename _Ht>
 static constexpr
 typename conditional<std::is_lvalue_reference<_Ht>::value,
        const value_type&, value_type&&>::type
 __fwd_value_for(value_type& __val) noexcept
 { return std::move(__val); }


      template<typename _Cond>
 using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>;

      template<typename _Cond>
 using __if_hash_not_cached = __or_<__hash_cached, _Cond>;





      struct __hash_code_base_access : __hash_code_base
      { using __hash_code_base::_M_bucket_index; };



      static_assert(noexcept(declval<const __hash_code_base_access&>()
        ._M_bucket_index((const __node_type*)nullptr,
           (std::size_t)0)),
      "Cache the hash code or qualify your functors involved"
      " in hash code and bucket index computation with noexcept");



      static_assert(__if_hash_cached<is_default_constructible<_H2>>::value,
      "Functor used to map hash code to bucket index"
      " must be default constructible");

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _H1a, typename _H2a, typename _Hasha,
        typename _RehashPolicya, typename _Traitsa,
        bool _Unique_keysa>
 friend struct __detail::_Map_base;

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _H1a, typename _H2a, typename _Hasha,
        typename _RehashPolicya, typename _Traitsa>
 friend struct __detail::_Insert_base;

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _H1a, typename _H2a, typename _Hasha,
        typename _RehashPolicya, typename _Traitsa,
        bool _Constant_iteratorsa>
 friend struct __detail::_Insert;

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _H1a, typename _H2a, typename _Hasha,
        typename _RehashPolicya, typename _Traitsa,
        bool _Unique_keysa>
 friend struct __detail::_Equality;

    public:
      using size_type = typename __hashtable_base::size_type;
      using difference_type = typename __hashtable_base::difference_type;

      using iterator = typename __hashtable_base::iterator;
      using const_iterator = typename __hashtable_base::const_iterator;

      using local_iterator = typename __hashtable_base::local_iterator;
      using const_local_iterator = typename __hashtable_base::
       const_local_iterator;


      using node_type = _Node_handle<_Key, _Value, __node_alloc_type>;
      using insert_return_type = _Node_insert_return<iterator, node_type>;


    private:
      __bucket_type* _M_buckets = &_M_single_bucket;
      size_type _M_bucket_count = 1;
      __node_base _M_before_begin;
      size_type _M_element_count = 0;
      _RehashPolicy _M_rehash_policy;







      __bucket_type _M_single_bucket = nullptr;

      bool
      _M_uses_single_bucket(__bucket_type* __bkts) const
      { return __builtin_expect(__bkts == &_M_single_bucket, false); }

      bool
      _M_uses_single_bucket() const
      { return _M_uses_single_bucket(_M_buckets); }

      __hashtable_alloc&
      _M_base_alloc() { return *this; }

      __bucket_type*
      _M_allocate_buckets(size_type __bkt_count)
      {
 if (__builtin_expect(__bkt_count == 1, false))
   {
     _M_single_bucket = nullptr;
     return &_M_single_bucket;
   }

 return __hashtable_alloc::_M_allocate_buckets(__bkt_count);
      }

      void
      _M_deallocate_buckets(__bucket_type* __bkts, size_type __bkt_count)
      {
 if (_M_uses_single_bucket(__bkts))
   return;

 __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count);
      }

      void
      _M_deallocate_buckets()
      { _M_deallocate_buckets(_M_buckets, _M_bucket_count); }



      __node_type*
      _M_bucket_begin(size_type __bkt) const;

      __node_type*
      _M_begin() const
      { return static_cast<__node_type*>(_M_before_begin._M_nxt); }



      template<typename _Ht>
 void
 _M_assign_elements(_Ht&&);

      template<typename _Ht, typename _NodeGenerator>
 void
 _M_assign(_Ht&&, const _NodeGenerator&);

      void
      _M_move_assign(_Hashtable&&, true_type);

      void
      _M_move_assign(_Hashtable&&, false_type);

      void
      _M_reset() noexcept;

      _Hashtable(const _H1& __h1, const _H2& __h2, const _Hash& __h,
   const _Equal& __eq, const _ExtractKey& __exk,
   const allocator_type& __a)
      : __hashtable_base(__exk, __h1, __h2, __h, __eq),
 __hashtable_alloc(__node_alloc_type(__a))
      { }

    public:

      _Hashtable() = default;
      _Hashtable(size_type __bkt_count_hint,
   const _H1&, const _H2&, const _Hash&,
   const _Equal&, const _ExtractKey&,
   const allocator_type&);

      template<typename _InputIterator>
 _Hashtable(_InputIterator __first, _InputIterator __last,
     size_type __bkt_count_hint,
     const _H1&, const _H2&, const _Hash&,
     const _Equal&, const _ExtractKey&,
     const allocator_type&);

      _Hashtable(const _Hashtable&);

      _Hashtable(_Hashtable&&) noexcept;

      _Hashtable(const _Hashtable&, const allocator_type&);

      _Hashtable(_Hashtable&&, const allocator_type&);


      explicit
      _Hashtable(const allocator_type& __a)
      : __hashtable_alloc(__node_alloc_type(__a))
      { }

      explicit
      _Hashtable(size_type __bkt_count_hint,
   const _H1& __hf = _H1(),
   const key_equal& __eql = key_equal(),
   const allocator_type& __a = allocator_type())
      : _Hashtable(__bkt_count_hint, __hf, _H2(), _Hash(), __eql,
     __key_extract(), __a)
      { }

      template<typename _InputIterator>
 _Hashtable(_InputIterator __f, _InputIterator __l,
     size_type __bkt_count_hint = 0,
     const _H1& __hf = _H1(),
     const key_equal& __eql = key_equal(),
     const allocator_type& __a = allocator_type())
 : _Hashtable(__f, __l, __bkt_count_hint, __hf, _H2(), _Hash(), __eql,
       __key_extract(), __a)
 { }

      _Hashtable(initializer_list<value_type> __l,
   size_type __bkt_count_hint = 0,
   const _H1& __hf = _H1(),
   const key_equal& __eql = key_equal(),
   const allocator_type& __a = allocator_type())
      : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint,
     __hf, _H2(), _Hash(), __eql,
     __key_extract(), __a)
      { }

      _Hashtable&
      operator=(const _Hashtable& __ht);

      _Hashtable&
      operator=(_Hashtable&& __ht)
      noexcept(__node_alloc_traits::_S_nothrow_move()
        && is_nothrow_move_assignable<_H1>::value
        && is_nothrow_move_assignable<_Equal>::value)
      {
        constexpr bool __move_storage =
   __node_alloc_traits::_S_propagate_on_move_assign()
   || __node_alloc_traits::_S_always_equal();
 _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
 return *this;
      }

      _Hashtable&
      operator=(initializer_list<value_type> __l)
      {
 __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
 _M_before_begin._M_nxt = nullptr;
 clear();
 this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys());
 return *this;
      }

      ~_Hashtable() noexcept;

      void
      swap(_Hashtable&)
      noexcept(__and_<__is_nothrow_swappable<_H1>,
                   __is_nothrow_swappable<_Equal>>::value);


      iterator
      begin() noexcept
      { return iterator(_M_begin()); }

      const_iterator
      begin() const noexcept
      { return const_iterator(_M_begin()); }

      iterator
      end() noexcept
      { return iterator(nullptr); }

      const_iterator
      end() const noexcept
      { return const_iterator(nullptr); }

      const_iterator
      cbegin() const noexcept
      { return const_iterator(_M_begin()); }

      const_iterator
      cend() const noexcept
      { return const_iterator(nullptr); }

      size_type
      size() const noexcept
      { return _M_element_count; }

      [[__nodiscard__]] bool
      empty() const noexcept
      { return size() == 0; }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(this->_M_node_allocator()); }

      size_type
      max_size() const noexcept
      { return __node_alloc_traits::max_size(this->_M_node_allocator()); }


      key_equal
      key_eq() const
      { return this->_M_eq(); }




      size_type
      bucket_count() const noexcept
      { return _M_bucket_count; }

      size_type
      max_bucket_count() const noexcept
      { return max_size(); }

      size_type
      bucket_size(size_type __bkt) const
      { return std::distance(begin(__bkt), end(__bkt)); }

      size_type
      bucket(const key_type& __k) const
      { return _M_bucket_index(__k, this->_M_hash_code(__k)); }

      local_iterator
      begin(size_type __bkt)
      {
 return local_iterator(*this, _M_bucket_begin(__bkt),
         __bkt, _M_bucket_count);
      }

      local_iterator
      end(size_type __bkt)
      { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); }

      const_local_iterator
      begin(size_type __bkt) const
      {
 return const_local_iterator(*this, _M_bucket_begin(__bkt),
        __bkt, _M_bucket_count);
      }

      const_local_iterator
      end(size_type __bkt) const
      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }


      const_local_iterator
      cbegin(size_type __bkt) const
      {
 return const_local_iterator(*this, _M_bucket_begin(__bkt),
        __bkt, _M_bucket_count);
      }

      const_local_iterator
      cend(size_type __bkt) const
      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }

      float
      load_factor() const noexcept
      {
 return static_cast<float>(size()) / static_cast<float>(bucket_count());
      }






      const _RehashPolicy&
      __rehash_policy() const
      { return _M_rehash_policy; }

      void
      __rehash_policy(const _RehashPolicy& __pol)
      { _M_rehash_policy = __pol; }


      iterator
      find(const key_type& __k);

      const_iterator
      find(const key_type& __k) const;

      size_type
      count(const key_type& __k) const;

      std::pair<iterator, iterator>
      equal_range(const key_type& __k);

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __k) const;

    protected:

      size_type
      _M_bucket_index(__node_type* __n) const noexcept
      { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }

      size_type
      _M_bucket_index(const key_type& __k, __hash_code __c) const
      { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); }



      __node_base*
      _M_find_before_node(size_type, const key_type&, __hash_code) const;

      __node_type*
      _M_find_node(size_type __bkt, const key_type& __key,
     __hash_code __c) const
      {
 __node_base* __before_n = _M_find_before_node(__bkt, __key, __c);
 if (__before_n)
   return static_cast<__node_type*>(__before_n->_M_nxt);
 return nullptr;
      }


      void
      _M_insert_bucket_begin(size_type, __node_type*);


      void
      _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n,
        size_type __next_bkt);


      __node_base*
      _M_get_previous_node(size_type __bkt, __node_base* __n);




      iterator
      _M_insert_unique_node(const key_type& __k, size_type __bkt,
       __hash_code __code, __node_type* __n,
       size_type __n_elt = 1);



      iterator
      _M_insert_multi_node(__node_type* __hint, const key_type& __k,
      __hash_code __code, __node_type* __n);

      template<typename... _Args>
 std::pair<iterator, bool>
 _M_emplace(true_type, _Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace(false_type __uk, _Args&&... __args)
 { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); }


      template<typename... _Args>
 iterator
 _M_emplace(const_iterator, true_type __uk, _Args&&... __args)
 { return _M_emplace(__uk, std::forward<_Args>(__args)...).first; }

      template<typename... _Args>
 iterator
 _M_emplace(const_iterator, false_type, _Args&&... __args);

      template<typename _Arg, typename _NodeGenerator>
 std::pair<iterator, bool>
 _M_insert(_Arg&&, const _NodeGenerator&, true_type, size_type = 1);

      template<typename _Arg, typename _NodeGenerator>
 iterator
 _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
    false_type __uk)
 {
   return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen,
      __uk);
 }


      template<typename _Arg, typename _NodeGenerator>
 iterator
 _M_insert(const_iterator, _Arg&& __arg,
    const _NodeGenerator& __node_gen, true_type __uk)
 {
   return
     _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first;
 }


      template<typename _Arg, typename _NodeGenerator>
 iterator
 _M_insert(const_iterator, _Arg&&,
    const _NodeGenerator&, false_type);

      size_type
      _M_erase(true_type, const key_type&);

      size_type
      _M_erase(false_type, const key_type&);

      iterator
      _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n);

    public:

      template<typename... _Args>
 __ireturn_type
 emplace(_Args&&... __args)
 { return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); }

      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __hint, _Args&&... __args)
 {
   return _M_emplace(__hint, __unique_keys(),
       std::forward<_Args>(__args)...);
 }




      iterator
      erase(const_iterator);


      iterator
      erase(iterator __it)
      { return erase(const_iterator(__it)); }

      size_type
      erase(const key_type& __k)
      { return _M_erase(__unique_keys(), __k); }

      iterator
      erase(const_iterator, const_iterator);

      void
      clear() noexcept;



      void rehash(size_type __bkt_count);






      insert_return_type
      _M_reinsert_node(node_type&& __nh)
      {
 insert_return_type __ret;
 if (__nh.empty())
   __ret.position = end();
 else
   {
     do { if (! (get_allocator() == __nh.get_allocator())) std::__replacement_assert("/usr/include/c++/10/bits/hashtable.h", 836, __PRETTY_FUNCTION__, "get_allocator() == __nh.get_allocator()"); } while (false);

     const key_type& __k = __nh._M_key();
     __hash_code __code = this->_M_hash_code(__k);
     size_type __bkt = _M_bucket_index(__k, __code);
     if (__node_type* __n = _M_find_node(__bkt, __k, __code))
       {
  __ret.node = std::move(__nh);
  __ret.position = iterator(__n);
  __ret.inserted = false;
       }
     else
       {
  __ret.position
    = _M_insert_unique_node(__k, __bkt, __code, __nh._M_ptr);
  __nh._M_ptr = nullptr;
  __ret.inserted = true;
       }
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh)
      {
 if (__nh.empty())
   return end();

 do { if (! (get_allocator() == __nh.get_allocator())) std::__replacement_assert("/usr/include/c++/10/bits/hashtable.h", 865, __PRETTY_FUNCTION__, "get_allocator() == __nh.get_allocator()"); } 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, __k, __code, __nh._M_ptr);
 __nh._M_ptr = nullptr;
 return __ret;
      }

    private:
      node_type
      _M_extract_node(size_t __bkt, __node_base* __prev_n)
      {
 __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
 if (__prev_n == _M_buckets[__bkt])
   _M_remove_bucket_begin(__bkt, __n->_M_next(),
      __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
 else if (__n->_M_nxt)
   {
     size_type __next_bkt = _M_bucket_index(__n->_M_next());
     if (__next_bkt != __bkt)
       _M_buckets[__next_bkt] = __prev_n;
   }

 __prev_n->_M_nxt = __n->_M_nxt;
 __n->_M_nxt = nullptr;
 --_M_element_count;
 return { __n, this->_M_node_allocator() };
      }

    public:

      node_type
      extract(const_iterator __pos)
      {
 size_t __bkt = _M_bucket_index(__pos._M_cur);
 return _M_extract_node(__bkt,
          _M_get_previous_node(__bkt, __pos._M_cur));
      }


      node_type
      extract(const _Key& __k)
      {
 node_type __nh;
 __hash_code __code = this->_M_hash_code(__k);
 std::size_t __bkt = _M_bucket_index(__k, __code);
 if (__node_base* __prev_node = _M_find_before_node(__bkt, __k, __code))
   __nh = _M_extract_node(__bkt, __prev_node);
 return __nh;
      }


      template<typename _Compatible_Hashtable>
 void
 _M_merge_unique(_Compatible_Hashtable& __src) noexcept
 {
   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
       node_type>, "Node types are compatible");
   do { if (! (get_allocator() == __src.get_allocator())) std::__replacement_assert("/usr/include/c++/10/bits/hashtable.h", 925, __PRETTY_FUNCTION__, "get_allocator() == __src.get_allocator()"); } while (false);

   auto __n_elt = __src.size();
   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
     {
       auto __pos = __i++;
       const key_type& __k = this->_M_extract()(*__pos);
       __hash_code __code = this->_M_hash_code(__k);
       size_type __bkt = _M_bucket_index(__k, __code);
       if (_M_find_node(__bkt, __k, __code) == nullptr)
  {
    auto __nh = __src.extract(__pos);
    _M_insert_unique_node(__k, __bkt, __code, __nh._M_ptr,
     __n_elt);
    __nh._M_ptr = nullptr;
    __n_elt = 1;
  }
       else if (__n_elt != 1)
  --__n_elt;
     }
 }


      template<typename _Compatible_Hashtable>
 void
 _M_merge_multi(_Compatible_Hashtable& __src) noexcept
 {
   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
       node_type>, "Node types are compatible");
   do { if (! (get_allocator() == __src.get_allocator())) std::__replacement_assert("/usr/include/c++/10/bits/hashtable.h", 954, __PRETTY_FUNCTION__, "get_allocator() == __src.get_allocator()"); } while (false);

   this->reserve(size() + __src.size());
   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
     _M_reinsert_node_multi(cend(), __src.extract(__i++));
 }


    private:

      void _M_rehash_aux(size_type __bkt_count, true_type);


      void _M_rehash_aux(size_type __bkt_count, false_type);



      void _M_rehash(size_type __bkt_count, const __rehash_state& __state);
    };



  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_bucket_begin(size_type __bkt) const
    -> __node_type*
    {
      __node_base* __n = _M_buckets[__bkt];
      return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _Hashtable(size_type __bkt_count_hint,
        const _H1& __h1, const _H2& __h2, const _Hash& __h,
        const _Equal& __eq, const _ExtractKey& __exk,
        const allocator_type& __a)
    : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
    {
      auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint);
      if (__bkt_count > _M_bucket_count)
 {
   _M_buckets = _M_allocate_buckets(__bkt_count);
   _M_bucket_count = __bkt_count;
 }
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    template<typename _InputIterator>
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
      _Hashtable(_InputIterator __f, _InputIterator __l,
   size_type __bkt_count_hint,
   const _H1& __h1, const _H2& __h2, const _Hash& __h,
   const _Equal& __eq, const _ExtractKey& __exk,
   const allocator_type& __a)
      : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
      {
 auto __nb_elems = __detail::__distance_fw(__f, __l);
 auto __bkt_count =
   _M_rehash_policy._M_next_bkt(
     std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
       __bkt_count_hint));

 if (__bkt_count > _M_bucket_count)
   {
     _M_buckets = _M_allocate_buckets(__bkt_count);
     _M_bucket_count = __bkt_count;
   }

 for (; __f != __l; ++__f)
   this->insert(*__f);
      }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    operator=(const _Hashtable& __ht)
    -> _Hashtable&
    {
      if (&__ht == this)
 return *this;

      if (__node_alloc_traits::_S_propagate_on_copy_assign())
 {
   auto& __this_alloc = this->_M_node_allocator();
   auto& __that_alloc = __ht._M_node_allocator();
   if (!__node_alloc_traits::_S_always_equal()
       && __this_alloc != __that_alloc)
     {

       this->_M_deallocate_nodes(_M_begin());
       _M_before_begin._M_nxt = nullptr;
       _M_deallocate_buckets();
       _M_buckets = nullptr;
       std::__alloc_on_copy(__this_alloc, __that_alloc);
       __hashtable_base::operator=(__ht);
       _M_bucket_count = __ht._M_bucket_count;
       _M_element_count = __ht._M_element_count;
       _M_rehash_policy = __ht._M_rehash_policy;
       __alloc_node_gen_t __alloc_node_gen(*this);
       try
  {
    _M_assign(__ht, __alloc_node_gen);
  }
       catch(...)
  {


    _M_reset();
    throw;
  }
       return *this;
     }
   std::__alloc_on_copy(__this_alloc, __that_alloc);
 }


      _M_assign_elements(__ht);
      return *this;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    template<typename _Ht>
      void
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
      _M_assign_elements(_Ht&& __ht)
      {
 __bucket_type* __former_buckets = nullptr;
 std::size_t __former_bucket_count = _M_bucket_count;
 const __rehash_state& __former_state = _M_rehash_policy._M_state();

 if (_M_bucket_count != __ht._M_bucket_count)
   {
     __former_buckets = _M_buckets;
     _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
     _M_bucket_count = __ht._M_bucket_count;
   }
 else
   __builtin_memset(_M_buckets, 0,
      _M_bucket_count * sizeof(__bucket_type));

 try
   {
     __hashtable_base::operator=(std::forward<_Ht>(__ht));
     _M_element_count = __ht._M_element_count;
     _M_rehash_policy = __ht._M_rehash_policy;
     __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
     _M_before_begin._M_nxt = nullptr;
     _M_assign(std::forward<_Ht>(__ht), __roan);
     if (__former_buckets)
       _M_deallocate_buckets(__former_buckets, __former_bucket_count);
   }
 catch(...)
   {
     if (__former_buckets)
       {

  _M_deallocate_buckets();
  _M_rehash_policy._M_reset(__former_state);
  _M_buckets = __former_buckets;
  _M_bucket_count = __former_bucket_count;
       }
     __builtin_memset(_M_buckets, 0,
        _M_bucket_count * sizeof(__bucket_type));
     throw;
   }
      }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    template<typename _Ht, typename _NodeGenerator>
      void
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
      _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen)
      {
 __bucket_type* __buckets = nullptr;
 if (!_M_buckets)
   _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count);

 try
   {
     if (!__ht._M_before_begin._M_nxt)
       return;



     __node_type* __ht_n = __ht._M_begin();
     __node_type* __this_n
       = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
     this->_M_copy_code(__this_n, __ht_n);
     _M_before_begin._M_nxt = __this_n;
     _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin;


     __node_base* __prev_n = __this_n;
     for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
       {
  __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
  __prev_n->_M_nxt = __this_n;
  this->_M_copy_code(__this_n, __ht_n);
  size_type __bkt = _M_bucket_index(__this_n);
  if (!_M_buckets[__bkt])
    _M_buckets[__bkt] = __prev_n;
  __prev_n = __this_n;
       }
   }
 catch(...)
   {
     clear();
     if (__buckets)
       _M_deallocate_buckets();
     throw;
   }
      }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_reset() noexcept
    {
      _M_rehash_policy._M_reset();
      _M_bucket_count = 1;
      _M_single_bucket = nullptr;
      _M_buckets = &_M_single_bucket;
      _M_before_begin._M_nxt = nullptr;
      _M_element_count = 0;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_move_assign(_Hashtable&& __ht, true_type)
    {
      this->_M_deallocate_nodes(_M_begin());
      _M_deallocate_buckets();
      __hashtable_base::operator=(std::move(__ht));
      _M_rehash_policy = __ht._M_rehash_policy;
      if (!__ht._M_uses_single_bucket())
 _M_buckets = __ht._M_buckets;
      else
 {
   _M_buckets = &_M_single_bucket;
   _M_single_bucket = __ht._M_single_bucket;
 }
      _M_bucket_count = __ht._M_bucket_count;
      _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
      _M_element_count = __ht._M_element_count;
      std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator());



      if (_M_begin())
 _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
      __ht._M_reset();
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_move_assign(_Hashtable&& __ht, false_type)
    {
      if (__ht._M_node_allocator() == this->_M_node_allocator())
 _M_move_assign(std::move(__ht), true_type());
      else
 {

   _M_assign_elements(std::move(__ht));
   __ht.clear();
 }
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _Hashtable(const _Hashtable& __ht)
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(
 __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),
      _M_buckets(nullptr),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      __alloc_node_gen_t __alloc_node_gen(*this);
      _M_assign(__ht, __alloc_node_gen);
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _Hashtable(_Hashtable&& __ht) noexcept
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(std::move(__ht._M_base_alloc())),
      _M_buckets(__ht._M_buckets),
      _M_bucket_count(__ht._M_bucket_count),
      _M_before_begin(__ht._M_before_begin._M_nxt),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {

      if (__ht._M_uses_single_bucket())
 {
   _M_buckets = &_M_single_bucket;
   _M_single_bucket = __ht._M_single_bucket;
 }



      if (_M_begin())
 _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;

      __ht._M_reset();
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _Hashtable(const _Hashtable& __ht, const allocator_type& __a)
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(__node_alloc_type(__a)),
      _M_buckets(),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      __alloc_node_gen_t __alloc_node_gen(*this);
      _M_assign(__ht, __alloc_node_gen);
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(__node_alloc_type(__a)),
      _M_buckets(nullptr),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      if (__ht._M_node_allocator() == this->_M_node_allocator())
 {
   if (__ht._M_uses_single_bucket())
     {
       _M_buckets = &_M_single_bucket;
       _M_single_bucket = __ht._M_single_bucket;
     }
   else
     _M_buckets = __ht._M_buckets;

   _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;


   if (_M_begin())
     _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
   __ht._M_reset();
 }
      else
 {
   __alloc_node_gen_t __alloc_gen(*this);

   using _Fwd_Ht = typename
     conditional<__move_if_noexcept_cond<value_type>::value,
   const _Hashtable&, _Hashtable&&>::type;
   _M_assign(forward<_Fwd_Ht>(__ht), __alloc_gen);
   __ht.clear();
 }
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    ~_Hashtable() noexcept
    {
      clear();
      _M_deallocate_buckets();
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    swap(_Hashtable& __x)
    noexcept(__and_<__is_nothrow_swappable<_H1>,
                 __is_nothrow_swappable<_Equal>>::value)
    {



      this->_M_swap(__x);

      std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator());
      std::swap(_M_rehash_policy, __x._M_rehash_policy);


      if (this->_M_uses_single_bucket())
 {
   if (!__x._M_uses_single_bucket())
     {
       _M_buckets = __x._M_buckets;
       __x._M_buckets = &__x._M_single_bucket;
     }
 }
      else if (__x._M_uses_single_bucket())
 {
   __x._M_buckets = _M_buckets;
   _M_buckets = &_M_single_bucket;
 }
      else
 std::swap(_M_buckets, __x._M_buckets);

      std::swap(_M_bucket_count, __x._M_bucket_count);
      std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);
      std::swap(_M_element_count, __x._M_element_count);
      std::swap(_M_single_bucket, __x._M_single_bucket);



      if (_M_begin())
 _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;

      if (__x._M_begin())
 __x._M_buckets[__x._M_bucket_index(__x._M_begin())]
   = &__x._M_before_begin;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    find(const key_type& __k)
    -> iterator
    {
      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__k, __code);
      __node_type* __p = _M_find_node(__bkt, __k, __code);
      return __p ? iterator(__p) : end();
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    find(const key_type& __k) const
    -> const_iterator
    {
      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__k, __code);
      __node_type* __p = _M_find_node(__bkt, __k, __code);
      return __p ? const_iterator(__p) : end();
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    count(const key_type& __k) const
    -> size_type
    {
      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__k, __code);
      __node_type* __p = _M_bucket_begin(__bkt);
      if (!__p)
 return 0;

      std::size_t __result = 0;
      for (;; __p = __p->_M_next())
 {
   if (this->_M_equals(__k, __code, __p))
     ++__result;
   else if (__result)



     break;
   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt)
     break;
 }
      return __result;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    equal_range(const key_type& __k)
    -> pair<iterator, iterator>
    {
      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__k, __code);
      __node_type* __p = _M_find_node(__bkt, __k, __code);

      if (__p)
 {
   __node_type* __p1 = __p->_M_next();
   while (__p1 && _M_bucket_index(__p1) == __bkt
   && this->_M_equals(__k, __code, __p1))
     __p1 = __p1->_M_next();

   return std::make_pair(iterator(__p), iterator(__p1));
 }
      else
 return std::make_pair(end(), end());
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    equal_range(const key_type& __k) const
    -> pair<const_iterator, const_iterator>
    {
      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__k, __code);
      __node_type* __p = _M_find_node(__bkt, __k, __code);

      if (__p)
 {
   __node_type* __p1 = __p->_M_next();
   while (__p1 && _M_bucket_index(__p1) == __bkt
   && this->_M_equals(__k, __code, __p1))
     __p1 = __p1->_M_next();

   return std::make_pair(const_iterator(__p), const_iterator(__p1));
 }
      else
 return std::make_pair(end(), end());
    }



  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_find_before_node(size_type __bkt, const key_type& __k,
   __hash_code __code) const
    -> __node_base*
    {
      __node_base* __prev_p = _M_buckets[__bkt];
      if (!__prev_p)
 return nullptr;

      for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);;
    __p = __p->_M_next())
 {
   if (this->_M_equals(__k, __code, __p))
     return __prev_p;

   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt)
     break;
   __prev_p = __p;
 }
      return nullptr;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_insert_bucket_begin(size_type __bkt, __node_type* __node)
    {
      if (_M_buckets[__bkt])
 {


   __node->_M_nxt = _M_buckets[__bkt]->_M_nxt;
   _M_buckets[__bkt]->_M_nxt = __node;
 }
      else
 {



   __node->_M_nxt = _M_before_begin._M_nxt;
   _M_before_begin._M_nxt = __node;
   if (__node->_M_nxt)


     _M_buckets[_M_bucket_index(__node->_M_next())] = __node;
   _M_buckets[__bkt] = &_M_before_begin;
 }
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_remove_bucket_begin(size_type __bkt, __node_type* __next,
      size_type __next_bkt)
    {
      if (!__next || __next_bkt != __bkt)
 {


   if (__next)
     _M_buckets[__next_bkt] = _M_buckets[__bkt];


   if (&_M_before_begin == _M_buckets[__bkt])
     _M_before_begin._M_nxt = __next;
   _M_buckets[__bkt] = nullptr;
 }
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_get_previous_node(size_type __bkt, __node_base* __n)
    -> __node_base*
    {
      __node_base* __prev_n = _M_buckets[__bkt];
      while (__prev_n->_M_nxt != __n)
 __prev_n = __prev_n->_M_nxt;
      return __prev_n;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    template<typename... _Args>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
      _M_emplace(true_type, _Args&&... __args)
      -> pair<iterator, bool>
      {

 _Scoped_node __node { this, std::forward<_Args>(__args)... };
 const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
 __hash_code __code = this->_M_hash_code(__k);
 size_type __bkt = _M_bucket_index(__k, __code);
 if (__node_type* __p = _M_find_node(__bkt, __k, __code))

   return std::make_pair(iterator(__p), false);


 auto __pos = _M_insert_unique_node(__k, __bkt, __code, __node._M_node);
 __node._M_node = nullptr;
 return { __pos, true };
      }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    template<typename... _Args>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
      _M_emplace(const_iterator __hint, false_type, _Args&&... __args)
      -> iterator
      {

 _Scoped_node __node { this, std::forward<_Args>(__args)... };
 const key_type& __k = this->_M_extract()(__node._M_node->_M_v());

 __hash_code __code = this->_M_hash_code(__k);
 auto __pos
   = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node);
 __node._M_node = nullptr;
 return __pos;
      }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_insert_unique_node(const key_type& __k, size_type __bkt,
     __hash_code __code, __node_type* __node,
     size_type __n_elt)
    -> iterator
    {
      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
      std::pair<bool, std::size_t> __do_rehash
 = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,
       __n_elt);

      if (__do_rehash.first)
 {
   _M_rehash(__do_rehash.second, __saved_state);
   __bkt = _M_bucket_index(__k, __code);
 }

      this->_M_store_code(__node, __code);


      _M_insert_bucket_begin(__bkt, __node);
      ++_M_element_count;
      return iterator(__node);
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_insert_multi_node(__node_type* __hint, const key_type& __k,
    __hash_code __code, __node_type* __node)
    -> iterator
    {
      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
      std::pair<bool, std::size_t> __do_rehash
 = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);

      if (__do_rehash.first)
 _M_rehash(__do_rehash.second, __saved_state);

      this->_M_store_code(__node, __code);
      size_type __bkt = _M_bucket_index(__k, __code);



      __node_base* __prev
 = __builtin_expect(__hint != nullptr, false)
   && this->_M_equals(__k, __code, __hint)
     ? __hint
     : _M_find_before_node(__bkt, __k, __code);
      if (__prev)
 {

   __node->_M_nxt = __prev->_M_nxt;
   __prev->_M_nxt = __node;
   if (__builtin_expect(__prev == __hint, false))


     if (__node->_M_nxt
  && !this->_M_equals(__k, __code, __node->_M_next()))
       {
  size_type __next_bkt = _M_bucket_index(__node->_M_next());
  if (__next_bkt != __bkt)
    _M_buckets[__next_bkt] = __node;
       }
 }
      else



 _M_insert_bucket_begin(__bkt, __node);
      ++_M_element_count;
      return iterator(__node);
    }


  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    template<typename _Arg, typename _NodeGenerator>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
      _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, true_type,
  size_type __n_elt)
      -> pair<iterator, bool>
      {
 const key_type& __k = this->_M_extract()(__v);
 __hash_code __code = this->_M_hash_code(__k);
 size_type __bkt = _M_bucket_index(__k, __code);

 if (__node_type* __node = _M_find_node(__bkt, __k, __code))
   return { iterator(__node), false };

 _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };
 auto __pos
   = _M_insert_unique_node(__k, __bkt, __code, __node._M_node, __n_elt);
 __node._M_node = nullptr;
 return { __pos, true };
      }


  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    template<typename _Arg, typename _NodeGenerator>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
      _M_insert(const_iterator __hint, _Arg&& __v,
  const _NodeGenerator& __node_gen, false_type)
      -> iterator
      {


 __hash_code __code = this->_M_hash_code(this->_M_extract()(__v));


 _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };
 const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
 auto __pos
   = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node);
 __node._M_node = nullptr;
 return __pos;
      }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    erase(const_iterator __it)
    -> iterator
    {
      __node_type* __n = __it._M_cur;
      std::size_t __bkt = _M_bucket_index(__n);




      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
      return _M_erase(__bkt, __prev_n, __n);
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n)
    -> iterator
    {
      if (__prev_n == _M_buckets[__bkt])
 _M_remove_bucket_begin(__bkt, __n->_M_next(),
    __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
      else if (__n->_M_nxt)
 {
   size_type __next_bkt = _M_bucket_index(__n->_M_next());
   if (__next_bkt != __bkt)
     _M_buckets[__next_bkt] = __prev_n;
 }

      __prev_n->_M_nxt = __n->_M_nxt;
      iterator __result(__n->_M_next());
      this->_M_deallocate_node(__n);
      --_M_element_count;

      return __result;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_erase(true_type, const key_type& __k)
    -> size_type
    {
      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__k, __code);


      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
      if (!__prev_n)
 return 0;


      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
      _M_erase(__bkt, __prev_n, __n);
      return 1;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_erase(false_type, const key_type& __k)
    -> size_type
    {
      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__k, __code);


      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
      if (!__prev_n)
 return 0;







      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
      __node_type* __n_last = __n;
      std::size_t __n_last_bkt = __bkt;
      do
 {
   __n_last = __n_last->_M_next();
   if (!__n_last)
     break;
   __n_last_bkt = _M_bucket_index(__n_last);
 }
      while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last));


      size_type __result = 0;
      do
 {
   __node_type* __p = __n->_M_next();
   this->_M_deallocate_node(__n);
   __n = __p;
   ++__result;
   --_M_element_count;
 }
      while (__n != __n_last);

      if (__prev_n == _M_buckets[__bkt])
 _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
      else if (__n_last && __n_last_bkt != __bkt)
 _M_buckets[__n_last_bkt] = __prev_n;
      __prev_n->_M_nxt = __n_last;
      return __result;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    erase(const_iterator __first, const_iterator __last)
    -> iterator
    {
      __node_type* __n = __first._M_cur;
      __node_type* __last_n = __last._M_cur;
      if (__n == __last_n)
 return iterator(__n);

      std::size_t __bkt = _M_bucket_index(__n);

      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
      bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);
      std::size_t __n_bkt = __bkt;
      for (;;)
 {
   do
     {
       __node_type* __tmp = __n;
       __n = __n->_M_next();
       this->_M_deallocate_node(__tmp);
       --_M_element_count;
       if (!__n)
  break;
       __n_bkt = _M_bucket_index(__n);
     }
   while (__n != __last_n && __n_bkt == __bkt);
   if (__is_bucket_begin)
     _M_remove_bucket_begin(__bkt, __n, __n_bkt);
   if (__n == __last_n)
     break;
   __is_bucket_begin = true;
   __bkt = __n_bkt;
 }

      if (__n && (__n_bkt != __bkt || __is_bucket_begin))
 _M_buckets[__n_bkt] = __prev_n;
      __prev_n->_M_nxt = __n;
      return iterator(__n);
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    clear() noexcept
    {
      this->_M_deallocate_nodes(_M_begin());
      __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type));
      _M_element_count = 0;
      _M_before_begin._M_nxt = nullptr;
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    rehash(size_type __bkt_count)
    {
      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
      __bkt_count
 = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),
     __bkt_count);
      __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count);

      if (__bkt_count != _M_bucket_count)
 _M_rehash(__bkt_count, __saved_state);
      else


 _M_rehash_policy._M_reset(__saved_state);
    }

  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_rehash(size_type __bkt_count, const __rehash_state& __state)
    {
      try
 {
   _M_rehash_aux(__bkt_count, __unique_keys());
 }
      catch(...)
 {


   _M_rehash_policy._M_reset(__state);
   throw;
 }
    }


  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_rehash_aux(size_type __bkt_count, true_type)
    {
      __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count);
      __node_type* __p = _M_begin();
      _M_before_begin._M_nxt = nullptr;
      std::size_t __bbegin_bkt = 0;
      while (__p)
 {
   __node_type* __next = __p->_M_next();
   std::size_t __bkt
     = __hash_code_base::_M_bucket_index(__p, __bkt_count);
   if (!__new_buckets[__bkt])
     {
       __p->_M_nxt = _M_before_begin._M_nxt;
       _M_before_begin._M_nxt = __p;
       __new_buckets[__bkt] = &_M_before_begin;
       if (__p->_M_nxt)
  __new_buckets[__bbegin_bkt] = __p;
       __bbegin_bkt = __bkt;
     }
   else
     {
       __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
       __new_buckets[__bkt]->_M_nxt = __p;
     }
   __p = __next;
 }

      _M_deallocate_buckets();
      _M_bucket_count = __bkt_count;
      _M_buckets = __new_buckets;
    }



  template<typename _Key, typename _Value,
    typename _Alloc, typename _ExtractKey, typename _Equal,
    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
    typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
    _M_rehash_aux(size_type __bkt_count, false_type)
    {
      __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count);

      __node_type* __p = _M_begin();
      _M_before_begin._M_nxt = nullptr;
      std::size_t __bbegin_bkt = 0;
      std::size_t __prev_bkt = 0;
      __node_type* __prev_p = nullptr;
      bool __check_bucket = false;

      while (__p)
 {
   __node_type* __next = __p->_M_next();
   std::size_t __bkt
     = __hash_code_base::_M_bucket_index(__p, __bkt_count);

   if (__prev_p && __prev_bkt == __bkt)
     {



       __p->_M_nxt = __prev_p->_M_nxt;
       __prev_p->_M_nxt = __p;






       __check_bucket = true;
     }
   else
     {
       if (__check_bucket)
  {


    if (__prev_p->_M_nxt)
      {
        std::size_t __next_bkt
   = __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
           __bkt_count);
        if (__next_bkt != __prev_bkt)
   __new_buckets[__next_bkt] = __prev_p;
      }
    __check_bucket = false;
  }

       if (!__new_buckets[__bkt])
  {
    __p->_M_nxt = _M_before_begin._M_nxt;
    _M_before_begin._M_nxt = __p;
    __new_buckets[__bkt] = &_M_before_begin;
    if (__p->_M_nxt)
      __new_buckets[__bbegin_bkt] = __p;
    __bbegin_bkt = __bkt;
  }
       else
  {
    __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
    __new_buckets[__bkt]->_M_nxt = __p;
  }
     }
   __prev_p = __p;
   __prev_bkt = __bkt;
   __p = __next;
 }

      if (__check_bucket && __prev_p->_M_nxt)
 {
   std::size_t __next_bkt
     = __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
      __bkt_count);
   if (__next_bkt != __prev_bkt)
     __new_buckets[__next_bkt] = __prev_p;
 }

      _M_deallocate_buckets();
      _M_bucket_count = __bkt_count;
      _M_buckets = __new_buckets;
    }


  template<typename, typename, typename> class _Hash_merge_helper { };




  template<typename _Hash>
    using _RequireNotAllocatorOrIntegral
      = __enable_if_t<!__or_<is_integral<_Hash>, __is_allocator<_Hash>>::value>;



}
# 47 "/usr/include/c++/10/unordered_map" 2 3
# 1 "/usr/include/c++/10/bits/unordered_map.h" 1 3
# 33 "/usr/include/c++/10/bits/unordered_map.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template<bool _Cache>
    using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;

  template<typename _Key,
    typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = std::equal_to<_Key>,
    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
    typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
    using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
                                        _Alloc, __detail::_Select1st,
            _Pred, _Hash,
            __detail::_Mod_range_hashing,
            __detail::_Default_ranged_hash,
            __detail::_Prime_rehash_policy, _Tr>;


  template<bool _Cache>
    using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;

  template<typename _Key,
    typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = std::equal_to<_Key>,
    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
    typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
    using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
      _Alloc, __detail::_Select1st,
      _Pred, _Hash,
      __detail::_Mod_range_hashing,
      __detail::_Default_ranged_hash,
      __detail::_Prime_rehash_policy, _Tr>;

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    class unordered_multimap;
# 98 "/usr/include/c++/10/bits/unordered_map.h" 3
  template<typename _Key, typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = equal_to<_Key>,
    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
    class unordered_map
    {
      typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
      _Hashtable _M_h;

    public:



      typedef typename _Hashtable::key_type key_type;
      typedef typename _Hashtable::value_type value_type;
      typedef typename _Hashtable::mapped_type mapped_type;
      typedef typename _Hashtable::hasher hasher;
      typedef typename _Hashtable::key_equal key_equal;
      typedef typename _Hashtable::allocator_type allocator_type;




      typedef typename _Hashtable::pointer pointer;
      typedef typename _Hashtable::const_pointer const_pointer;
      typedef typename _Hashtable::reference reference;
      typedef typename _Hashtable::const_reference const_reference;
      typedef typename _Hashtable::iterator iterator;
      typedef typename _Hashtable::const_iterator const_iterator;
      typedef typename _Hashtable::local_iterator local_iterator;
      typedef typename _Hashtable::const_local_iterator const_local_iterator;
      typedef typename _Hashtable::size_type size_type;
      typedef typename _Hashtable::difference_type difference_type;



      using node_type = typename _Hashtable::node_type;
      using insert_return_type = typename _Hashtable::insert_return_type;





      unordered_map() = default;
# 150 "/usr/include/c++/10/bits/unordered_map.h" 3
      explicit
      unordered_map(size_type __n,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
      : _M_h(__n, __hf, __eql, __a)
      { }
# 171 "/usr/include/c++/10/bits/unordered_map.h" 3
      template<typename _InputIterator>
 unordered_map(_InputIterator __first, _InputIterator __last,
        size_type __n = 0,
        const hasher& __hf = hasher(),
        const key_equal& __eql = key_equal(),
        const allocator_type& __a = allocator_type())
 : _M_h(__first, __last, __n, __hf, __eql, __a)
 { }


      unordered_map(const unordered_map&) = default;


      unordered_map(unordered_map&&) = default;





      explicit
      unordered_map(const allocator_type& __a)
 : _M_h(__a)
      { }






      unordered_map(const unordered_map& __umap,
      const allocator_type& __a)
      : _M_h(__umap._M_h, __a)
      { }






      unordered_map(unordered_map&& __umap,
      const allocator_type& __a)
      : _M_h(std::move(__umap._M_h), __a)
      { }
# 226 "/usr/include/c++/10/bits/unordered_map.h" 3
      unordered_map(initializer_list<value_type> __l,
      size_type __n = 0,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
      : _M_h(__l, __n, __hf, __eql, __a)
      { }

      unordered_map(size_type __n, const allocator_type& __a)
      : unordered_map(__n, hasher(), key_equal(), __a)
      { }

      unordered_map(size_type __n, const hasher& __hf,
      const allocator_type& __a)
      : unordered_map(__n, __hf, key_equal(), __a)
      { }

      template<typename _InputIterator>
 unordered_map(_InputIterator __first, _InputIterator __last,
        size_type __n,
        const allocator_type& __a)
 : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
 { }

      template<typename _InputIterator>
 unordered_map(_InputIterator __first, _InputIterator __last,
        size_type __n, const hasher& __hf,
        const allocator_type& __a)
   : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
 { }

      unordered_map(initializer_list<value_type> __l,
      size_type __n,
      const allocator_type& __a)
      : unordered_map(__l, __n, hasher(), key_equal(), __a)
      { }

      unordered_map(initializer_list<value_type> __l,
      size_type __n, const hasher& __hf,
      const allocator_type& __a)
      : unordered_map(__l, __n, __hf, key_equal(), __a)
      { }


      unordered_map&
      operator=(const unordered_map&) = default;


      unordered_map&
      operator=(unordered_map&&) = default;
# 288 "/usr/include/c++/10/bits/unordered_map.h" 3
      unordered_map&
      operator=(initializer_list<value_type> __l)
      {
 _M_h = __l;
 return *this;
      }


      allocator_type
      get_allocator() const noexcept
      { return _M_h.get_allocator(); }




      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_h.empty(); }


      size_type
      size() const noexcept
      { return _M_h.size(); }


      size_type
      max_size() const noexcept
      { return _M_h.max_size(); }







      iterator
      begin() noexcept
      { return _M_h.begin(); }






      const_iterator
      begin() const noexcept
      { return _M_h.begin(); }

      const_iterator
      cbegin() const noexcept
      { return _M_h.begin(); }






      iterator
      end() noexcept
      { return _M_h.end(); }






      const_iterator
      end() const noexcept
      { return _M_h.end(); }

      const_iterator
      cend() const noexcept
      { return _M_h.end(); }
# 385 "/usr/include/c++/10/bits/unordered_map.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 416 "/usr/include/c++/10/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 (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/unordered_map.h", 426, __PRETTY_FUNCTION__, "__pos != end()"); } 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; }
# 468 "/usr/include/c++/10/bits/unordered_map.h" 3
      template <typename... _Args>
        pair<iterator, bool>
        try_emplace(const key_type& __k, _Args&&... __args)
        {
          iterator __i = find(__k);
          if (__i == end())
            {
              __i = emplace(std::piecewise_construct,
                            std::forward_as_tuple(__k),
                            std::forward_as_tuple(
                              std::forward<_Args>(__args)...))
                .first;
              return {__i, true};
            }
          return {__i, false};
        }


      template <typename... _Args>
        pair<iterator, bool>
        try_emplace(key_type&& __k, _Args&&... __args)
        {
          iterator __i = find(__k);
          if (__i == end())
            {
              __i = emplace(std::piecewise_construct,
                            std::forward_as_tuple(std::move(__k)),
                            std::forward_as_tuple(
                              std::forward<_Args>(__args)...))
                .first;
              return {__i, true};
            }
          return {__i, false};
        }
# 531 "/usr/include/c++/10/bits/unordered_map.h" 3
      template <typename... _Args>
        iterator
        try_emplace(const_iterator __hint, const key_type& __k,
                    _Args&&... __args)
        {
          iterator __i = find(__k);
          if (__i == end())
            __i = emplace_hint(__hint, std::piecewise_construct,
                               std::forward_as_tuple(__k),
                               std::forward_as_tuple(
                                 std::forward<_Args>(__args)...));
          return __i;
        }


      template <typename... _Args>
        iterator
        try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
        {
          iterator __i = find(__k);
          if (__i == end())
            __i = emplace_hint(__hint, std::piecewise_construct,
                               std::forward_as_tuple(std::move(__k)),
                               std::forward_as_tuple(
                                 std::forward<_Args>(__args)...));
          return __i;
        }
# 578 "/usr/include/c++/10/bits/unordered_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_h.insert(__x); }



      std::pair<iterator, bool>
      insert(value_type&& __x)
      { return _M_h.insert(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value,
        pair<iterator, bool>>
 insert(_Pair&& __x)
        { return _M_h.emplace(std::forward<_Pair>(__x)); }
# 617 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __x); }



      iterator
      insert(const_iterator __hint, value_type&& __x)
      { return _M_h.insert(__hint, std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
 insert(const_iterator __hint, _Pair&& __x)
 { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
# 642 "/usr/include/c++/10/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 654 "/usr/include/c++/10/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 681 "/usr/include/c++/10/bits/unordered_map.h" 3
      template <typename _Obj>
        pair<iterator, bool>
        insert_or_assign(const key_type& __k, _Obj&& __obj)
        {
          iterator __i = find(__k);
          if (__i == end())
            {
              __i = emplace(std::piecewise_construct,
                            std::forward_as_tuple(__k),
                            std::forward_as_tuple(std::forward<_Obj>(__obj)))
                .first;
              return {__i, true};
            }
          (*__i).second = std::forward<_Obj>(__obj);
          return {__i, false};
        }


      template <typename _Obj>
        pair<iterator, bool>
        insert_or_assign(key_type&& __k, _Obj&& __obj)
        {
          iterator __i = find(__k);
          if (__i == end())
            {
              __i = emplace(std::piecewise_construct,
                            std::forward_as_tuple(std::move(__k)),
                            std::forward_as_tuple(std::forward<_Obj>(__obj)))
                .first;
              return {__i, true};
            }
          (*__i).second = std::forward<_Obj>(__obj);
          return {__i, false};
        }
# 742 "/usr/include/c++/10/bits/unordered_map.h" 3
      template <typename _Obj>
        iterator
        insert_or_assign(const_iterator __hint, const key_type& __k,
                         _Obj&& __obj)
        {
          iterator __i = find(__k);
          if (__i == end())
            {
              return emplace_hint(__hint, std::piecewise_construct,
                                  std::forward_as_tuple(__k),
                                  std::forward_as_tuple(
                                    std::forward<_Obj>(__obj)));
            }
          (*__i).second = std::forward<_Obj>(__obj);
          return __i;
        }


      template <typename _Obj>
        iterator
        insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
        {
          iterator __i = find(__k);
          if (__i == end())
            {
              return emplace_hint(__hint, std::piecewise_construct,
                                  std::forward_as_tuple(std::move(__k)),
                                  std::forward_as_tuple(
                                    std::forward<_Obj>(__obj)));
            }
          (*__i).second = std::forward<_Obj>(__obj);
          return __i;
        }
# 791 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 813 "/usr/include/c++/10/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 831 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_h.erase(__first, __last); }







      void
      clear() noexcept
      { _M_h.clear(); }
# 855 "/usr/include/c++/10/bits/unordered_map.h" 3
      void
      swap(unordered_map& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }


      template<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(); }
# 919 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }
# 937 "/usr/include/c++/10/bits/unordered_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }
# 961 "/usr/include/c++/10/bits/unordered_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }
# 983 "/usr/include/c++/10/bits/unordered_map.h" 3
      mapped_type&
      operator[](const key_type& __k)
      { return _M_h[__k]; }

      mapped_type&
      operator[](key_type&& __k)
      { return _M_h[std::move(__k)]; }
# 1000 "/usr/include/c++/10/bits/unordered_map.h" 3
      mapped_type&
      at(const key_type& __k)
      { return _M_h.at(__k); }

      const mapped_type&
      at(const key_type& __k) const
      { return _M_h.at(__k); }





      size_type
      bucket_count() const noexcept
      { return _M_h.bucket_count(); }


      size_type
      max_bucket_count() const noexcept
      { return _M_h.max_bucket_count(); }






      size_type
      bucket_size(size_type __n) const
      { return _M_h.bucket_size(__n); }






      size_type
      bucket(const key_type& __key) const
      { return _M_h.bucket(__key); }







      local_iterator
      begin(size_type __n)
      { return _M_h.begin(__n); }
# 1056 "/usr/include/c++/10/bits/unordered_map.h" 3
      const_local_iterator
      begin(size_type __n) const
      { return _M_h.begin(__n); }

      const_local_iterator
      cbegin(size_type __n) const
      { return _M_h.cbegin(__n); }
# 1071 "/usr/include/c++/10/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 1082 "/usr/include/c++/10/bits/unordered_map.h" 3
      const_local_iterator
      end(size_type __n) const
      { return _M_h.end(__n); }

      const_local_iterator
      cend(size_type __n) const
      { return _M_h.cend(__n); }





      float
      load_factor() const noexcept
      { return _M_h.load_factor(); }



      float
      max_load_factor() const noexcept
      { return _M_h.max_load_factor(); }





      void
      max_load_factor(float __z)
      { _M_h.max_load_factor(__z); }
# 1119 "/usr/include/c++/10/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1130 "/usr/include/c++/10/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>;
# 1246 "/usr/include/c++/10/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;
# 1297 "/usr/include/c++/10/bits/unordered_map.h" 3
      explicit
      unordered_multimap(size_type __n,
    const hasher& __hf = hasher(),
    const key_equal& __eql = key_equal(),
    const allocator_type& __a = allocator_type())
      : _M_h(__n, __hf, __eql, __a)
      { }
# 1318 "/usr/include/c++/10/bits/unordered_map.h" 3
      template<typename _InputIterator>
 unordered_multimap(_InputIterator __first, _InputIterator __last,
      size_type __n = 0,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
 : _M_h(__first, __last, __n, __hf, __eql, __a)
 { }


      unordered_multimap(const unordered_multimap&) = default;


      unordered_multimap(unordered_multimap&&) = default;





      explicit
      unordered_multimap(const allocator_type& __a)
      : _M_h(__a)
      { }






      unordered_multimap(const unordered_multimap& __ummap,
    const allocator_type& __a)
      : _M_h(__ummap._M_h, __a)
      { }






      unordered_multimap(unordered_multimap&& __ummap,
    const allocator_type& __a)
      : _M_h(std::move(__ummap._M_h), __a)
      { }
# 1373 "/usr/include/c++/10/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;
# 1435 "/usr/include/c++/10/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(); }
# 1527 "/usr/include/c++/10/bits/unordered_map.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 1554 "/usr/include/c++/10/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)...); }
# 1569 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_h.insert(__x); }

      iterator
      insert(value_type&& __x)
      { return _M_h.insert(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
 insert(_Pair&& __x)
        { return _M_h.emplace(std::forward<_Pair>(__x)); }
# 1603 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __x); }



      iterator
      insert(const_iterator __hint, value_type&& __x)
      { return _M_h.insert(__hint, std::move(__x)); }

      template<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)); }
# 1628 "/usr/include/c++/10/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 1641 "/usr/include/c++/10/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/unordered_map.h", 1650, __PRETTY_FUNCTION__, "__pos != end()"); } 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)); }
# 1684 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 1705 "/usr/include/c++/10/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 1724 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_h.erase(__first, __last); }







      void
      clear() noexcept
      { _M_h.clear(); }
# 1748 "/usr/include/c++/10/bits/unordered_map.h" 3
      void
      swap(unordered_multimap& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }


      template<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(); }
# 1814 "/usr/include/c++/10/bits/unordered_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }







      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }
# 1850 "/usr/include/c++/10/bits/unordered_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }





      size_type
      bucket_count() const noexcept
      { return _M_h.bucket_count(); }


      size_type
      max_bucket_count() const noexcept
      { return _M_h.max_bucket_count(); }






      size_type
      bucket_size(size_type __n) const
      { return _M_h.bucket_size(__n); }






      size_type
      bucket(const key_type& __key) const
      { return _M_h.bucket(__key); }







      local_iterator
      begin(size_type __n)
      { return _M_h.begin(__n); }
# 1906 "/usr/include/c++/10/bits/unordered_map.h" 3
      const_local_iterator
      begin(size_type __n) const
      { return _M_h.begin(__n); }

      const_local_iterator
      cbegin(size_type __n) const
      { return _M_h.cbegin(__n); }
# 1921 "/usr/include/c++/10/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 1932 "/usr/include/c++/10/bits/unordered_map.h" 3
      const_local_iterator
      end(size_type __n) const
      { return _M_h.end(__n); }

      const_local_iterator
      cend(size_type __n) const
      { return _M_h.cend(__n); }





      float
      load_factor() const noexcept
      { return _M_h.load_factor(); }



      float
      max_load_factor() const noexcept
      { return _M_h.max_load_factor(); }





      void
      max_load_factor(float __z)
      { _M_h.max_load_factor(__z); }
# 1969 "/usr/include/c++/10/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1980 "/usr/include/c++/10/bits/unordered_map.h" 3
      void
      reserve(size_type __n)
      { _M_h.reserve(__n); }

      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
        typename _Alloc1>
        friend bool
 operator==(const unordered_multimap<_Key1, _Tp1,
         _Hash1, _Pred1, _Alloc1>&,
     const unordered_multimap<_Key1, _Tp1,
         _Hash1, _Pred1, _Alloc1>&);
    };



  template<typename _InputIterator,
    typename _Hash = hash<__iter_key_t<_InputIterator>>,
    typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator,
         unordered_multimap<int, int>::size_type = {},
         _Hash = _Hash(), _Pred = _Pred(),
         _Allocator = _Allocator())
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>, _Hash, _Pred,
     _Allocator>;

  template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
    typename _Pred = equal_to<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
         unordered_multimap<int, int>::size_type = {},
         _Hash = _Hash(), _Pred = _Pred(),
         _Allocator = _Allocator())
    -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator,
         unordered_multimap<int, int>::size_type, _Allocator)
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>,
     hash<__iter_key_t<_InputIterator>>,
     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator, _Allocator)
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>,
     hash<__iter_key_t<_InputIterator>>,
     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _InputIterator, typename _Hash, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator,
         unordered_multimap<int, int>::size_type, _Hash,
         _Allocator)
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>, _Hash,
     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
         unordered_multimap<int, int>::size_type,
         _Allocator)
    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
         unordered_multimap<int, int>::size_type,
         _Hash, _Allocator)
    -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;



  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline void
    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline void
    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    { return __x._M_h._M_equal(__y._M_h); }

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    { return !(__x == __y); }

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    { return __x._M_h._M_equal(__y._M_h); }

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    { return !(__x == __y); }





  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
    typename _Alloc, typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_map = std::unordered_map<_Tp...>;
      template<typename... _Tp>
 using unordered_multimap = std::unordered_multimap<_Tp...>;

      friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }

      static auto&
      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }
    };


  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
    typename _Alloc, typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_map = std::unordered_map<_Tp...>;
      template<typename... _Tp>
 using unordered_multimap = std::unordered_multimap<_Tp...>;

      friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }

      static auto&
      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }
    };



}
# 48 "/usr/include/c++/10/unordered_map" 2 3

# 1 "/usr/include/c++/10/bits/erase_if.h" 1 3
# 33 "/usr/include/c++/10/bits/erase_if.h" 3
       
# 34 "/usr/include/c++/10/bits/erase_if.h" 3



namespace std
{






  namespace __detail
  {
    template<typename _Container, typename _Predicate>
      typename _Container::size_type
      __erase_nodes_if(_Container& __cont, _Predicate __pred)
      {
 typename _Container::size_type __num = 0;
 for (auto __iter = __cont.begin(), __last = __cont.end();
      __iter != __last;)
   {
     if (__pred(*__iter))
       {
  __iter = __cont.erase(__iter);
  ++__num;
       }
     else
       ++__iter;
   }
 return __num;
      }
  }


}
# 50 "/usr/include/c++/10/unordered_map" 2 3






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

  namespace pmr
  {
    template<typename _Tp> class polymorphic_allocator;
    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_map
 = std::unordered_map<_Key, _Tp, _Hash, _Pred,
        polymorphic_allocator<pair<const _Key, _Tp>>>;
    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_multimap
 = std::unordered_multimap<_Key, _Tp, _Hash, _Pred,
      polymorphic_allocator<pair<const _Key, _Tp>>>;
  }

}
# 62 "/usr/include/c++/10/functional" 2 3
# 1 "/usr/include/c++/10/vector" 1 3
# 58 "/usr/include/c++/10/vector" 3
       
# 59 "/usr/include/c++/10/vector" 3







# 1 "/usr/include/c++/10/bits/stl_uninitialized.h" 1 3
# 69 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{








  template<bool _TrivialValueTypes>
    struct __uninitialized_copy
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        __uninit_copy(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result)
        {
   _ForwardIterator __cur = __result;
   try
     {
       for (; __first != __last; ++__first, (void)++__cur)
  std::_Construct(std::__addressof(*__cur), *__first);
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__result, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_copy<true>
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        __uninit_copy(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result)
        { return std::copy(__first, __last, __result); }
    };
# 123 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_copy(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType1;
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType2;





      static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
   "result type must be constructible from value type of input range");

      typedef typename iterator_traits<_InputIterator>::reference _RefType1;
      typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;


      const bool __assignable = is_assignable<_RefType2, _RefType1>::value;


      return std::__uninitialized_copy<__is_trivial(_ValueType1)
           && __is_trivial(_ValueType2)
           && __assignable>::
 __uninit_copy(__first, __last, __result);
    }



  template<bool _TrivialValueType>
    struct __uninitialized_fill
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
        const _Tp& __x)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __cur != __last; ++__cur)
  std::_Construct(std::__addressof(*__cur), __x);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_fill<true>
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
        const _Tp& __x)
        { std::fill(__first, __last, __x); }
    };
# 198 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
         const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;





      static_assert(is_constructible<_ValueType, const _Tp&>::value,
   "result type must be constructible from input type");



      const bool __assignable = is_copy_assignable<_ValueType>::value;


      std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
 __uninit_fill(__first, __last, __x);
    }



  template<bool _TrivialValueType>
    struct __uninitialized_fill_n
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
        static _ForwardIterator
        __uninit_fill_n(_ForwardIterator __first, _Size __n,
   const _Tp& __x)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __n > 0; --__n, (void) ++__cur)
  std::_Construct(std::__addressof(*__cur), __x);
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_fill_n<true>
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
        static _ForwardIterator
        __uninit_fill_n(_ForwardIterator __first, _Size __n,
   const _Tp& __x)
        { return std::fill_n(__first, __n, __x); }
    };
# 270 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline _ForwardIterator
    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;





      static_assert(is_constructible<_ValueType, const _Tp&>::value,
   "result type must be constructible from input type");



      const bool __assignable = is_copy_assignable<_ValueType>::value;

      return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
 __uninit_fill_n(__first, __n, __x);
    }
# 300 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __result;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __first != __last; ++__first, (void)++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur), *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur, __alloc);
   throw;
 }
    }

  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
    inline _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, allocator<_Tp>&)
    { return std::uninitialized_copy(__first, __last, __result); }

  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a(std::make_move_iterator(__first),
      std::make_move_iterator(__last),
      __result, __alloc);
    }

  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_if_noexcept_a(_InputIterator __first,
           _InputIterator __last,
           _ForwardIterator __result,
           _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a
 (std::__make_move_if_noexcept_iterator(__first),
  std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
    }

  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
    void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __cur != __last; ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur), __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
    inline void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, allocator<_Tp2>&)
    { std::uninitialized_fill(__first, __last, __x); }

  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Allocator>
    _ForwardIterator
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __n > 0; --__n, (void) ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur), __x);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Tp2>
    inline _ForwardIterator
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, allocator<_Tp2>&)
    { return std::uninitialized_fill_n(__first, __n, __x); }
# 414 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_copy_move(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }





  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_copy(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
         const _Tp& __x, _InputIterator __first,
         _InputIterator __last, _Allocator& __alloc)
    {
      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
      try
 {
   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
    typename _Allocator>
    inline void
    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
         _ForwardIterator __first2,
         _ForwardIterator __last2, const _Tp& __x,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
           __first2,
           __alloc);
      try
 {
   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__first2, __mid2, __alloc);
   throw;
 }
    }
# 521 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template<bool _TrivialValueType>
    struct __uninitialized_default_1
    {
      template<typename _ForwardIterator>
        static void
        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __cur != __last; ++__cur)
  std::_Construct(std::__addressof(*__cur));
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_1<true>
    {
      template<typename _ForwardIterator>
        static void
        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
        {
   typedef typename iterator_traits<_ForwardIterator>::value_type
     _ValueType;

   std::fill(__first, __last, _ValueType());
 }
    };

  template<bool _TrivialValueType>
    struct __uninitialized_default_n_1
    {
      template<typename _ForwardIterator, typename _Size>
        static _ForwardIterator
        __uninit_default_n(_ForwardIterator __first, _Size __n)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __n > 0; --__n, (void) ++__cur)
  std::_Construct(std::__addressof(*__cur));
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_n_1<true>
    {
      template<typename _ForwardIterator, typename _Size>
        static _ForwardIterator
        __uninit_default_n(_ForwardIterator __first, _Size __n)
        {
   typedef typename iterator_traits<_ForwardIterator>::value_type
     _ValueType;

   return std::fill_n(__first, __n, _ValueType());
 }
    };




  template<typename _ForwardIterator>
    inline void
    __uninitialized_default(_ForwardIterator __first,
       _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      const bool __assignable = is_copy_assignable<_ValueType>::value;

      std::__uninitialized_default_1<__is_trivial(_ValueType)
         && __assignable>::
 __uninit_default(__first, __last);
    }



  template<typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      const bool __assignable = is_copy_assignable<_ValueType>::value;

      return __uninitialized_default_n_1<__is_trivial(_ValueType)
           && __assignable>::
 __uninit_default_n(__first, __n);
    }





  template<typename _ForwardIterator, typename _Allocator>
    void
    __uninitialized_default_a(_ForwardIterator __first,
         _ForwardIterator __last,
         _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __cur != __last; ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur));
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Tp>
    inline void
    __uninitialized_default_a(_ForwardIterator __first,
         _ForwardIterator __last,
         allocator<_Tp>&)
    { std::__uninitialized_default(__first, __last); }





  template<typename _ForwardIterator, typename _Size, typename _Allocator>
    _ForwardIterator
    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
    _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __n > 0; --__n, (void) ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur));
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline _ForwardIterator
    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
    allocator<_Tp>&)
    { return std::__uninitialized_default_n(__first, __n); }

  template<bool _TrivialValueType>
    struct __uninitialized_default_novalue_1
    {
      template<typename _ForwardIterator>
 static void
 __uninit_default_novalue(_ForwardIterator __first,
     _ForwardIterator __last)
 {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __cur != __last; ++__cur)
  std::_Construct_novalue(std::__addressof(*__cur));
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_novalue_1<true>
    {
      template<typename _ForwardIterator>
        static void
        __uninit_default_novalue(_ForwardIterator __first,
     _ForwardIterator __last)
 {
 }
    };

  template<bool _TrivialValueType>
    struct __uninitialized_default_novalue_n_1
    {
      template<typename _ForwardIterator, typename _Size>
 static _ForwardIterator
 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
 {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __n > 0; --__n, (void) ++__cur)
  std::_Construct_novalue(std::__addressof(*__cur));
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_novalue_n_1<true>
    {
      template<typename _ForwardIterator, typename _Size>
 static _ForwardIterator
 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
 { return std::next(__first, __n); }
    };




  template<typename _ForwardIterator>
    inline void
    __uninitialized_default_novalue(_ForwardIterator __first,
        _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      std::__uninitialized_default_novalue_1<
 is_trivially_default_constructible<_ValueType>::value>::
 __uninit_default_novalue(__first, __last);
    }



  template<typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      return __uninitialized_default_novalue_n_1<
 is_trivially_default_constructible<_ValueType>::value>::
 __uninit_default_novalue_n(__first, __n);
    }

  template<typename _InputIterator, typename _Size,
    typename _ForwardIterator>
    _ForwardIterator
    __uninitialized_copy_n(_InputIterator __first, _Size __n,
      _ForwardIterator __result, input_iterator_tag)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __n > 0; --__n, (void) ++__first, ++__cur)
     std::_Construct(std::__addressof(*__cur), *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur);
   throw;
 }
    }

  template<typename _RandomAccessIterator, typename _Size,
    typename _ForwardIterator>
    inline _ForwardIterator
    __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
      _ForwardIterator __result,
      random_access_iterator_tag)
    { return std::uninitialized_copy(__first, __first + __n, __result); }

  template<typename _InputIterator, typename _Size,
    typename _ForwardIterator>
    pair<_InputIterator, _ForwardIterator>
    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
      _ForwardIterator __result, input_iterator_tag)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __n > 0; --__n, (void) ++__first, ++__cur)
     std::_Construct(std::__addressof(*__cur), *__first);
   return {__first, __cur};
 }
      catch(...)
 {
   std::_Destroy(__result, __cur);
   throw;
 }
    }

  template<typename _RandomAccessIterator, typename _Size,
    typename _ForwardIterator>
    inline pair<_RandomAccessIterator, _ForwardIterator>
    __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,
      _ForwardIterator __result,
      random_access_iterator_tag)
    {
      auto __second_res = uninitialized_copy(__first, __first + __n, __result);
      auto __first_res = std::next(__first, __n);
      return {__first_res, __second_res};
    }
# 852 "/usr/include/c++/10/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));
    }
# 880 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template <typename _ForwardIterator>
    inline void
    uninitialized_default_construct(_ForwardIterator __first,
        _ForwardIterator __last)
    {
      __uninitialized_default_novalue(__first, __last);
    }







  template <typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
    {
      return __uninitialized_default_novalue_n(__first, __count);
    }






  template <typename _ForwardIterator>
    inline void
    uninitialized_value_construct(_ForwardIterator __first,
      _ForwardIterator __last)
    {
      return __uninitialized_default(__first, __last);
    }







  template <typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
    {
      return __uninitialized_default_n(__first, __count);
    }
# 934 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template <typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_move(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      return std::uninitialized_copy
 (std::make_move_iterator(__first),
  std::make_move_iterator(__last), __result);
    }
# 951 "/usr/include/c++/10/bits/stl_uninitialized.h" 3
  template <typename _InputIterator, typename _Size, typename _ForwardIterator>
    inline pair<_InputIterator, _ForwardIterator>
    uninitialized_move_n(_InputIterator __first, _Size __count,
    _ForwardIterator __result)
    {
      auto __res = std::__uninitialized_copy_n_pair
 (std::make_move_iterator(__first),
  __count, __result);
      return {__res.first.base(), __res.second};
    }





  template<typename _Tp, typename _Up, typename _Allocator>
    inline void
    __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
   _Allocator& __alloc)
    noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
    __dest, std::move(*__orig)))
      && noexcept(std::allocator_traits<_Allocator>::destroy(
       __alloc, std::__addressof(*__orig))))
    {
      typedef std::allocator_traits<_Allocator> __traits;
      __traits::construct(__alloc, __dest, std::move(*__orig));
      __traits::destroy(__alloc, std::__addressof(*__orig));
    }



  template<typename _Tp, typename = void>
    struct __is_bitwise_relocatable
    : is_trivial<_Tp> { };

  template <typename _Tp, typename _Up>
    inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
    __relocate_a_1(_Tp* __first, _Tp* __last,
     _Tp* __result, allocator<_Up>&) noexcept
    {
      ptrdiff_t __count = __last - __first;
      if (__count > 0)
 __builtin_memmove(__result, __first, __count * sizeof(_Tp));
      return __result + __count;
    }

  template <typename _InputIterator, typename _ForwardIterator,
     typename _Allocator>
    inline _ForwardIterator
    __relocate_a_1(_InputIterator __first, _InputIterator __last,
     _ForwardIterator __result, _Allocator& __alloc)
    noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
            std::addressof(*__first),
            __alloc)))
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType2;
      static_assert(std::is_same<_ValueType, _ValueType2>::value,
   "relocation is only possible for values of the same type");
      _ForwardIterator __cur = __result;
      for (; __first != __last; ++__first, (void)++__cur)
 std::__relocate_object_a(std::__addressof(*__cur),
     std::__addressof(*__first), __alloc);
      return __cur;
    }

  template <typename _InputIterator, typename _ForwardIterator,
     typename _Allocator>
    inline _ForwardIterator
    __relocate_a(_InputIterator __first, _InputIterator __last,
   _ForwardIterator __result, _Allocator& __alloc)
    noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
         std::__niter_base(__last),
         std::__niter_base(__result), __alloc)))
    {
      return __relocate_a_1(std::__niter_base(__first),
       std::__niter_base(__last),
       std::__niter_base(__result), __alloc);
    }







}
# 67 "/usr/include/c++/10/vector" 2 3
# 1 "/usr/include/c++/10/bits/stl_vector.h" 1 3
# 74 "/usr/include/c++/10/bits/stl_vector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Tp>::other _Tp_alloc_type;
      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
        pointer;

      struct _Vector_impl_data
      {
 pointer _M_start;
 pointer _M_finish;
 pointer _M_end_of_storage;

 _Vector_impl_data() noexcept
 : _M_start(), _M_finish(), _M_end_of_storage()
 { }


 _Vector_impl_data(_Vector_impl_data&& __x) noexcept
 : _M_start(__x._M_start), _M_finish(__x._M_finish),
   _M_end_of_storage(__x._M_end_of_storage)
 { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); }


 void
 _M_copy_data(_Vector_impl_data const& __x) noexcept
 {
   _M_start = __x._M_start;
   _M_finish = __x._M_finish;
   _M_end_of_storage = __x._M_end_of_storage;
 }

 void
 _M_swap_data(_Vector_impl_data& __x) noexcept
 {


   _Vector_impl_data __tmp;
   __tmp._M_copy_data(*this);
   _M_copy_data(__x);
   __x._M_copy_data(__tmp);
 }
      };

      struct _Vector_impl
 : public _Tp_alloc_type, public _Vector_impl_data
      {
 _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value)

 : _Tp_alloc_type()
 { }

 _Vector_impl(_Tp_alloc_type const& __a) noexcept
 : _Tp_alloc_type(__a)
 { }




 _Vector_impl(_Vector_impl&& __x) noexcept
 : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x))
 { }

 _Vector_impl(_Tp_alloc_type&& __a) noexcept
 : _Tp_alloc_type(std::move(__a))
 { }

 _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept
 : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv))
 { }
# 267 "/usr/include/c++/10/bits/stl_vector.h" 3
      };

    public:
      typedef _Alloc allocator_type;

      _Tp_alloc_type&
      _M_get_Tp_allocator() noexcept
      { return this->_M_impl; }

      const _Tp_alloc_type&
      _M_get_Tp_allocator() const noexcept
      { return this->_M_impl; }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Tp_allocator()); }


      _Vector_base() = default;




      _Vector_base(const allocator_type& __a) noexcept
      : _M_impl(__a) { }



      _Vector_base(size_t __n)
      : _M_impl()
      { _M_create_storage(__n); }


      _Vector_base(size_t __n, const allocator_type& __a)
      : _M_impl(__a)
      { _M_create_storage(__n); }


      _Vector_base(_Vector_base&&) = default;



      _Vector_base(_Tp_alloc_type&& __a) noexcept
      : _M_impl(std::move(__a)) { }

      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
      : _M_impl(__a)
      {
 if (__x.get_allocator() == __a)
   this->_M_impl._M_swap_data(__x._M_impl);
 else
   {
     size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
     _M_create_storage(__n);
   }
      }


      _Vector_base(const allocator_type& __a, _Vector_base&& __x)
      : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl))
      { }


      ~_Vector_base() noexcept
      {
 _M_deallocate(_M_impl._M_start,
        _M_impl._M_end_of_storage - _M_impl._M_start);
      }

    public:
      _Vector_impl _M_impl;

      pointer
      _M_allocate(size_t __n)
      {
 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
 return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
      }

      void
      _M_deallocate(pointer __p, size_t __n)
      {
 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
 if (__p)
   _Tr::deallocate(_M_impl, __p, __n);
      }

    protected:
      void
      _M_create_storage(size_t __n)
      {
 this->_M_impl._M_start = this->_M_allocate(__n);
 this->_M_impl._M_finish = this->_M_impl._M_start;
 this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
      }
    };
# 385 "/usr/include/c++/10/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {
# 398 "/usr/include/c++/10/bits/stl_vector.h" 3
      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
   "std::vector must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
   "std::vector must have the same value_type as its allocator");



      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;

    public:
      typedef _Tp value_type;
      typedef typename _Base::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
      const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    private:

      static constexpr bool
      _S_nothrow_relocate(true_type)
      {
 return noexcept(std::__relocate_a(std::declval<pointer>(),
       std::declval<pointer>(),
       std::declval<pointer>(),
       std::declval<_Tp_alloc_type&>()));
      }

      static constexpr bool
      _S_nothrow_relocate(false_type)
      { return false; }

      static constexpr bool
      _S_use_relocate()
      {



 return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});
      }

      static pointer
      _S_do_relocate(pointer __first, pointer __last, pointer __result,
       _Tp_alloc_type& __alloc, true_type) noexcept
      {
 return std::__relocate_a(__first, __last, __result, __alloc);
      }

      static pointer
      _S_do_relocate(pointer, pointer, pointer __result,
       _Tp_alloc_type&, false_type) noexcept
      { return __result; }

      static pointer
      _S_relocate(pointer __first, pointer __last, pointer __result,
    _Tp_alloc_type& __alloc) noexcept
      {
 using __do_it = __bool_constant<_S_use_relocate()>;
 return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
      }


    protected:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_M_impl;
      using _Base::_M_get_Tp_allocator;

    public:







      vector() = default;
# 493 "/usr/include/c++/10/bits/stl_vector.h" 3
      explicit
      vector(const allocator_type& __a) noexcept
      : _Base(__a) { }
# 506 "/usr/include/c++/10/bits/stl_vector.h" 3
      explicit
      vector(size_type __n, const allocator_type& __a = allocator_type())
      : _Base(_S_check_init_len(__n, __a), __a)
      { _M_default_initialize(__n); }
# 519 "/usr/include/c++/10/bits/stl_vector.h" 3
      vector(size_type __n, const value_type& __value,
      const allocator_type& __a = allocator_type())
      : _Base(_S_check_init_len(__n, __a), __a)
      { _M_fill_initialize(__n, __value); }
# 550 "/usr/include/c++/10/bits/stl_vector.h" 3
      vector(const vector& __x)
      : _Base(__x.size(),
 _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
      {
 this->_M_impl._M_finish =
   std::__uninitialized_copy_a(__x.begin(), __x.end(),
          this->_M_impl._M_start,
          _M_get_Tp_allocator());
      }
# 569 "/usr/include/c++/10/bits/stl_vector.h" 3
      vector(vector&&) noexcept = default;


      vector(const vector& __x, const allocator_type& __a)
      : _Base(__x.size(), __a)
      {
 this->_M_impl._M_finish =
   std::__uninitialized_copy_a(__x.begin(), __x.end(),
          this->_M_impl._M_start,
          _M_get_Tp_allocator());
      }

    private:
      vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
      : _Base(__m, std::move(__rv))
      { }

      vector(vector&& __rv, const allocator_type& __m, false_type)
      : _Base(__m)
      {
 if (__rv.get_allocator() == __m)
   this->_M_impl._M_swap_data(__rv._M_impl);
 else if (!__rv.empty())
   {
     this->_M_create_storage(__rv.size());
     this->_M_impl._M_finish =
       std::__uninitialized_move_a(__rv.begin(), __rv.end(),
       this->_M_impl._M_start,
       _M_get_Tp_allocator());
     __rv.clear();
   }
      }

    public:

      vector(vector&& __rv, const allocator_type& __m)
      noexcept( noexcept(
 vector(std::declval<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{})
      { }
# 622 "/usr/include/c++/10/bits/stl_vector.h" 3
      vector(initializer_list<value_type> __l,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 _M_range_initialize(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }
# 648 "/usr/include/c++/10/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 vector(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a = allocator_type())
 : _Base(__a)
 {
   _M_range_initialize(__first, __last,
         std::__iterator_category(__first));
 }
# 675 "/usr/include/c++/10/bits/stl_vector.h" 3
      ~vector() noexcept
      {
 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator());
 ;
      }
# 691 "/usr/include/c++/10/bits/stl_vector.h" 3
      vector&
      operator=(const vector& __x);
# 705 "/usr/include/c++/10/bits/stl_vector.h" 3
      vector&
      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
      {
 constexpr bool __move_storage =
   _Alloc_traits::_S_propagate_on_move_assign()
   || _Alloc_traits::_S_always_equal();
 _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
 return *this;
      }
# 726 "/usr/include/c++/10/bits/stl_vector.h" 3
      vector&
      operator=(initializer_list<value_type> __l)
      {
 this->_M_assign_aux(__l.begin(), __l.end(),
       random_access_iterator_tag());
 return *this;
      }
# 745 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 762 "/usr/include/c++/10/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_dispatch(__first, __last, __false_type()); }
# 790 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      assign(initializer_list<value_type> __l)
      {
 this->_M_assign_aux(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }



      using _Base::get_allocator;







      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_start); }






      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_start); }






      iterator
      end() noexcept
      { return iterator(this->_M_impl._M_finish); }






      const_iterator
      end() const noexcept
      { return const_iterator(this->_M_impl._M_finish); }






      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }






      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }






      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }






      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }







      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_start); }






      const_iterator
      cend() const noexcept
      { return const_iterator(this->_M_impl._M_finish); }






      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }






      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }




      size_type
      size() const noexcept
      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }


      size_type
      max_size() const noexcept
      { return _S_max_size(_M_get_Tp_allocator()); }
# 933 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      resize(size_type __new_size)
      {
 if (__new_size > size())
   _M_default_append(__new_size - size());
 else if (__new_size < size())
   _M_erase_at_end(this->_M_impl._M_start + __new_size);
      }
# 953 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      resize(size_type __new_size, const value_type& __x)
      {
 if (__new_size > size())
   _M_fill_insert(end(), __new_size - size(), __x);
 else if (__new_size < size())
   _M_erase_at_end(this->_M_impl._M_start + __new_size);
      }
# 985 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      shrink_to_fit()
      { _M_shrink_to_fit(); }






      size_type
      capacity() const noexcept
      { return size_type(this->_M_impl._M_end_of_storage
    - this->_M_impl._M_start); }





      [[__nodiscard__]] bool
      empty() const noexcept
      { return begin() == end(); }
# 1024 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      reserve(size_type __n);
# 1039 "/usr/include/c++/10/bits/stl_vector.h" 3
      reference
      operator[](size_type __n) noexcept
      {
 do { if (! (__builtin_expect(__n < this->size(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1042, __PRETTY_FUNCTION__, "__builtin_expect(__n < this->size(), true)"); } while (false);
 return *(this->_M_impl._M_start + __n);
      }
# 1057 "/usr/include/c++/10/bits/stl_vector.h" 3
      const_reference
      operator[](size_type __n) const noexcept
      {
 do { if (! (__builtin_expect(__n < this->size(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1060, __PRETTY_FUNCTION__, "__builtin_expect(__n < this->size(), true)"); } while (false);
 return *(this->_M_impl._M_start + __n);
      }

    protected:

      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")

                            ,
       __n, this->size());
      }

    public:
# 1088 "/usr/include/c++/10/bits/stl_vector.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1106 "/usr/include/c++/10/bits/stl_vector.h" 3
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }





      reference
      front() noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1120, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return *begin();
      }





      const_reference
      front() const noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1131, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return *begin();
      }





      reference
      back() noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1142, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return *(end() - 1);
      }





      const_reference
      back() const noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1153, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return *(end() - 1);
      }
# 1164 "/usr/include/c++/10/bits/stl_vector.h" 3
      _Tp*
      data() noexcept
      { return _M_data_ptr(this->_M_impl._M_start); }

      const _Tp*
      data() const noexcept
      { return _M_data_ptr(this->_M_impl._M_start); }
# 1183 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      push_back(const value_type& __x)
      {
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   {
     ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         __x);
     ++this->_M_impl._M_finish;
     ;
   }
 else
   _M_realloc_insert(end(), __x);
      }


      void
      push_back(value_type&& __x)
      { emplace_back(std::move(__x)); }

      template<typename... _Args>

 reference



 emplace_back(_Args&&... __args);
# 1221 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      pop_back() noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1224, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 --this->_M_impl._M_finish;
 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
 ;
      }
# 1243 "/usr/include/c++/10/bits/stl_vector.h" 3
      template<typename... _Args>
 iterator
 emplace(const_iterator __position, _Args&&... __args)
 { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
# 1259 "/usr/include/c++/10/bits/stl_vector.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1289 "/usr/include/c++/10/bits/stl_vector.h" 3
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_insert_rval(__position, std::move(__x)); }
# 1306 "/usr/include/c++/10/bits/stl_vector.h" 3
      iterator
      insert(const_iterator __position, initializer_list<value_type> __l)
      {
 auto __offset = __position - cbegin();
 _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
   std::random_access_iterator_tag());
 return begin() + __offset;
      }
# 1331 "/usr/include/c++/10/bits/stl_vector.h" 3
      iterator
      insert(const_iterator __position, size_type __n, const value_type& __x)
      {
 difference_type __offset = __position - cbegin();
 _M_fill_insert(begin() + __offset, __n, __x);
 return begin() + __offset;
      }
# 1373 "/usr/include/c++/10/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 iterator
 insert(const_iterator __position, _InputIterator __first,
        _InputIterator __last)
 {
   difference_type __offset = __position - cbegin();
   _M_insert_dispatch(begin() + __offset,
        __first, __last, __false_type());
   return begin() + __offset;
 }
# 1425 "/usr/include/c++/10/bits/stl_vector.h" 3
      iterator

      erase(const_iterator __position)
      { return _M_erase(begin() + (__position - cbegin())); }
# 1452 "/usr/include/c++/10/bits/stl_vector.h" 3
      iterator

      erase(const_iterator __first, const_iterator __last)
      {
 const auto __beg = begin();
 const auto __cbeg = cbegin();
 return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
      }
# 1476 "/usr/include/c++/10/bits/stl_vector.h" 3
      void
      swap(vector& __x) noexcept
      {

 do { if (! (_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) std::__replacement_assert("/usr/include/c++/10/bits/stl_vector.h", 1480, __PRETTY_FUNCTION__, "_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator()"); } 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());
      }







      void
      clear() noexcept
      { _M_erase_at_end(this->_M_impl._M_start); }

    protected:




      template<typename _ForwardIterator>
 pointer
 _M_allocate_and_copy(size_type __n,
        _ForwardIterator __first, _ForwardIterator __last)
 {
   pointer __result = this->_M_allocate(__n);
   try
     {
       std::__uninitialized_copy_a(__first, __last, __result,
       _M_get_Tp_allocator());
       return __result;
     }
   catch(...)
     {
       _M_deallocate(__result, __n);
       throw;
     }
 }
# 1553 "/usr/include/c++/10/bits/stl_vector.h" 3
      template<typename _InputIterator>
 void
 _M_range_initialize(_InputIterator __first, _InputIterator __last,
       std::input_iterator_tag)
 {
   try {
     for (; __first != __last; ++__first)

       emplace_back(*__first);



   } catch(...) {
     clear();
     throw;
   }
 }


      template<typename _ForwardIterator>
 void
 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
       std::forward_iterator_tag)
 {
   const size_type __n = std::distance(__first, __last);
   this->_M_impl._M_start
     = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
   this->_M_impl._M_finish =
     std::__uninitialized_copy_a(__first, __last,
     this->_M_impl._M_start,
     _M_get_Tp_allocator());
 }



      void
      _M_fill_initialize(size_type __n, const value_type& __value)
      {
 this->_M_impl._M_finish =
   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
     _M_get_Tp_allocator());
      }



      void
      _M_default_initialize(size_type __n)
      {
 this->_M_impl._M_finish =
   std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
        _M_get_Tp_allocator());
      }
# 1615 "/usr/include/c++/10/bits/stl_vector.h" 3
      template<typename _Integer>
 void
 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
 { _M_fill_assign(__n, __val); }


      template<typename _InputIterator>
 void
 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }


      template<typename _InputIterator>
 void
 _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag);


      template<typename _ForwardIterator>
 void
 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag);



      void
      _M_fill_assign(size_type __n, const value_type& __val);







      template<typename _Integer>
 void
 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
      __true_type)
 { _M_fill_insert(__pos, __n, __val); }


      template<typename _InputIterator>
 void
 _M_insert_dispatch(iterator __pos, _InputIterator __first,
      _InputIterator __last, __false_type)
 {
   _M_range_insert(__pos, __first, __last,
     std::__iterator_category(__first));
 }


      template<typename _InputIterator>
 void
 _M_range_insert(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag);


      template<typename _ForwardIterator>
 void
 _M_range_insert(iterator __pos, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);



      void
      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);



      void
      _M_default_append(size_type __n);

      bool
      _M_shrink_to_fit();
# 1702 "/usr/include/c++/10/bits/stl_vector.h" 3
      struct _Temporary_value
      {
 template<typename... _Args>
   explicit
   _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
   {
     _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
         std::forward<_Args>(__args)...);
   }

 ~_Temporary_value()
 { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }

 value_type&
 _M_val() { return *_M_ptr(); }

      private:
 _Tp*
 _M_ptr() { return reinterpret_cast<_Tp*>(&__buf); }

 vector* _M_this;
 typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __buf;
      };



      template<typename _Arg>
 void
 _M_insert_aux(iterator __position, _Arg&& __arg);

      template<typename... _Args>
 void
 _M_realloc_insert(iterator __position, _Args&&... __args);


      iterator
      _M_insert_rval(const_iterator __position, value_type&& __v);


      template<typename... _Args>
 iterator
 _M_emplace_aux(const_iterator __position, _Args&&... __args);


      iterator
      _M_emplace_aux(const_iterator __position, value_type&& __v)
      { return _M_insert_rval(__position, std::move(__v)); }



      size_type
      _M_check_len(size_type __n, const char* __s) const
      {
 if (max_size() - size() < __n)
   __throw_length_error((__s));

 const size_type __len = size() + (std::max)(size(), __n);
 return (__len < size() || __len > max_size()) ? max_size() : __len;
      }


      static size_type
      _S_check_init_len(size_type __n, const allocator_type& __a)
      {
 if (__n > _S_max_size(_Tp_alloc_type(__a)))
   __throw_length_error(
       ("cannot create std::vector larger than max_size()"));
 return __n;
      }

      static size_type
      _S_max_size(const _Tp_alloc_type& __a) noexcept
      {



 const size_t __diffmax
   = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
 const size_t __allocmax = _Alloc_traits::max_size(__a);
 return (std::min)(__diffmax, __allocmax);
      }





      void
      _M_erase_at_end(pointer __pos) noexcept
      {
 if (size_type __n = this->_M_impl._M_finish - __pos)
   {
     std::_Destroy(__pos, this->_M_impl._M_finish,
     _M_get_Tp_allocator());
     this->_M_impl._M_finish = __pos;
     ;
   }
      }

      iterator
      _M_erase(iterator __position);

      iterator
      _M_erase(iterator __first, iterator __last);


    private:



      void
      _M_move_assign(vector&& __x, true_type) noexcept
      {
 vector __tmp(get_allocator());
 this->_M_impl._M_swap_data(__x._M_impl);
 __tmp._M_impl._M_swap_data(__x._M_impl);
 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
      }



      void
      _M_move_assign(vector&& __x, false_type)
      {
 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
   _M_move_assign(std::move(__x), true_type());
 else
   {


     this->_M_assign_aux(std::make_move_iterator(__x.begin()),
           std::make_move_iterator(__x.end()),
    std::random_access_iterator_tag());
     __x.clear();
   }
      }


      template<typename _Up>
 _Up*
 _M_data_ptr(_Up* __ptr) const noexcept
 { return __ptr; }


      template<typename _Ptr>
 typename std::pointer_traits<_Ptr>::element_type*
 _M_data_ptr(_Ptr __ptr) const
 { return empty() ? nullptr : std::__to_address(__ptr); }
# 1865 "/usr/include/c++/10/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>;
# 1887 "/usr/include/c++/10/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return (__x.size() == __y.size()
       && std::equal(__x.begin(), __x.end(), __y.begin())); }
# 1904 "/usr/include/c++/10/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end()); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Alloc>
    inline void
    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }




  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Alloc>
      struct _Never_valueless_alt<std::vector<_Tp, _Alloc>>
      : std::is_nothrow_move_assignable<std::vector<_Tp, _Alloc>>
      { };
  }



}
# 68 "/usr/include/c++/10/vector" 2 3
# 1 "/usr/include/c++/10/bits/stl_bvector.h" 1 3
# 64 "/usr/include/c++/10/bits/stl_bvector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  typedef unsigned long _Bit_type;
  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };

  struct _Bit_reference
  {
    _Bit_type * _M_p;
    _Bit_type _M_mask;

    _Bit_reference(_Bit_type * __x, _Bit_type __y)
    : _M_p(__x), _M_mask(__y) { }

    _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }


    _Bit_reference(const _Bit_reference&) = default;


    operator bool() const noexcept
    { return !!(*_M_p & _M_mask); }

    _Bit_reference&
    operator=(bool __x) noexcept
    {
      if (__x)
 *_M_p |= _M_mask;
      else
 *_M_p &= ~_M_mask;
      return *this;
    }

    _Bit_reference&
    operator=(const _Bit_reference& __x) noexcept
    { return *this = bool(__x); }

    bool
    operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }

    bool
    operator<(const _Bit_reference& __x) const
    { return !bool(*this) && bool(__x); }

    void
    flip() noexcept
    { *_M_p ^= _M_mask; }
  };


  inline void
  swap(_Bit_reference __x, _Bit_reference __y) noexcept
  {
    bool __tmp = __x;
    __x = __y;
    __y = __tmp;
  }

  inline void
  swap(_Bit_reference __x, bool& __y) noexcept
  {
    bool __tmp = __x;
    __x = __y;
    __y = __tmp;
  }

  inline void
  swap(bool& __x, _Bit_reference __y) noexcept
  {
    bool __tmp = __x;
    __x = __y;
    __y = __tmp;
  }


  struct _Bit_iterator_base
  : public std::iterator<std::random_access_iterator_tag, bool>
  {
    _Bit_type * _M_p;
    unsigned int _M_offset;

    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) { }

    void
    _M_bump_up()
    {
      if (_M_offset++ == int(_S_word_bit) - 1)
 {
   _M_offset = 0;
   ++_M_p;
 }
    }

    void
    _M_bump_down()
    {
      if (_M_offset-- == 0)
 {
   _M_offset = int(_S_word_bit) - 1;
   --_M_p;
 }
    }

    void
    _M_incr(ptrdiff_t __i)
    {
      difference_type __n = __i + _M_offset;
      _M_p += __n / int(_S_word_bit);
      __n = __n % int(_S_word_bit);
      if (__n < 0)
 {
   __n += int(_S_word_bit);
   --_M_p;
 }
      _M_offset = static_cast<unsigned int>(__n);
    }

    friend bool
    operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; }

    friend bool
    operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    {
      return __x._M_p < __y._M_p
     || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
    }

    friend bool
    operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    { return !(__x == __y); }

    friend bool
    operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    { return __y < __x; }

    friend bool
    operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    { return !(__y < __x); }

    friend bool
    operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    { return !(__x < __y); }

    friend ptrdiff_t
    operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    {
      return (int(_S_word_bit) * (__x._M_p - __y._M_p)
       + __x._M_offset - __y._M_offset);
    }
  };

  struct _Bit_iterator : public _Bit_iterator_base
  {
    typedef _Bit_reference reference;



    typedef _Bit_reference* pointer;

    typedef _Bit_iterator iterator;

    _Bit_iterator() : _Bit_iterator_base(0, 0) { }

    _Bit_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    iterator
    _M_const_cast() const
    { return *this; }

    reference
    operator*() const
    { return reference(_M_p, 1UL << _M_offset); }

    iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    iterator
    operator++(int)
    {
      iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    iterator
    operator--(int)
    {
      iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    reference
    operator[](difference_type __i) const
    { return *(*this + __i); }

    friend iterator
    operator+(const iterator& __x, difference_type __n)
    {
      iterator __tmp = __x;
      __tmp += __n;
      return __tmp;
    }

    friend iterator
    operator+(difference_type __n, const iterator& __x)
    { return __x + __n; }

    friend iterator
    operator-(const iterator& __x, difference_type __n)
    {
      iterator __tmp = __x;
      __tmp -= __n;
      return __tmp;
    }
  };

  struct _Bit_const_iterator : public _Bit_iterator_base
  {
    typedef bool reference;
    typedef bool const_reference;



    typedef const bool* pointer;

    typedef _Bit_const_iterator const_iterator;

    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }

    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    _Bit_const_iterator(const _Bit_iterator& __x)
    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }

    _Bit_iterator
    _M_const_cast() const
    { return _Bit_iterator(_M_p, _M_offset); }

    const_reference
    operator*() const
    { return _Bit_reference(_M_p, 1UL << _M_offset); }

    const_iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    const_iterator
    operator++(int)
    {
      const_iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    const_iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    const_iterator
    operator--(int)
    {
      const_iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    const_iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    const_iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    const_reference
    operator[](difference_type __i) const
    { return *(*this + __i); }

    friend const_iterator
    operator+(const const_iterator& __x, difference_type __n)
    {
      const_iterator __tmp = __x;
      __tmp += __n;
      return __tmp;
    }

    friend const_iterator
    operator-(const const_iterator& __x, difference_type __n)
    {
      const_iterator __tmp = __x;
      __tmp -= __n;
      return __tmp;
    }

    friend const_iterator
    operator+(difference_type __n, const const_iterator& __x)
    { return __x + __n; }
  };

  inline void
  __fill_bvector(_Bit_type * __v,
   unsigned int __first, unsigned int __last, bool __x)
  {
    const _Bit_type __fmask = ~0ul << __first;
    const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
    const _Bit_type __mask = __fmask & __lmask;

    if (__x)
      *__v |= __mask;
    else
      *__v &= ~__mask;
  }

  inline void
  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
  {
    if (__first._M_p != __last._M_p)
      {
 _Bit_type* __first_p = __first._M_p;
 if (__first._M_offset != 0)
   __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);

 __builtin_memset(__first_p, __x ? ~0 : 0,
    (__last._M_p - __first_p) * sizeof(_Bit_type));

 if (__last._M_offset != 0)
   __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
      }
    else if (__first._M_offset != __last._M_offset)
      __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
  }

  template<typename _Alloc>
    struct _Bvector_base
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
        rebind<_Bit_type>::other _Bit_alloc_type;
      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
 _Bit_alloc_traits;
      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;

      struct _Bvector_impl_data
      {
 _Bit_iterator _M_start;
 _Bit_iterator _M_finish;
 _Bit_pointer _M_end_of_storage;

 _Bvector_impl_data() noexcept
 : _M_start(), _M_finish(), _M_end_of_storage()
 { }


 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
 : _M_start(__x._M_start), _M_finish(__x._M_finish)
 , _M_end_of_storage(__x._M_end_of_storage)
 { __x._M_reset(); }

 void
 _M_move_data(_Bvector_impl_data&& __x) noexcept
 {
   this->_M_start = __x._M_start;
   this->_M_finish = __x._M_finish;
   this->_M_end_of_storage = __x._M_end_of_storage;
   __x._M_reset();
 }


 void
 _M_reset() noexcept
 {
   _M_start = _M_finish = _Bit_iterator();
   _M_end_of_storage = _Bit_pointer();
 }
      };

      struct _Bvector_impl
 : public _Bit_alloc_type, public _Bvector_impl_data
 {
 public:
   _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value)

   : _Bit_alloc_type()
   { }

   _Bvector_impl(const _Bit_alloc_type& __a) noexcept
   : _Bit_alloc_type(__a)
   { }


 _Bvector_impl(_Bvector_impl&&) = default;


 _Bit_type*
 _M_end_addr() const noexcept
 {
   if (this->_M_end_of_storage)
     return std::__addressof(this->_M_end_of_storage[-1]) + 1;
   return 0;
 }
      };

    public:
      typedef _Alloc allocator_type;

      _Bit_alloc_type&
      _M_get_Bit_allocator() noexcept
      { return this->_M_impl; }

      const _Bit_alloc_type&
      _M_get_Bit_allocator() const noexcept
      { return this->_M_impl; }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Bit_allocator()); }


      _Bvector_base() = default;




      _Bvector_base(const allocator_type& __a)
      : _M_impl(__a) { }


      _Bvector_base(_Bvector_base&&) = default;


      ~_Bvector_base()
      { this->_M_deallocate(); }

    protected:
      _Bvector_impl _M_impl;

      _Bit_pointer
      _M_allocate(size_t __n)
      { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }

      void
      _M_deallocate()
      {
 if (_M_impl._M_start._M_p)
   {
     const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
     _Bit_alloc_traits::deallocate(_M_impl,
       _M_impl._M_end_of_storage - __n,
       __n);
     _M_impl._M_reset();
   }
      }


      void
      _M_move_data(_Bvector_base&& __x) noexcept
      { _M_impl._M_move_data(std::move(__x._M_impl)); }


      static size_t
      _S_nword(size_t __n)
      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
    };



}




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


# 603 "/usr/include/c++/10/bits/stl_bvector.h" 3
  template<typename _Alloc>
    class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
    {
      typedef _Bvector_base<_Alloc> _Base;
      typedef typename _Base::_Bit_pointer _Bit_pointer;
      typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;


      friend struct std::hash<vector>;


    public:
      typedef bool value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Bit_reference reference;
      typedef bool const_reference;
      typedef _Bit_reference* pointer;
      typedef const bool* const_pointer;
      typedef _Bit_iterator iterator;
      typedef _Bit_const_iterator const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef _Alloc allocator_type;

      allocator_type
      get_allocator() const
      { return _Base::get_allocator(); }

    protected:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_S_nword;
      using _Base::_M_get_Bit_allocator;

    public:

      vector() = default;




      explicit
      vector(const allocator_type& __a)
      : _Base(__a) { }


      explicit
      vector(size_type __n, const allocator_type& __a = allocator_type())
      : vector(__n, false, __a)
      { }

      vector(size_type __n, const bool& __value,
      const allocator_type& __a = allocator_type())





      : _Base(__a)
      {
 _M_initialize(__n);
 _M_initialize_value(__value);
      }

      vector(const vector& __x)
      : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
      {
 _M_initialize(__x.size());
 _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
      }


      vector(vector&&) = default;

      vector(vector&& __x, const allocator_type& __a)
      noexcept(_Bit_alloc_traits::_S_always_equal())
      : _Base(__a)
      {
 if (__x.get_allocator() == __a)
   this->_M_move_data(std::move(__x));
 else
   {
     _M_initialize(__x.size());
     _M_copy_aligned(__x.begin(), __x.end(), begin());
     __x.clear();
   }
      }

      vector(const vector& __x, const allocator_type& __a)
      : _Base(__a)
      {
 _M_initialize(__x.size());
 _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
      }

      vector(initializer_list<bool> __l,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 _M_initialize_range(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }



      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 vector(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a = allocator_type())
 : _Base(__a)
 { _M_initialize_dispatch(__first, __last, __false_type()); }
# 726 "/usr/include/c++/10/bits/stl_bvector.h" 3
      ~vector() noexcept { }

      vector&
      operator=(const vector& __x)
      {
 if (&__x == this)
   return *this;

 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
   {
     if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
       {
  this->_M_deallocate();
  std::__alloc_on_copy(_M_get_Bit_allocator(),
         __x._M_get_Bit_allocator());
  _M_initialize(__x.size());
       }
     else
       std::__alloc_on_copy(_M_get_Bit_allocator(),
       __x._M_get_Bit_allocator());
   }

 if (__x.size() > capacity())
   {
     this->_M_deallocate();
     _M_initialize(__x.size());
   }
 this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
        begin());
 return *this;
      }


      vector&
      operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
      {
 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
     || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
   {
     this->_M_deallocate();
     this->_M_move_data(std::move(__x));
     std::__alloc_on_move(_M_get_Bit_allocator(),
     __x._M_get_Bit_allocator());
   }
 else
   {
     if (__x.size() > capacity())
       {
  this->_M_deallocate();
  _M_initialize(__x.size());
       }
     this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
            begin());
     __x.clear();
   }
 return *this;
      }

      vector&
      operator=(initializer_list<bool> __l)
      {
 this->assign (__l.begin(), __l.end());
 return *this;
      }






      void
      assign(size_type __n, const bool& __x)
      { _M_fill_assign(__n, __x); }


      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
# 817 "/usr/include/c++/10/bits/stl_bvector.h" 3
      void
      assign(initializer_list<bool> __l)
      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }


      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_start._M_p, 0); }

      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_start._M_p, 0); }

      iterator
      end() noexcept
      { return this->_M_impl._M_finish; }

      const_iterator
      end() const noexcept
      { return this->_M_impl._M_finish; }

      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }


      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_start._M_p, 0); }

      const_iterator
      cend() const noexcept
      { return this->_M_impl._M_finish; }

      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }


      size_type
      size() const noexcept
      { return size_type(end() - begin()); }

      size_type
      max_size() const noexcept
      {
 const size_type __isize =
   __gnu_cxx::__numeric_traits<difference_type>::__max
   - int(_S_word_bit) + 1;
 const size_type __asize
   = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
 return (__asize <= __isize / int(_S_word_bit)
  ? __asize * int(_S_word_bit) : __isize);
      }

      size_type
      capacity() const noexcept
      { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
    - begin()); }

      [[__nodiscard__]] bool
      empty() const noexcept
      { return begin() == end(); }

      reference
      operator[](size_type __n)
      {
 return *iterator(this->_M_impl._M_start._M_p
    + __n / int(_S_word_bit), __n % int(_S_word_bit));
      }

      const_reference
      operator[](size_type __n) const
      {
 return *const_iterator(this->_M_impl._M_start._M_p
        + __n / int(_S_word_bit), __n % int(_S_word_bit));
      }

    protected:
      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")

                            ,
       __n, this->size());
      }

    public:
      reference
      at(size_type __n)
      { _M_range_check(__n); return (*this)[__n]; }

      const_reference
      at(size_type __n) const
      { _M_range_check(__n); return (*this)[__n]; }

      void
      reserve(size_type __n)
      {
 if (__n > max_size())
   __throw_length_error(("vector::reserve"));
 if (capacity() < __n)
   _M_reallocate(__n);
      }

      reference
      front()
      { return *begin(); }

      const_reference
      front() const
      { return *begin(); }

      reference
      back()
      { return *(end() - 1); }

      const_reference
      back() const
      { return *(end() - 1); }






      void
      data() noexcept { }

      void
      push_back(bool __x)
      {
 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
   *this->_M_impl._M_finish++ = __x;
 else
   _M_insert_aux(end(), __x);
      }

      void
      swap(vector& __x) noexcept
      {
 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
 std::swap(this->_M_impl._M_end_of_storage,
    __x._M_impl._M_end_of_storage);
 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
          __x._M_get_Bit_allocator());
      }


      static void
      swap(reference __x, reference __y) noexcept
      {
 bool __tmp = __x;
 __x = __y;
 __y = __tmp;
      }

      iterator

      insert(const_iterator __position, const bool& __x = bool())



      {
 const difference_type __n = __position - begin();
 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
     && __position == end())
   *this->_M_impl._M_finish++ = __x;
 else
   _M_insert_aux(__position._M_const_cast(), __x);
 return begin() + __n;
      }


      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 iterator
 insert(const_iterator __position,
        _InputIterator __first, _InputIterator __last)
 {
   difference_type __offset = __position - cbegin();
   _M_insert_dispatch(__position._M_const_cast(),
        __first, __last, __false_type());
   return begin() + __offset;
 }
# 1033 "/usr/include/c++/10/bits/stl_bvector.h" 3
      iterator
      insert(const_iterator __position, size_type __n, const bool& __x)
      {
 difference_type __offset = __position - cbegin();
 _M_fill_insert(__position._M_const_cast(), __n, __x);
 return begin() + __offset;
      }







      iterator
      insert(const_iterator __p, initializer_list<bool> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }


      void
      pop_back()
      { --this->_M_impl._M_finish; }

      iterator

      erase(const_iterator __position)



      { return _M_erase(__position._M_const_cast()); }

      iterator

      erase(const_iterator __first, const_iterator __last)



      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }

      void
      resize(size_type __new_size, bool __x = bool())
      {
 if (__new_size < size())
   _M_erase_at_end(begin() + difference_type(__new_size));
 else
   insert(end(), __new_size - size(), __x);
      }


      void
      shrink_to_fit()
      { _M_shrink_to_fit(); }


      void
      flip() noexcept
      {
 _Bit_type * const __end = this->_M_impl._M_end_addr();
 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
   *__p = ~*__p;
      }

      void
      clear() noexcept
      { _M_erase_at_end(begin()); }


      template<typename... _Args>

 reference



 emplace_back(_Args&&... __args)
 {
   push_back(bool(__args...));

   return back();

 }

      template<typename... _Args>
 iterator
 emplace(const_iterator __pos, _Args&&... __args)
 { return insert(__pos, bool(__args...)); }


    protected:

      iterator
      _M_copy_aligned(const_iterator __first, const_iterator __last,
        iterator __result)
      {
 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
 return std::copy(const_iterator(__last._M_p, 0), __last,
    iterator(__q, 0));
      }

      void
      _M_initialize(size_type __n)
      {
 if (__n)
   {
     _Bit_pointer __q = this->_M_allocate(__n);
     this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
     this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
   }
 else
   {
     this->_M_impl._M_end_of_storage = _Bit_pointer();
     this->_M_impl._M_start = iterator(0, 0);
   }
 this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);

      }

      void
      _M_initialize_value(bool __x)
      {
 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
   __builtin_memset(__p, __x ? ~0 : 0,
      (this->_M_impl._M_end_addr() - __p)
      * sizeof(_Bit_type));
      }

      void
      _M_reallocate(size_type __n);


      bool
      _M_shrink_to_fit();






      template<typename _Integer>
 void
 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
 {
   _M_initialize(static_cast<size_type>(__n));
   _M_initialize_value(__x);
 }

      template<typename _InputIterator>
 void
 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
          __false_type)
 { _M_initialize_range(__first, __last,
         std::__iterator_category(__first)); }

      template<typename _InputIterator>
 void
 _M_initialize_range(_InputIterator __first, _InputIterator __last,
       std::input_iterator_tag)
 {
   for (; __first != __last; ++__first)
     push_back(*__first);
 }

      template<typename _ForwardIterator>
 void
 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
       std::forward_iterator_tag)
 {
   const size_type __n = std::distance(__first, __last);
   _M_initialize(__n);
   std::copy(__first, __last, this->_M_impl._M_start);
 }
# 1219 "/usr/include/c++/10/bits/stl_bvector.h" 3
      void
      _M_fill_assign(size_t __n, bool __x)
      {
 if (__n > size())
   {
     _M_initialize_value(__x);
     insert(end(), __n - size(), __x);
   }
 else
   {
     _M_erase_at_end(begin() + __n);
     _M_initialize_value(__x);
   }
      }

      template<typename _InputIterator>
 void
 _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag)
 {
   iterator __cur = begin();
   for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
     *__cur = *__first;
   if (__first == __last)
     _M_erase_at_end(__cur);
   else
     insert(end(), __first, __last);
 }

      template<typename _ForwardIterator>
 void
 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag)
 {
   const size_type __len = std::distance(__first, __last);
   if (__len < size())
     _M_erase_at_end(std::copy(__first, __last, begin()));
   else
     {
       _ForwardIterator __mid = __first;
       std::advance(__mid, size());
       std::copy(__first, __mid, begin());
       insert(end(), __mid, __last);
     }
 }





      template<typename _Integer>
 void
 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
      __true_type)
 { _M_fill_insert(__pos, __n, __x); }

      template<typename _InputIterator>
 void
 _M_insert_dispatch(iterator __pos,
      _InputIterator __first, _InputIterator __last,
      __false_type)
 { _M_insert_range(__pos, __first, __last,
     std::__iterator_category(__first)); }

      void
      _M_fill_insert(iterator __position, size_type __n, bool __x);

      template<typename _InputIterator>
 void
 _M_insert_range(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag)
 {
   for (; __first != __last; ++__first)
     {
       __pos = insert(__pos, *__first);
       ++__pos;
     }
 }

      template<typename _ForwardIterator>
 void
 _M_insert_range(iterator __position, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);

      void
      _M_insert_aux(iterator __position, bool __x);

      size_type
      _M_check_len(size_type __n, const char* __s) const
      {
 if (max_size() - size() < __n)
   __throw_length_error((__s));

 const size_type __len = size() + std::max(size(), __n);
 return (__len < size() || __len > max_size()) ? max_size() : __len;
      }

      void
      _M_erase_at_end(iterator __pos)
      { this->_M_impl._M_finish = __pos; }

      iterator
      _M_erase(iterator __pos);

      iterator
      _M_erase(iterator __first, iterator __last);
  };



}



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




  template<typename _Alloc>
    struct hash<std::vector<bool, _Alloc>>
    : public __hash_base<size_t, std::vector<bool, _Alloc>>
    {
      size_t
      operator()(const std::vector<bool, _Alloc>&) const noexcept;
    };


}
# 69 "/usr/include/c++/10/vector" 2 3



# 1 "/usr/include/c++/10/bits/vector.tcc" 1 3
# 59 "/usr/include/c++/10/bits/vector.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   const size_type __old_size = size();
   pointer __tmp;

   if constexpr (_S_use_relocate())
     {
       __tmp = this->_M_allocate(__n);
       _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
     __tmp, _M_get_Tp_allocator());
     }
   else

     {
       __tmp = _M_allocate_and_copy(__n,
  std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
  std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
   ;
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_finish = __tmp + __old_size;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
 }
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>

      typename vector<_Tp, _Alloc>::reference



      vector<_Tp, _Alloc>::
      emplace_back(_Args&&... __args)
      {
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   {
     ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         std::forward<_Args>(__args)...);
     ++this->_M_impl._M_finish;
     ;
   }
 else
   _M_realloc_insert(end(), std::forward<_Args>(__args)...);

 return back();

      }


  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::

    insert(const_iterator __position, const value_type& __x)



    {
      const size_type __n = __position - begin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 if (__position == end())
   {
     ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         __x);
     ++this->_M_impl._M_finish;
     ;
   }
 else
   {

     const auto __pos = begin() + (__position - cbegin());


     _Temporary_value __x_copy(this, __x);
     _M_insert_aux(__pos, std::move(__x_copy._M_val()));



   }
      else

 _M_realloc_insert(begin() + (__position - cbegin()), __x);




      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    _M_erase(iterator __position)
    {
      if (__position + 1 != end())
 std::move(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
      ;
      return __position;
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    _M_erase(iterator __first, iterator __last)
    {
      if (__first != __last)
 {
   if (__last != end())
     std::move(__last, end(), __first);
   _M_erase_at_end(__first.base() + (end() - __last));
 }
      return __first;
    }

  template<typename _Tp, typename _Alloc>
    vector<_Tp, _Alloc>&
    vector<_Tp, _Alloc>::
    operator=(const vector<_Tp, _Alloc>& __x)
    {
      if (&__x != this)
 {
   ;

   if (_Alloc_traits::_S_propagate_on_copy_assign())
     {
       if (!_Alloc_traits::_S_always_equal()
           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
         {

    this->clear();
    _M_deallocate(this->_M_impl._M_start,
    this->_M_impl._M_end_of_storage
    - this->_M_impl._M_start);
    this->_M_impl._M_start = nullptr;
    this->_M_impl._M_finish = nullptr;
    this->_M_impl._M_end_of_storage = nullptr;
  }
       std::__alloc_on_copy(_M_get_Tp_allocator(),
       __x._M_get_Tp_allocator());
     }

   const size_type __xlen = __x.size();
   if (__xlen > capacity())
     {
       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
         __x.end());
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __tmp;
       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
     }
   else if (size() >= __xlen)
     {
       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
       end(), _M_get_Tp_allocator());
     }
   else
     {
       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
   this->_M_impl._M_start);
       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
       __x._M_impl._M_finish,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
 }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_fill_assign(size_t __n, const value_type& __val)
    {
      if (__n > capacity())
 {
   vector __tmp(__n, __val, _M_get_Tp_allocator());
   __tmp._M_impl._M_swap_data(this->_M_impl);
 }
      else if (__n > size())
 {
   std::fill(begin(), end(), __val);
   const size_type __add = __n - size();
   ;
   this->_M_impl._M_finish =
     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
       __add, __val, _M_get_Tp_allocator());
   ;
 }
      else
        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 pointer __cur(this->_M_impl._M_start);
 for (; __first != __last && __cur != this->_M_impl._M_finish;
      ++__cur, (void)++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   _M_range_insert(end(), __first, __last,
     std::__iterator_category(__first));
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __len = std::distance(__first, __last);

 if (__len > capacity())
   {
     _S_check_init_len(__len, _M_get_Tp_allocator());
     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
     _M_get_Tp_allocator());
     ;
     _M_deallocate(this->_M_impl._M_start,
     this->_M_impl._M_end_of_storage
     - this->_M_impl._M_start);
     this->_M_impl._M_start = __tmp;
     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
   }
 else if (size() >= __len)
   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, size());
     std::copy(__first, __mid, this->_M_impl._M_start);
     const size_type __attribute__((__unused__)) __n = __len - size();
     ;
     this->_M_impl._M_finish =
       std::__uninitialized_copy_a(__mid, __last,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     ;
   }
      }


  template<typename _Tp, typename _Alloc>
    auto
    vector<_Tp, _Alloc>::
    _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator
    {
      const auto __n = __position - cbegin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 if (__position == cend())
   {
     ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         std::move(__v));
     ++this->_M_impl._M_finish;
     ;
   }
 else
   _M_insert_aux(begin() + __n, std::move(__v));
      else
 _M_realloc_insert(begin() + __n, std::move(__v));

      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      auto
      vector<_Tp, _Alloc>::
      _M_emplace_aux(const_iterator __position, _Args&&... __args)
      -> iterator
      {
 const auto __n = __position - cbegin();
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   if (__position == cend())
     {
       ;
       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
           std::forward<_Args>(__args)...);
       ++this->_M_impl._M_finish;
       ;
     }
   else
     {



       _Temporary_value __tmp(this, std::forward<_Args>(__args)...);
       _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
     }
 else
   _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...);

 return iterator(this->_M_impl._M_start + __n);
      }

  template<typename _Tp, typename _Alloc>
    template<typename _Arg>
      void
      vector<_Tp, _Alloc>::
      _M_insert_aux(iterator __position, _Arg&& __arg)






    {
      ;
      _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
          std::move(*(this->_M_impl._M_finish - 1)));
      ++this->_M_impl._M_finish;
      ;



      std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)

                                     ;



      *__position = std::forward<_Arg>(__arg);

    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      void
      vector<_Tp, _Alloc>::
      _M_realloc_insert(iterator __position, _Args&&... __args)






    {
      const size_type __len =
 _M_check_len(size_type(1), "vector::_M_realloc_insert");
      pointer __old_start = this->_M_impl._M_start;
      pointer __old_finish = this->_M_impl._M_finish;
      const size_type __elems_before = __position - begin();
      pointer __new_start(this->_M_allocate(__len));
      pointer __new_finish(__new_start);
      try
 {





   _Alloc_traits::construct(this->_M_impl,
       __new_start + __elems_before,

       std::forward<_Args>(__args)...);



   __new_finish = pointer();


   if constexpr (_S_use_relocate())
     {
       __new_finish = _S_relocate(__old_start, __position.base(),
      __new_start, _M_get_Tp_allocator());

       ++__new_finish;

       __new_finish = _S_relocate(__position.base(), __old_finish,
      __new_finish, _M_get_Tp_allocator());
     }
   else

     {
       __new_finish
  = std::__uninitialized_move_if_noexcept_a
  (__old_start, __position.base(),
   __new_start, _M_get_Tp_allocator());

       ++__new_finish;

       __new_finish
  = std::__uninitialized_move_if_noexcept_a
  (__position.base(), __old_finish,
   __new_finish, _M_get_Tp_allocator());
     }
 }
      catch(...)
 {
   if (!__new_finish)
     _Alloc_traits::destroy(this->_M_impl,
       __new_start + __elems_before);
   else
     std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
   _M_deallocate(__new_start, __len);
   throw;
 }

      if constexpr (!_S_use_relocate())

 std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
      ;
      _M_deallocate(__old_start,
      this->_M_impl._M_end_of_storage - __old_start);
      this->_M_impl._M_start = __new_start;
      this->_M_impl._M_finish = __new_finish;
      this->_M_impl._M_end_of_storage = __new_start + __len;
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
    {
      if (__n != 0)
 {
   if (size_type(this->_M_impl._M_end_of_storage
   - this->_M_impl._M_finish) >= __n)
     {



       _Temporary_value __tmp(this, __x);
       value_type& __x_copy = __tmp._M_val();

       const size_type __elems_after = end() - __position;
       pointer __old_finish(this->_M_impl._M_finish);
       if (__elems_after > __n)
  {
    ;
    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
           this->_M_impl._M_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __n;
    ;
    std::move_backward(__position.base(), __old_finish - __n, __old_finish)
                                        ;
    std::fill(__position.base(), __position.base() + __n,
       __x_copy);
  }
       else
  {
    ;
    this->_M_impl._M_finish =
      std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
        __n - __elems_after,
        __x_copy,
        _M_get_Tp_allocator());
    ;
    std::__uninitialized_move_a(__position.base(), __old_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __elems_after;
    ;
    std::fill(__position.base(), __old_finish, __x_copy);
  }
     }
   else
     {
       const size_type __len =
  _M_check_len(__n, "vector::_M_fill_insert");
       const size_type __elems_before = __position - begin();
       pointer __new_start(this->_M_allocate(__len));
       pointer __new_finish(__new_start);
       try
  {

    std::__uninitialized_fill_n_a(__new_start + __elems_before,
      __n, __x,
      _M_get_Tp_allocator());
    __new_finish = pointer();

    __new_finish
      = std::__uninitialized_move_if_noexcept_a
      (this->_M_impl._M_start, __position.base(),
       __new_start, _M_get_Tp_allocator());

    __new_finish += __n;

    __new_finish
      = std::__uninitialized_move_if_noexcept_a
      (__position.base(), this->_M_impl._M_finish,
       __new_finish, _M_get_Tp_allocator());
  }
       catch(...)
  {
    if (!__new_finish)
      std::_Destroy(__new_start + __elems_before,
      __new_start + __elems_before + __n,
      _M_get_Tp_allocator());
    else
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
    _M_deallocate(__new_start, __len);
    throw;
  }
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       ;
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_finish;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }


  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_default_append(size_type __n)
    {
      if (__n != 0)
 {
   const size_type __size = size();
   size_type __navail = size_type(this->_M_impl._M_end_of_storage
      - this->_M_impl._M_finish);

   if (__size > max_size() || __navail > max_size() - __size)
     __builtin_unreachable();

   if (__navail >= __n)
     {
       ;
       this->_M_impl._M_finish =
  std::__uninitialized_default_n_a(this->_M_impl._M_finish,
       __n, _M_get_Tp_allocator());
       ;
     }
   else
     {
       const size_type __len =
  _M_check_len(__n, "vector::_M_default_append");
       pointer __new_start(this->_M_allocate(__len));
       if constexpr (_S_use_relocate())
  {
    try
      {
        std::__uninitialized_default_n_a(__new_start + __size,
         __n, _M_get_Tp_allocator());
      }
    catch(...)
      {
        _M_deallocate(__new_start, __len);
        throw;
      }
    _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
         __new_start, _M_get_Tp_allocator());
  }
       else
  {
    pointer __destroy_from = pointer();
    try
      {
        std::__uninitialized_default_n_a(__new_start + __size,
         __n, _M_get_Tp_allocator());
        __destroy_from = __new_start + __size;
        std::__uninitialized_move_if_noexcept_a(
         this->_M_impl._M_start, this->_M_impl._M_finish,
         __new_start, _M_get_Tp_allocator());
      }
    catch(...)
      {
        if (__destroy_from)
   std::_Destroy(__destroy_from, __destroy_from + __n,
          _M_get_Tp_allocator());
        _M_deallocate(__new_start, __len);
        throw;
      }
    std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
    _M_get_Tp_allocator());
  }
       ;
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_start + __size + __n;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }

  template<typename _Tp, typename _Alloc>
    bool
    vector<_Tp, _Alloc>::
    _M_shrink_to_fit()
    {
      if (capacity() == size())
 return false;
      ;
      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
    }


  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __pos, _InputIterator __first,
        _InputIterator __last, std::input_iterator_tag)
      {
 if (__pos == end())
   {
     for (; __first != __last; ++__first)
       insert(end(), *__first);
   }
 else if (__first != __last)
   {
     vector __tmp(__first, __last, _M_get_Tp_allocator());
     insert(__pos,
     std::make_move_iterator(__tmp.begin()),
     std::make_move_iterator(__tmp.end()));
   }
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     const size_type __n = std::distance(__first, __last);
     if (size_type(this->_M_impl._M_end_of_storage
     - this->_M_impl._M_finish) >= __n)
       {
  const size_type __elems_after = end() - __position;
  pointer __old_finish(this->_M_impl._M_finish);
  if (__elems_after > __n)
    {
      ;
      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
      this->_M_impl._M_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n;
      ;
      std::move_backward(__position.base(), __old_finish - __n, __old_finish)
                                          ;
      std::copy(__first, __last, __position);
    }
  else
    {
      _ForwardIterator __mid = __first;
      std::advance(__mid, __elems_after);
      ;
      std::__uninitialized_copy_a(__mid, __last,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __n - __elems_after;
      ;
      std::__uninitialized_move_a(__position.base(),
      __old_finish,
      this->_M_impl._M_finish,
      _M_get_Tp_allocator());
      this->_M_impl._M_finish += __elems_after;
      ;
      std::copy(__first, __mid, __position);
    }
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector::_M_range_insert");
  pointer __new_start(this->_M_allocate(__len));
  pointer __new_finish(__new_start);
  try
    {
      __new_finish
        = std::__uninitialized_move_if_noexcept_a
        (this->_M_impl._M_start, __position.base(),
         __new_start, _M_get_Tp_allocator());
      __new_finish
        = std::__uninitialized_copy_a(__first, __last,
          __new_finish,
          _M_get_Tp_allocator());
      __new_finish
        = std::__uninitialized_move_if_noexcept_a
        (__position.base(), this->_M_impl._M_finish,
         __new_finish, _M_get_Tp_allocator());
    }
  catch(...)
    {
      std::_Destroy(__new_start, __new_finish,
      _M_get_Tp_allocator());
      _M_deallocate(__new_start, __len);
      throw;
    }
  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
         _M_get_Tp_allocator());
  ;
  _M_deallocate(this->_M_impl._M_start,
         this->_M_impl._M_end_of_storage
         - this->_M_impl._M_start);
  this->_M_impl._M_start = __new_start;
  this->_M_impl._M_finish = __new_finish;
  this->_M_impl._M_end_of_storage = __new_start + __len;
       }
   }
      }



  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    _M_reallocate(size_type __n)
    {
      _Bit_pointer __q = this->_M_allocate(__n);
      iterator __start(std::__addressof(*__q), 0);
      iterator __finish(_M_copy_aligned(begin(), end(), __start));
      this->_M_deallocate();
      this->_M_impl._M_start = __start;
      this->_M_impl._M_finish = __finish;
      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
    }

  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, bool __x)
    {
      if (__n == 0)
 return;
      if (capacity() - size() >= __n)
 {
   std::copy_backward(__position, end(),
        this->_M_impl._M_finish + difference_type(__n));
   std::fill(__position, __position + difference_type(__n), __x);
   this->_M_impl._M_finish += difference_type(__n);
 }
      else
 {
   const size_type __len =
     _M_check_len(__n, "vector<bool>::_M_fill_insert");
   _Bit_pointer __q = this->_M_allocate(__len);
   iterator __start(std::__addressof(*__q), 0);
   iterator __i = _M_copy_aligned(begin(), __position, __start);
   std::fill(__i, __i + difference_type(__n), __x);
   iterator __finish = std::copy(__position, end(),
     __i + difference_type(__n));
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
   this->_M_impl._M_start = __start;
   this->_M_impl._M_finish = __finish;
 }
    }

  template<typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<bool, _Alloc>::
      _M_insert_range(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     size_type __n = std::distance(__first, __last);
     if (capacity() - size() >= __n)
       {
  std::copy_backward(__position, end(),
       this->_M_impl._M_finish
       + difference_type(__n));
  std::copy(__first, __last, __position);
  this->_M_impl._M_finish += difference_type(__n);
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector<bool>::_M_insert_range");
  _Bit_pointer __q = this->_M_allocate(__len);
  iterator __start(std::__addressof(*__q), 0);
  iterator __i = _M_copy_aligned(begin(), __position, __start);
  __i = std::copy(__first, __last, __i);
  iterator __finish = std::copy(__position, end(), __i);
  this->_M_deallocate();
  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
  this->_M_impl._M_start = __start;
  this->_M_impl._M_finish = __finish;
       }
   }
      }

  template<typename _Alloc>
    void
    vector<bool, _Alloc>::
    _M_insert_aux(iterator __position, bool __x)
    {
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
 {
   std::copy_backward(__position, this->_M_impl._M_finish,
        this->_M_impl._M_finish + 1);
   *__position = __x;
   ++this->_M_impl._M_finish;
 }
      else
 {
   const size_type __len =
     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
   _Bit_pointer __q = this->_M_allocate(__len);
   iterator __start(std::__addressof(*__q), 0);
   iterator __i = _M_copy_aligned(begin(), __position, __start);
   *__i++ = __x;
   iterator __finish = std::copy(__position, end(), __i);
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
   this->_M_impl._M_start = __start;
   this->_M_impl._M_finish = __finish;
 }
    }

  template<typename _Alloc>
    typename vector<bool, _Alloc>::iterator
    vector<bool, _Alloc>::
    _M_erase(iterator __position)
    {
      if (__position + 1 != end())
        std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      return __position;
    }

  template<typename _Alloc>
    typename vector<bool, _Alloc>::iterator
    vector<bool, _Alloc>::
    _M_erase(iterator __first, iterator __last)
    {
      if (__first != __last)
 _M_erase_at_end(std::copy(__last, end(), __first));
      return __first;
    }


  template<typename _Alloc>
    bool
    vector<bool, _Alloc>::
    _M_shrink_to_fit()
    {
      if (capacity() - size() < int(_S_word_bit))
 return false;
      try
 {
   _M_reallocate(size());
   return true;
 }
      catch(...)
 { return false; }
    }




}



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


  template<typename _Alloc>
    size_t
    hash<std::vector<bool, _Alloc>>::
    operator()(const std::vector<bool, _Alloc>& __b) const noexcept
    {
      size_t __hash = 0;
      using std::_S_word_bit;
      using std::_Bit_type;

      const size_t __words = __b.size() / _S_word_bit;
      if (__words)
 {
   const size_t __clength = __words * sizeof(_Bit_type);
   __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
 }

      const size_t __extrabits = __b.size() % _S_word_bit;
      if (__extrabits)
 {
   _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
   __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);

   const size_t __clength
     = (__extrabits + 8 - 1) / 8;
   if (__words)
     __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
   else
     __hash = std::_Hash_impl::hash(&__hiword, __clength);
 }

      return __hash;
    }


}
# 73 "/usr/include/c++/10/vector" 2 3







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

  namespace pmr {
    template<typename _Tp> class polymorphic_allocator;
    template<typename _Tp>
      using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>;
  }








}
# 63 "/usr/include/c++/10/functional" 2 3
# 72 "/usr/include/c++/10/functional" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 83 "/usr/include/c++/10/functional" 3
  template<typename _Callable, typename... _Args>
    inline invoke_result_t<_Callable, _Args...>
    invoke(_Callable&& __fn, _Args&&... __args)
    noexcept(is_nothrow_invocable_v<_Callable, _Args...>)
    {
      return std::__invoke(std::forward<_Callable>(__fn),
      std::forward<_Args>(__args)...);
    }


  template<typename _MemFunPtr,
    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
    class _Mem_fn_base
    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
    {
      using _Traits = _Mem_fn_traits<_MemFunPtr>;

      using _Arity = typename _Traits::__arity;
      using _Varargs = typename _Traits::__vararg;

      template<typename _Func, typename... _BoundArgs>
 friend struct _Bind_check_arity;

      _MemFunPtr _M_pmf;

    public:

      using result_type = typename _Traits::__result_type;

      explicit constexpr
      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }

      template<typename... _Args>

 auto
 operator()(_Args&&... __args) const
 noexcept(noexcept(
       std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
 -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
 { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
    };


  template<typename _MemObjPtr>
    class _Mem_fn_base<_MemObjPtr, false>
    {
      using _Arity = integral_constant<size_t, 0>;
      using _Varargs = false_type;

      template<typename _Func, typename... _BoundArgs>
 friend struct _Bind_check_arity;

      _MemObjPtr _M_pm;

    public:
      explicit constexpr
      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }

      template<typename _Tp>

 auto
 operator()(_Tp&& __obj) const
 noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
 -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
 { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
    };

  template<typename _MemberPointer>
    struct _Mem_fn;

  template<typename _Res, typename _Class>
    struct _Mem_fn<_Res _Class::*>
    : _Mem_fn_base<_Res _Class::*>
    {
      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
    };
# 167 "/usr/include/c++/10/functional" 3
  template<typename _Tp, typename _Class>
   
    inline _Mem_fn<_Tp _Class::*>
    mem_fn(_Tp _Class::* __pm) noexcept
    {
      return _Mem_fn<_Tp _Class::*>(__pm);
    }
# 183 "/usr/include/c++/10/functional" 3
  template<typename _Tp>
    struct is_bind_expression
    : public false_type { };
# 194 "/usr/include/c++/10/functional" 3
  template<typename _Tp>
    struct is_placeholder
    : public integral_constant<int, 0>
    { };


  template <typename _Tp> inline constexpr bool is_bind_expression_v
    = is_bind_expression<_Tp>::value;
  template <typename _Tp> inline constexpr int is_placeholder_v
    = is_placeholder<_Tp>::value;





  template<int _Num> struct _Placeholder { };





  namespace placeholders
  {




    extern const _Placeholder<1> _1;
    extern const _Placeholder<2> _2;
    extern const _Placeholder<3> _3;
    extern const _Placeholder<4> _4;
    extern const _Placeholder<5> _5;
    extern const _Placeholder<6> _6;
    extern const _Placeholder<7> _7;
    extern const _Placeholder<8> _8;
    extern const _Placeholder<9> _9;
    extern const _Placeholder<10> _10;
    extern const _Placeholder<11> _11;
    extern const _Placeholder<12> _12;
    extern const _Placeholder<13> _13;
    extern const _Placeholder<14> _14;
    extern const _Placeholder<15> _15;
    extern const _Placeholder<16> _16;
    extern const _Placeholder<17> _17;
    extern const _Placeholder<18> _18;
    extern const _Placeholder<19> _19;
    extern const _Placeholder<20> _20;
    extern const _Placeholder<21> _21;
    extern const _Placeholder<22> _22;
    extern const _Placeholder<23> _23;
    extern const _Placeholder<24> _24;
    extern const _Placeholder<25> _25;
    extern const _Placeholder<26> _26;
    extern const _Placeholder<27> _27;
    extern const _Placeholder<28> _28;
    extern const _Placeholder<29> _29;
  }






  template<int _Num>
    struct is_placeholder<_Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };

  template<int _Num>
    struct is_placeholder<const _Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };



  template<std::size_t __i, typename _Tuple>
    using _Safe_tuple_element_t
      = typename enable_if<(__i < tuple_size<_Tuple>::value),
      tuple_element<__i, _Tuple>>::type::type;
# 285 "/usr/include/c++/10/functional" 3
  template<typename _Arg,
    bool _IsBindExp = is_bind_expression<_Arg>::value,
    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
    class _Mu;






  template<typename _Tp>
    class _Mu<reference_wrapper<_Tp>, false, false>
    {
    public:




      template<typename _CVRef, typename _Tuple>

 _Tp&
 operator()(_CVRef& __arg, _Tuple&) const volatile
 { return __arg.get(); }
    };







  template<typename _Arg>
    class _Mu<_Arg, true, false>
    {
    public:
      template<typename _CVArg, typename... _Args>

 auto
 operator()(_CVArg& __arg,
     tuple<_Args...>& __tuple) const volatile
 -> decltype(__arg(declval<_Args>()...))
 {

   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
     _Indexes;
   return this->__call(__arg, __tuple, _Indexes());
 }

    private:


      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>

 auto
 __call(_CVArg& __arg, tuple<_Args...>& __tuple,
        const _Index_tuple<_Indexes...>&) const volatile
 -> decltype(__arg(declval<_Args>()...))
 {
   return __arg(std::get<_Indexes>(std::move(__tuple))...);
 }
    };






  template<typename _Arg>
    class _Mu<_Arg, false, true>
    {
    public:
      template<typename _Tuple>

 _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
 operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
 {
   return
     ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
 }
    };






  template<typename _Arg>
    class _Mu<_Arg, false, false>
    {
    public:
      template<typename _CVArg, typename _Tuple>

 _CVArg&&
 operator()(_CVArg&& __arg, _Tuple&) const volatile
 { return std::forward<_CVArg>(__arg); }
    };


  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }


  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(const volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }


  template<typename _Signature>
    struct _Bind;

   template<typename _Functor, typename... _Bound_args>
    class _Bind<_Functor(_Bound_args...)>
    : public _Weak_result_type<_Functor>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
 _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;


      template<typename _Result, typename... _Args, std::size_t... _Indexes>

 _Result
 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
 {
   return std::__invoke(_M_f,
       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
       );
 }


      template<typename _Result, typename... _Args, std::size_t... _Indexes>

 _Result
 __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
 {
   return std::__invoke(_M_f,
       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
       );
 }


      template<typename _Result, typename... _Args, std::size_t... _Indexes>
 _Result
 __call_v(tuple<_Args...>&& __args,
   _Index_tuple<_Indexes...>) volatile
 {
   return std::__invoke(_M_f,
       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
       );
 }


      template<typename _Result, typename... _Args, std::size_t... _Indexes>
 _Result
 __call_c_v(tuple<_Args...>&& __args,
     _Index_tuple<_Indexes...>) const volatile
 {
   return std::__invoke(_M_f,
       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
       );
 }

      template<typename _BoundArg, typename _CallArgs>
 using _Mu_type = decltype(
     _Mu<typename remove_cv<_BoundArg>::type>()(
       std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );

      template<typename _Fn, typename _CallArgs, typename... _BArgs>
 using _Res_type_impl
   = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type;

      template<typename _CallArgs>
 using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;

      template<typename _CallArgs>
 using __dependent = typename
   enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;

      template<typename _CallArgs, template<class> class __cv_quals>
 using _Res_type_cv = _Res_type_impl<
   typename __cv_quals<__dependent<_CallArgs>>::type,
   _CallArgs,
   typename __cv_quals<_Bound_args>::type...>;

     public:
      template<typename... _Args>
 explicit
 _Bind(const _Functor& __f, _Args&&... __args)
 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      template<typename... _Args>
 explicit
 _Bind(_Functor&& __f, _Args&&... __args)
 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      _Bind(const _Bind&) = default;
      _Bind(_Bind&&) = default;


      template<typename... _Args,
        typename _Result = _Res_type<tuple<_Args...>>>

 _Result
 operator()(_Args&&... __args)
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args,
        typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>

 _Result
 operator()(_Args&&... __args) const
 {
   return this->__call_c<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }
# 523 "/usr/include/c++/10/functional" 3
      template<typename... _Args,
        typename _Result = _Res_type_cv<tuple<_Args...>, add_volatile>>
 [[deprecated("std::bind does not support volatile in C++17")]]
 _Result
 operator()(_Args&&... __args) volatile
 {
   return this->__call_v<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args,
        typename _Result = _Res_type_cv<tuple<_Args...>, add_cv>>
 [[deprecated("std::bind does not support volatile in C++17")]]
 _Result
 operator()(_Args&&... __args) const volatile
 {
   return this->__call_c_v<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }
    };


  template<typename _Result, typename _Signature>
    struct _Bind_result;

  template<typename _Result, typename _Functor, typename... _Bound_args>
    class _Bind_result<_Result, _Functor(_Bound_args...)>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
 _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;


      template<typename _Res, typename... _Args, std::size_t... _Indexes>

 _Res
 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
 {
   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
        (std::get<_Indexes>(_M_bound_args), __args)...);
 }


      template<typename _Res, typename... _Args, std::size_t... _Indexes>

 _Res
 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
 {
   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
        (std::get<_Indexes>(_M_bound_args), __args)...);
 }


      template<typename _Res, typename... _Args, std::size_t... _Indexes>

 _Res
 __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
 {
   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
        (__volget<_Indexes>(_M_bound_args), __args)...);
 }


      template<typename _Res, typename... _Args, std::size_t... _Indexes>

 _Res
 __call(tuple<_Args...>&& __args,
        _Index_tuple<_Indexes...>) const volatile
 {
   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
        (__volget<_Indexes>(_M_bound_args), __args)...);
 }

    public:
      typedef _Result result_type;

      template<typename... _Args>
 explicit
 _Bind_result(const _Functor& __f, _Args&&... __args)
 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      template<typename... _Args>
 explicit
 _Bind_result(_Functor&& __f, _Args&&... __args)
 : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      _Bind_result(const _Bind_result&) = default;
      _Bind_result(_Bind_result&&) = default;


      template<typename... _Args>

 result_type
 operator()(_Args&&... __args)
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args>

 result_type
 operator()(_Args&&... __args) const
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args>
 [[deprecated("std::bind does not support volatile in C++17")]]
 result_type
 operator()(_Args&&... __args) volatile
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args>
 [[deprecated("std::bind does not support volatile in C++17")]]
 result_type
 operator()(_Args&&... __args) const volatile
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }
    };






  template<typename _Signature>
    struct is_bind_expression<_Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<const _Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<volatile _Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<const volatile _Bind<_Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<_Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
    : public true_type { };

  template<typename _Func, typename... _BoundArgs>
    struct _Bind_check_arity { };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Tp, typename _Class, typename... _BoundArgs>
    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
    {
      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
      static_assert(_Varargs::value
      ? sizeof...(_BoundArgs) >= _Arity::value + 1
      : sizeof...(_BoundArgs) == _Arity::value + 1,
      "Wrong number of arguments for pointer-to-member");
    };




  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;

  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
    struct _Bind_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __func_type;
      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
    };




  template<typename _Func, typename... _BoundArgs>
    struct _Bind_helper<true, _Func, _BoundArgs...>
    { };





  template<typename _Func, typename... _BoundArgs>
    inline typename
    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    {
      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
      return typename __helper_type::type(std::forward<_Func>(__f),
       std::forward<_BoundArgs>(__args)...);
    }

  template<typename _Result, typename _Func, typename... _BoundArgs>
    struct _Bindres_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __functor_type;
      typedef _Bind_result<_Result,
      __functor_type(typename decay<_BoundArgs>::type...)>
 type;
    };





  template<typename _Result, typename _Func, typename... _BoundArgs>
    inline
    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    {
      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
      return typename __helper_type::type(std::forward<_Func>(__f),
       std::forward<_BoundArgs>(__args)...);
    }
# 918 "/usr/include/c++/10/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;
# 952 "/usr/include/c++/10/functional" 3
      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_Fn &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); }
      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(__is_nothrow_invocable<_Fn const &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); }
      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(__is_nothrow_invocable<_Fn &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); }
      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothrow_invocable<_Fn const &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); }


    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 { };



  template<typename _Fn>
   
    inline auto
    not_fn(_Fn&& __fn)
    noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value)
    {
      return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
    }




  template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>>
    class default_searcher
    {
    public:
     
      default_searcher(_ForwardIterator1 __pat_first,
         _ForwardIterator1 __pat_last,
         _BinaryPredicate __pred = _BinaryPredicate())
      : _M_m(__pat_first, __pat_last, std::move(__pred))
      { }

      template<typename _ForwardIterator2>

 pair<_ForwardIterator2, _ForwardIterator2>
 operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const
 {
   _ForwardIterator2 __first_ret =
     std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m),
   std::get<2>(_M_m));
   auto __ret = std::make_pair(__first_ret, __first_ret);
   if (__ret.first != __last)
     std::advance(__ret.second, std::distance(std::get<0>(_M_m),
           std::get<1>(_M_m)));
   return __ret;
 }

    private:
      tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m;
    };

  template<typename _Key, typename _Tp, typename _Hash, typename _Pred>
    struct __boyer_moore_map_base
    {
      template<typename _RAIter>
 __boyer_moore_map_base(_RAIter __pat, size_t __patlen,
          _Hash&& __hf, _Pred&& __pred)
 : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) }
 {
   if (__patlen > 0)
     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
       _M_bad_char[__pat[__i]] = __patlen - 1 - __i;
 }

      using __diff_type = _Tp;

      __diff_type
      _M_lookup(_Key __key, __diff_type __not_found) const
      {
 auto __iter = _M_bad_char.find(__key);
 if (__iter == _M_bad_char.end())
   return __not_found;
 return __iter->second;
      }

      _Pred
      _M_pred() const { return _M_bad_char.key_eq(); }

      std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
    };

  template<typename _Tp, size_t _Len, typename _Pred>
    struct __boyer_moore_array_base
    {
      template<typename _RAIter, typename _Unused>
 __boyer_moore_array_base(_RAIter __pat, size_t __patlen,
     _Unused&&, _Pred&& __pred)
 : _M_bad_char{ std::array<_Tp, _Len>{}, std::move(__pred) }
 {
   std::get<0>(_M_bad_char).fill(__patlen);
   if (__patlen > 0)
     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
       {
  auto __ch = __pat[__i];
  using _UCh = make_unsigned_t<decltype(__ch)>;
  auto __uch = static_cast<_UCh>(__ch);
  std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i;
       }
 }

      using __diff_type = _Tp;

      template<typename _Key>
 __diff_type
 _M_lookup(_Key __key, __diff_type __not_found) const
 {
   auto __ukey = static_cast<make_unsigned_t<_Key>>(__key);
   if (__ukey >= _Len)
     return __not_found;
   return std::get<0>(_M_bad_char)[__ukey];
 }

      const _Pred&
      _M_pred() const { return std::get<1>(_M_bad_char); }

      tuple<std::array<_Tp, _Len>, _Pred> _M_bad_char;
    };



  template<typename _RAIter, typename _Hash, typename _Pred,
           typename _Val = typename iterator_traits<_RAIter>::value_type,
    typename _Diff = typename iterator_traits<_RAIter>::difference_type>
    using __boyer_moore_base_t
      = conditional_t<__is_byte_like<_Val, _Pred>::value,
        __boyer_moore_array_base<_Diff, 256, _Pred>,
        __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;

  template<typename _RAIter, typename _Hash
      = hash<typename iterator_traits<_RAIter>::value_type>,
    typename _BinaryPredicate = equal_to<>>
    class boyer_moore_searcher
    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
    {
      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
      using typename _Base::__diff_type;

    public:
      boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last,
      _Hash __hf = _Hash(),
      _BinaryPredicate __pred = _BinaryPredicate());

      template<typename _RandomAccessIterator2>
        pair<_RandomAccessIterator2, _RandomAccessIterator2>
 operator()(_RandomAccessIterator2 __first,
     _RandomAccessIterator2 __last) const;

    private:
      bool
      _M_is_prefix(_RAIter __word, __diff_type __len,
     __diff_type __pos)
      {
 const auto& __pred = this->_M_pred();
 __diff_type __suffixlen = __len - __pos;
 for (__diff_type __i = 0; __i < __suffixlen; ++__i)
   if (!__pred(__word[__i], __word[__pos + __i]))
     return false;
 return true;
      }

      __diff_type
      _M_suffix_length(_RAIter __word, __diff_type __len,
         __diff_type __pos)
      {
 const auto& __pred = this->_M_pred();
 __diff_type __i = 0;
 while (__pred(__word[__pos - __i], __word[__len - 1 - __i])
        && __i < __pos)
   {
     ++__i;
   }
 return __i;
      }

      template<typename _Tp>
 __diff_type
 _M_bad_char_shift(_Tp __c) const
 { return this->_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
      std::vector<__diff_type> _M_good_suffix;
    };

  template<typename _RAIter, typename _Hash
      = hash<typename iterator_traits<_RAIter>::value_type>,
    typename _BinaryPredicate = equal_to<>>
    class boyer_moore_horspool_searcher
    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
    {
      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
      using typename _Base::__diff_type;

    public:
      boyer_moore_horspool_searcher(_RAIter __pat,
        _RAIter __pat_end,
        _Hash __hf = _Hash(),
        _BinaryPredicate __pred
        = _BinaryPredicate())
      : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
 _M_pat(__pat), _M_pat_end(__pat_end)
      { }

      template<typename _RandomAccessIterator2>
        pair<_RandomAccessIterator2, _RandomAccessIterator2>
 operator()(_RandomAccessIterator2 __first,
     _RandomAccessIterator2 __last) const
 {
   const auto& __pred = this->_M_pred();
   auto __patlen = _M_pat_end - _M_pat;
   if (__patlen == 0)
     return std::make_pair(__first, __first);
   auto __len = __last - __first;
   while (__len >= __patlen)
     {
       for (auto __scan = __patlen - 1;
     __pred(__first[__scan], _M_pat[__scan]); --__scan)
  if (__scan == 0)
    return std::make_pair(__first, __first + __patlen);
       auto __shift = _M_bad_char_shift(__first[__patlen - 1]);
       __len -= __shift;
       __first += __shift;
     }
   return std::make_pair(__last, __last);
 }

    private:
      template<typename _Tp>
 __diff_type
 _M_bad_char_shift(_Tp __c) const
 { return this->_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
    };

  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
    boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end,
    _Hash __hf, _BinaryPredicate __pred)
    : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
      _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat)
    {
      auto __patlen = __pat_end - __pat;
      if (__patlen == 0)
 return;
      __diff_type __last_prefix = __patlen - 1;
      for (__diff_type __p = __patlen - 1; __p >= 0; --__p)
 {
   if (_M_is_prefix(__pat, __patlen, __p + 1))
     __last_prefix = __p + 1;
   _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p);
 }
      for (__diff_type __p = 0; __p < __patlen - 1; ++__p)
 {
   auto __slen = _M_suffix_length(__pat, __patlen, __p);
   auto __pos = __patlen - 1 - __slen;
   if (!__pred(__pat[__p - __slen], __pat[__pos]))
     _M_good_suffix[__pos] = __patlen - 1 - __p + __slen;
 }
    }

  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
  template<typename _RandomAccessIterator2>
    pair<_RandomAccessIterator2, _RandomAccessIterator2>
    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
    operator()(_RandomAccessIterator2 __first,
        _RandomAccessIterator2 __last) const
    {
      auto __patlen = _M_pat_end - _M_pat;
      if (__patlen == 0)
 return std::make_pair(__first, __first);
      const auto& __pred = this->_M_pred();
      __diff_type __i = __patlen - 1;
      auto __stringlen = __last - __first;
      while (__i < __stringlen)
 {
   __diff_type __j = __patlen - 1;
   while (__j >= 0 && __pred(__first[__i], _M_pat[__j]))
     {
       --__i;
       --__j;
     }
   if (__j < 0)
     {
       const auto __match = __first + __i + 1;
       return std::make_pair(__match, __match + __patlen);
     }
   __i += std::max(_M_bad_char_shift(__first[__i]),
     _M_good_suffix[__j]);
 }
      return std::make_pair(__last, __last);
    }





}
# 14 "/usr/include/c++/10/pstl/glue_algorithm_defs.h" 2 3

# 1 "/usr/include/c++/10/pstl/execution_defs.h" 1 3
# 15 "/usr/include/c++/10/pstl/execution_defs.h" 3
namespace __pstl
{
namespace execution
{
inline namespace v1
{


class sequenced_policy
{
  public:

    static constexpr std::false_type
    __allow_unsequenced()
    {
        return std::false_type{};
    }
    static constexpr std::false_type
    __allow_vector()
    {
        return std::false_type{};
    }
    static constexpr std::false_type
    __allow_parallel()
    {
        return std::false_type{};
    }
};


class parallel_policy
{
  public:

    static constexpr std::false_type
    __allow_unsequenced()
    {
        return std::false_type{};
    }
    static constexpr std::false_type
    __allow_vector()
    {
        return std::false_type{};
    }
    static constexpr std::true_type
    __allow_parallel()
    {
        return std::true_type{};
    }
};


class parallel_unsequenced_policy
{
  public:

    static constexpr std::true_type
    __allow_unsequenced()
    {
        return std::true_type{};
    }
    static constexpr std::true_type
    __allow_vector()
    {
        return std::true_type{};
    }
    static constexpr std::true_type
    __allow_parallel()
    {
        return std::true_type{};
    }
};

class unsequenced_policy
{
  public:

    static constexpr std::true_type
    __allow_unsequenced()
    {
        return std::true_type{};
    }
    static constexpr std::true_type
    __allow_vector()
    {
        return std::true_type{};
    }
    static constexpr std::false_type
    __allow_parallel()
    {
        return std::false_type{};
    }
};


constexpr sequenced_policy seq{};
constexpr parallel_policy par{};
constexpr parallel_unsequenced_policy par_unseq{};
constexpr unsequenced_policy unseq{};


template <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;





}

}
# 16 "/usr/include/c++/10/pstl/glue_algorithm_defs.h" 2 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);

}
# 72 "/usr/include/c++/10/algorithm" 2 3
# 6 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/user.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/select_compiler_config.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/compiler/gcc.hpp" 1 3 4
# 165 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/compiler/gcc.hpp" 3 4
# 1 "/usr/include/c++/10/cstddef" 1 3 4
# 42 "/usr/include/c++/10/cstddef" 3 4
       
# 43 "/usr/include/c++/10/cstddef" 3







# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 51 "/usr/include/c++/10/cstddef" 2 3

extern "C++"
{

namespace std
{

  using ::max_align_t;
}



namespace std
{




  enum class byte : unsigned char {};

  template<typename _IntegerType> struct __byte_operand { };
  template<> struct __byte_operand<bool> { using __type = byte; };
  template<> struct __byte_operand<char> { using __type = byte; };
  template<> struct __byte_operand<signed char> { using __type = byte; };
  template<> struct __byte_operand<unsigned char> { using __type = byte; };

  template<> struct __byte_operand<wchar_t> { using __type = byte; };




  template<> struct __byte_operand<char16_t> { using __type = byte; };
  template<> struct __byte_operand<char32_t> { using __type = byte; };
  template<> struct __byte_operand<short> { using __type = byte; };
  template<> struct __byte_operand<unsigned short> { using __type = byte; };
  template<> struct __byte_operand<int> { using __type = byte; };
  template<> struct __byte_operand<unsigned int> { using __type = byte; };
  template<> struct __byte_operand<long> { using __type = byte; };
  template<> struct __byte_operand<unsigned long> { using __type = byte; };
  template<> struct __byte_operand<long long> { using __type = byte; };
  template<> struct __byte_operand<unsigned long long> { using __type = byte; };
# 110 "/usr/include/c++/10/cstddef" 3
  template<typename _IntegerType>
    struct __byte_operand<const _IntegerType>
    : __byte_operand<_IntegerType> { };
  template<typename _IntegerType>
    struct __byte_operand<volatile _IntegerType>
    : __byte_operand<_IntegerType> { };
  template<typename _IntegerType>
    struct __byte_operand<const volatile _IntegerType>
    : __byte_operand<_IntegerType> { };

  template<typename _IntegerType>
    using __byte_op_t = typename __byte_operand<_IntegerType>::__type;

  template<typename _IntegerType>
    constexpr __byte_op_t<_IntegerType>
    operator<<(byte __b, _IntegerType __shift) noexcept
    { return (byte)(unsigned char)((unsigned)__b << __shift); }

  template<typename _IntegerType>
    constexpr __byte_op_t<_IntegerType>
    operator>>(byte __b, _IntegerType __shift) noexcept
    { return (byte)(unsigned char)((unsigned)__b >> __shift); }

  constexpr byte
  operator|(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); }

  constexpr byte
  operator&(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); }

  constexpr byte
  operator^(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); }

  constexpr byte
  operator~(byte __b) noexcept
  { return (byte)(unsigned char)~(unsigned)__b; }

  template<typename _IntegerType>
    constexpr __byte_op_t<_IntegerType>&
    operator<<=(byte& __b, _IntegerType __shift) noexcept
    { return __b = __b << __shift; }

  template<typename _IntegerType>
    constexpr __byte_op_t<_IntegerType>&
    operator>>=(byte& __b, _IntegerType __shift) noexcept
    { return __b = __b >> __shift; }

  constexpr byte&
  operator|=(byte& __l, byte __r) noexcept
  { return __l = __l | __r; }

  constexpr byte&
  operator&=(byte& __l, byte __r) noexcept
  { return __l = __l & __r; }

  constexpr byte&
  operator^=(byte& __l, byte __r) noexcept
  { return __l = __l ^ __r; }

  template<typename _IntegerType>
    constexpr _IntegerType
    to_integer(__byte_op_t<_IntegerType> __b) noexcept
    { return _IntegerType(__b); }


}

}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/compiler/gcc.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/select_stdlib_config.hpp" 1 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/stdlib/libstdcpp3.hpp" 1 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
# 226 "/usr/include/unistd.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 227 "/usr/include/unistd.h" 2 3 4
# 267 "/usr/include/unistd.h" 3 4
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) throw () __attribute__ ((__nonnull__ (1)));




extern int euidaccess (const char *__name, int __type)
     throw () __attribute__ ((__nonnull__ (1)));


extern int eaccess (const char *__name, int __type)
     throw () __attribute__ ((__nonnull__ (1)));






extern int faccessat (int __fd, const char *__file, int __type, int __flag)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
# 337 "/usr/include/unistd.h" 3 4
extern __off64_t lseek (int __fd, __off64_t __offset, int __whence) throw () __asm__ ("" "lseek64")

             ;





extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     throw ();






extern int close (int __fd);






extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__ ((__warn_unused_result__));





extern ssize_t write (int __fd, const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
# 388 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")

               __attribute__ ((__warn_unused_result__));
extern ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64")

                __attribute__ ((__warn_unused_result__));
# 404 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset) __attribute__ ((__warn_unused_result__));


extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
    __off64_t __offset) __attribute__ ((__warn_unused_result__));







extern int pipe (int __pipedes[2]) throw () __attribute__ ((__warn_unused_result__));




extern int pipe2 (int __pipedes[2], int __flags) throw () __attribute__ ((__warn_unused_result__));
# 432 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 444 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);







extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     throw ();






extern int usleep (__useconds_t __useconds);
# 469 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () __attribute__ ((__warn_unused_result__));




extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));






extern int fchownat (int __fd, const char *__file, __uid_t __owner,
       __gid_t __group, int __flag)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));



extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern int fchdir (int __fd) throw () __attribute__ ((__warn_unused_result__));
# 511 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw () __attribute__ ((__warn_unused_result__));





extern char *get_current_dir_name (void) throw ();







extern char *getwd (char *__buf)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));




extern int dup (int __fd) throw () __attribute__ ((__warn_unused_result__));


extern int dup2 (int __fd, int __fd2) throw ();




extern int dup3 (int __fd, int __fd2, int __flags) throw ();



extern char **__environ;

extern char **environ;





extern int execve (const char *__path, char *const __argv[],
     char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));




extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
     throw () __attribute__ ((__nonnull__ (2)));




extern int execv (const char *__path, char *const __argv[])
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int execle (const char *__path, const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int execl (const char *__path, const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int execvp (const char *__file, char *const __argv[])
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int execlp (const char *__file, const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int execvpe (const char *__file, char *const __argv[],
      char *const __envp[])
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern int nice (int __inc) throw () __attribute__ ((__warn_unused_result__));




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

  };


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

  };
# 610 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (const char *__path, int __name)
     throw () __attribute__ ((__nonnull__ (1)));


extern long int fpathconf (int __fd, int __name) throw ();


extern long int sysconf (int __name) throw ();



extern size_t confstr (int __name, char *__buf, size_t __len) throw ();




extern __pid_t getpid (void) throw ();


extern __pid_t getppid (void) throw ();


extern __pid_t getpgrp (void) throw ();


extern __pid_t __getpgid (__pid_t __pid) throw ();

extern __pid_t getpgid (__pid_t __pid) throw ();






extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
# 660 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();






extern __pid_t setsid (void) throw ();



extern __pid_t getsid (__pid_t __pid) throw ();



extern __uid_t getuid (void) throw ();


extern __uid_t geteuid (void) throw ();


extern __gid_t getgid (void) throw ();


extern __gid_t getegid (void) throw ();




extern int getgroups (int __size, __gid_t __list[]) throw () __attribute__ ((__warn_unused_result__));



extern int group_member (__gid_t __gid) throw ();






extern int setuid (__uid_t __uid) throw () __attribute__ ((__warn_unused_result__));




extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () __attribute__ ((__warn_unused_result__));




extern int seteuid (__uid_t __uid) throw () __attribute__ ((__warn_unused_result__));






extern int setgid (__gid_t __gid) throw () __attribute__ ((__warn_unused_result__));




extern int setregid (__gid_t __rgid, __gid_t __egid) throw () __attribute__ ((__warn_unused_result__));




extern int setegid (__gid_t __gid) throw () __attribute__ ((__warn_unused_result__));





extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
     throw ();



extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
     throw ();



extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
     throw () __attribute__ ((__warn_unused_result__));



extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
     throw () __attribute__ ((__warn_unused_result__));






extern __pid_t fork (void) throw ();







extern __pid_t vfork (void) throw ();





extern char *ttyname (int __fd) throw ();



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));



extern int isatty (int __fd) throw ();




extern int ttyslot (void) throw ();




extern int link (const char *__from, const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));




extern int linkat (int __fromfd, const char *__from, int __tofd,
     const char *__to, int __flags)
     throw () __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));




extern int symlink (const char *__from, const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));




extern ssize_t readlink (const char *__restrict __path,
    char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));




extern int symlinkat (const char *__from, int __tofd,
        const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));


extern ssize_t readlinkat (int __fd, const char *__restrict __path,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));



extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));



extern int unlinkat (int __fd, const char *__name, int __flag)
     throw () __attribute__ ((__nonnull__ (2)));



extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));



extern __pid_t tcgetpgrp (int __fd) throw ();


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();






extern char *getlogin (void);







extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));




extern int setlogin (const char *__name) throw () __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)
       throw () __attribute__ ((__nonnull__ (2, 3)));

}
# 28 "/usr/include/bits/getopt_posix.h" 2 3 4

extern "C" {
# 49 "/usr/include/bits/getopt_posix.h" 3 4
}
# 870 "/usr/include/unistd.h" 2 3 4







extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));






extern int sethostname (const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern int sethostid (long int __id) throw () __attribute__ ((__warn_unused_result__));





extern int getdomainname (char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int setdomainname (const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int vhangup (void) throw ();


extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));







extern int profil (unsigned short int *__sample_buffer, size_t __size,
     size_t __offset, unsigned int __scale)
     throw () __attribute__ ((__nonnull__ (1)));





extern int acct (const char *__name) throw ();



extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();





extern int daemon (int __nochdir, int __noclose) throw () __attribute__ ((__warn_unused_result__));






extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));



extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));







extern int fsync (int __fd);





extern int syncfs (int __fd) throw ();






extern long int gethostid (void);


extern void sync (void) throw ();





extern int getpagesize (void) throw () __attribute__ ((__const__));




extern int getdtablesize (void) throw ();
# 995 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off64_t __length) throw () __asm__ ("" "truncate64")

                  __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int truncate64 (const char *__file, __off64_t __length)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 1017 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off64_t __length) throw () __asm__ ("" "ftruncate64")
                   __attribute__ ((__warn_unused_result__));





extern int ftruncate64 (int __fd, __off64_t __length) throw () __attribute__ ((__warn_unused_result__));
# 1035 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () __attribute__ ((__warn_unused_result__));





extern void *sbrk (intptr_t __delta) throw ();
# 1056 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 1082 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off64_t __len) __asm__ ("" "lockf64")
                  __attribute__ ((__warn_unused_result__));





extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
# 1107 "/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);
# 1124 "/usr/include/unistd.h" 3 4
extern char *crypt (const char *__key, const char *__salt)
     throw () __attribute__ ((__nonnull__ (1, 2)));







extern void swab (const void *__restrict __from, void *__restrict __to,
    ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
# 1161 "/usr/include/unistd.h" 3 4
int getentropy (void *__buffer, size_t __length) __attribute__ ((__warn_unused_result__));




# 1 "/usr/include/bits/unistd.h" 1 3 4
# 23 "/usr/include/bits/unistd.h" 3 4
extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
      size_t __buflen) __attribute__ ((__warn_unused_result__));
extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
                               __attribute__ ((__warn_unused_result__));
extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
read (int __fd, void *__buf, size_t __nbytes)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));

      if (__nbytes > __builtin_object_size (__buf, 0))
 return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
    }
  return __read_alias (__fd, __buf, __nbytes);
}


extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")

                                 __attribute__ ((__warn_unused_result__));
extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")

                                     __attribute__ ((__warn_unused_result__));
extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
                                  ;
extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")



     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
                                  ;
# 86 "/usr/include/bits/unistd.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));

      if ( __nbytes > __builtin_object_size (__buf, 0))
 return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
       __builtin_object_size (__buf, 0));
    }

  return __pread64_alias (__fd, __buf, __nbytes, __offset);
}



extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__nbytes))
 return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));

      if ( __nbytes > __builtin_object_size (__buf, 0))
 return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
       __builtin_object_size (__buf, 0));
    }

  return __pread64_alias (__fd, __buf, __nbytes, __offset);
}




extern ssize_t __readlink_chk (const char *__restrict __path,
          char *__restrict __buf, size_t __len,
          size_t __buflen)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_alias (const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlink")


     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlink_chk_warn (const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlink_chk")



     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
                                         ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
__attribute__ ((__leaf__)) readlink (const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()

{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if ( __len > __builtin_object_size (__buf, 2 > 1))
 return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
    }
  return __readlink_alias (__path, __buf, __len);
}



extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path,
     char *__restrict __buf, size_t __len,
     size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_alias (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlinkat")



     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
extern ssize_t __readlinkat_chk_warn (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlinkat_chk")



     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))

                ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
__attribute__ ((__leaf__)) readlinkat (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()

{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if (__len > __builtin_object_size (__buf, 2 > 1))
 return __readlinkat_chk_warn (__fd, __path, __buf, __len,
          __builtin_object_size (__buf, 2 > 1));
    }
  return __readlinkat_alias (__fd, __path, __buf, __len);
}


extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
     throw () __attribute__ ((__warn_unused_result__));
extern char *__getcwd_alias (char *__buf, size_t __size) throw () __asm__ ("" "getcwd")
                                              __attribute__ ((__warn_unused_result__));
extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) throw () __asm__ ("" "__getcwd_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
                              ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__leaf__)) getcwd (char *__buf, size_t __size) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size))
 return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));

      if (__size > __builtin_object_size (__buf, 2 > 1))
 return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
    }
  return __getcwd_alias (__buf, __size);
}


extern char *__getwd_chk (char *__buf, size_t buflen)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern char *__getwd_warn (char *__buf) throw () __asm__ ("" "getwd")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
                                         ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
__attribute__ ((__leaf__)) getwd (char *__buf) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
  return __getwd_warn (__buf);
}


extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
        size_t __buflen) throw ();
extern size_t __confstr_alias (int __name, char *__buf, size_t __len) throw () __asm__ ("" "confstr")
                             ;
extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__confstr_chk")


     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) confstr (int __name, char *__buf, size_t __len) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));

      if (__builtin_object_size (__buf, 2 > 1) < __len)
 return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
    }
  return __confstr_alias (__name, __buf, __len);
}


extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
     throw () __attribute__ ((__warn_unused_result__));
extern int __getgroups_alias (int __size, __gid_t __list[]) throw () __asm__ ("" "getgroups")
                 __attribute__ ((__warn_unused_result__));
extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) throw () __asm__ ("" "__getgroups_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
                                           ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) getgroups (int __size, __gid_t __list[]) throw ()
{
  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size) || __size < 0)
 return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));

      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
 return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
    }
  return __getgroups_alias (__size, __list);
}


extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ttyname_r")

     __attribute__ ((__nonnull__ (2)));
extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ttyname_r_chk")


     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) ttyname_r (int __fd, char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __ttyname_r_alias (__fd, __buf, __buflen);
}



extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
     __attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
                     __attribute__ ((__nonnull__ (1)));
extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")


     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
getlogin_r (char *__buf, size_t __buflen)
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __getlogin_r_alias (__buf, __buflen);
}




extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
     throw () __attribute__ ((__nonnull__ (1)));
extern int __gethostname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "gethostname")
                   __attribute__ ((__nonnull__ (1)));
extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__gethostname_chk")


     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
                                  ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) gethostname (char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __gethostname_alias (__buf, __buflen);
}




extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "getdomainname")

                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__getdomainname_chk")


     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))

                    ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) getdomainname (char *__buf, size_t __buflen) throw ()
{
  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__buflen))
 return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));

      if (__buflen > __builtin_object_size (__buf, 2 > 1))
 return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
    }
  return __getdomainname_alias (__buf, __buflen);
}
# 1167 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/unistd_ext.h" 1 3 4
# 34 "/usr/include/bits/unistd_ext.h" 3 4
extern __pid_t gettid (void) throw ();
# 1171 "/usr/include/unistd.h" 2 3 4

}
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/stdlib/libstdcpp3.hpp" 2 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/select_platform_config.hpp" 1 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/platform/linux.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/platform/linux.hpp" 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/platform/linux.hpp" 2 3 4
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/platform/linux.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/posix_features.hpp" 1 3 4
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/platform/linux.hpp" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/suffix.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/suffix.hpp" 3 4
       
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/suffix.hpp" 3
# 484 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;




}
# 543 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/suffix.hpp" 3
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/helper_macros.hpp" 1 3 4
# 544 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/detail/suffix.hpp" 2 3
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config.hpp" 2 3 4


       
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/workaround.hpp" 1 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/workaround.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/workaround.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view_fwd.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view_fwd.hpp" 3 4
# 1 "/usr/include/c++/10/string" 1 3 4
# 36 "/usr/include/c++/10/string" 3 4
       
# 37 "/usr/include/c++/10/string" 3


# 1 "/usr/include/c++/10/bits/stringfwd.h" 1 3
# 37 "/usr/include/c++/10/bits/stringfwd.h" 3
       
# 38 "/usr/include/c++/10/bits/stringfwd.h" 3




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








  template<class _CharT>
    struct char_traits;

  template<> struct char_traits<char>;


  template<> struct char_traits<wchar_t>;







  template<> struct char_traits<char16_t>;
  template<> struct char_traits<char32_t>;


namespace __cxx11 {

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_string;

}


  typedef basic_string<char> string;



  typedef basic_string<wchar_t> wstring;
# 93 "/usr/include/c++/10/bits/stringfwd.h" 3
  typedef basic_string<char16_t> u16string;


  typedef basic_string<char32_t> u32string;





}
# 40 "/usr/include/c++/10/string" 2 3
# 1 "/usr/include/c++/10/bits/char_traits.h" 1 3
# 37 "/usr/include/c++/10/bits/char_traits.h" 3
       
# 38 "/usr/include/c++/10/bits/char_traits.h" 3


# 1 "/usr/include/c++/10/bits/postypes.h" 1 3
# 38 "/usr/include/c++/10/bits/postypes.h" 3
       
# 39 "/usr/include/c++/10/bits/postypes.h" 3

# 1 "/usr/include/c++/10/cwchar" 1 3
# 39 "/usr/include/c++/10/cwchar" 3
       
# 40 "/usr/include/c++/10/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 27 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/wchar.h" 2 3 4







# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 36 "/usr/include/wchar.h" 2 3 4


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 39 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 41 "/usr/include/wchar.h" 2 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;
# 42 "/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;
# 43 "/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;
# 44 "/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;
# 47 "/usr/include/wchar.h" 2 3 4
# 79 "/usr/include/wchar.h" 3 4
extern "C" {



struct tm;



extern wchar_t *wcscpy (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern wchar_t *wcscat (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern wchar_t *wcsncat (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();


extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
   size_t __n) throw ();



extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
    locale_t __loc) throw ();

extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
     size_t __n, locale_t __loc) throw ();




extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();



extern size_t wcsxfrm (wchar_t *__restrict __s1,
         const wchar_t *__restrict __s2, size_t __n) throw ();







extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
        locale_t __loc) throw ();




extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
    size_t __n, locale_t __loc) throw ();


extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));




extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcschr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcschr") __attribute__ ((__pure__));






extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
# 181 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
     throw () __attribute__ ((__pure__));




extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
     throw () __attribute__ ((__pure__));


extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
     throw () __attribute__ ((__pure__));


extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
         const wchar_t *__accept)
     throw () __asm ("wcspbrk") __attribute__ ((__pure__));






extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
     throw () __asm ("wcsstr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
        const wchar_t *__needle)
     throw () __asm ("wcsstr") __attribute__ ((__pure__));






extern wchar_t *wcstok (wchar_t *__restrict __s,
   const wchar_t *__restrict __delim,
   wchar_t **__restrict __ptr) throw ();


extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));




extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
     throw () __asm ("wcswcs") __attribute__ ((__pure__));
extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
        const wchar_t *__needle)
     throw () __asm ("wcswcs") __attribute__ ((__pure__));
# 240 "/usr/include/wchar.h" 3 4
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
     throw () __attribute__ ((__pure__));





extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
     throw () __asm ("wmemchr") __attribute__ ((__pure__));
extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
         size_t __n)
     throw () __asm ("wmemchr") __attribute__ ((__pure__));






extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
    const wchar_t *__restrict __s2, size_t __n) throw ();



extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
     throw ();


extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();




extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
     const wchar_t *__restrict __s2, size_t __n)
     throw ();





extern wint_t btowc (int __c) throw ();



extern int wctob (wint_t __c) throw ();



extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));



extern size_t mbrtowc (wchar_t *__restrict __pwc,
         const char *__restrict __s, size_t __n,
         mbstate_t *__restrict __p) throw ();


extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
         mbstate_t *__restrict __ps) throw ();


extern size_t __mbrlen (const char *__restrict __s, size_t __n,
   mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
        mbstate_t *__restrict __ps) throw ();







extern wint_t __btowc_alias (int __c) __asm ("btowc");
extern __inline __attribute__ ((__gnu_inline__)) wint_t
__attribute__ ((__leaf__)) btowc (int __c) throw ()
{ 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
__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
   ? (int) __wc : __wctob_alias (__wc)); }

extern __inline __attribute__ ((__gnu_inline__)) size_t
__attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()

{ 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) throw ();



extern size_t wcsrtombs (char *__restrict __dst,
    const wchar_t **__restrict __src, size_t __len,
    mbstate_t *__restrict __ps) throw ();





extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
     const char **__restrict __src, size_t __nmc,
     size_t __len, mbstate_t *__restrict __ps) throw ();



extern size_t wcsnrtombs (char *__restrict __dst,
     const wchar_t **__restrict __src,
     size_t __nwc, size_t __len,
     mbstate_t *__restrict __ps) throw ();






extern int wcwidth (wchar_t __c) throw ();



extern int wcswidth (const wchar_t *__s, size_t __n) throw ();





extern double wcstod (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr) throw ();



extern float wcstof (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) throw ();
# 396 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr) throw ();



extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr) throw ();



extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) throw ();



extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) throw ();



extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) throw ();
# 428 "/usr/include/wchar.h" 3 4
extern long int wcstol (const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, int __base) throw ();



extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
      wchar_t **__restrict __endptr, int __base)
     throw ();




__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr,
     int __base) throw ();





__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr, int __base)
     throw ();



__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
           wchar_t **__restrict __endptr,
           int __base) throw ();






extern long int wcstol_l (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr, int __base,
     locale_t __loc) throw ();

extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr,
        int __base, locale_t __loc) throw ();

__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
    wchar_t **__restrict __endptr,
    int __base, locale_t __loc) throw ();

__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       int __base, locale_t __loc)
     throw ();

extern double wcstod_l (const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, locale_t __loc)
     throw ();

extern float wcstof_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, locale_t __loc)
     throw ();

extern long double wcstold_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) throw ();
# 511 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       locale_t __loc) throw ();



extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       locale_t __loc) throw ();



extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) throw ();



extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) throw ();



extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) throw ();
# 551 "/usr/include/wchar.h" 3 4
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src) throw ();



extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     throw ();
# 567 "/usr/include/wchar.h" 3 4
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();





extern int fwide (__FILE *__fp, int __mode) throw ();






extern int fwprintf (__FILE *__restrict __stream,
       const wchar_t *__restrict __format, ...)
                                                           ;




extern int wprintf (const wchar_t *__restrict __format, ...)
                                                           ;

extern int swprintf (wchar_t *__restrict __s, size_t __n,
       const wchar_t *__restrict __format, ...)
     throw () ;





extern int vfwprintf (__FILE *__restrict __s,
        const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
                                                           ;




extern int vwprintf (const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                           ;


extern int vswprintf (wchar_t *__restrict __s, size_t __n,
        const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
     throw () ;






extern int fwscanf (__FILE *__restrict __stream,
      const wchar_t *__restrict __format, ...)
                                                          ;




extern int wscanf (const wchar_t *__restrict __format, ...)
                                                          ;

extern int swscanf (const wchar_t *__restrict __s,
      const wchar_t *__restrict __format, ...)
     throw () ;






extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_fwscanf")


                                                          ;
extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_wscanf")

                                                          ;
extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) throw () __asm__ ("" "__isoc99_swscanf")


                                                          ;
# 671 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s,
       const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                          ;




extern int vwscanf (const wchar_t *__restrict __format,
      __gnuc_va_list __arg)
                                                          ;

extern int vswscanf (const wchar_t *__restrict __s,
       const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
     throw () ;






extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf")


                                                          ;
extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vwscanf")

                                                          ;
extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vswscanf")


                                                          ;
# 726 "/usr/include/wchar.h" 3 4
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);





extern wint_t getwchar (void);






extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);





extern wint_t putwchar (wchar_t __wc);







extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
   __FILE *__restrict __stream);





extern int fputws (const wchar_t *__restrict __ws,
     __FILE *__restrict __stream);






extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
# 781 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);







extern wint_t fgetwc_unlocked (__FILE *__stream);







extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
# 807 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 817 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
     __FILE *__restrict __stream);







extern int fputws_unlocked (const wchar_t *__restrict __ws,
       __FILE *__restrict __stream);






extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
   const wchar_t *__restrict __format,
   const struct tm *__restrict __tp) throw ();




extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
     const wchar_t *__restrict __format,
     const struct tm *__restrict __tp,
     locale_t __loc) throw ();




# 1 "/usr/include/bits/wchar2.h" 1 3 4
# 24 "/usr/include/bits/wchar2.h" 3 4
extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
          const wchar_t *__restrict __s2, size_t __n,
          size_t __ns1) throw ();
extern wchar_t *__wmemcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmemcpy")


            ;
extern wchar_t *__wmemcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemcpy_chk")



     __attribute__((__warning__ ("wmemcpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ()

{
  if (__builtin_object_size (__s1, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmemcpy_chk (__s1, __s2, __n,
         __builtin_object_size (__s1, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
 return __wmemcpy_chk_warn (__s1, __s2, __n,
       __builtin_object_size (__s1, 0) / sizeof (wchar_t));
    }
  return __wmemcpy_alias (__s1, __s2, __n);
}


extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2,
    size_t __n, size_t __ns1) throw ();
extern wchar_t *__wmemmove_alias (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw () __asm__ ("" "wmemmove")

                               ;
extern wchar_t *__wmemmove_chk_warn (wchar_t *__s1, const wchar_t *__s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemmove_chk")


     __attribute__((__warning__ ("wmemmove called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw ()
{
  if (__builtin_object_size (__s1, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmemmove_chk (__s1, __s2, __n,
          __builtin_object_size (__s1, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
 return __wmemmove_chk_warn (__s1, __s2, __n,
        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
    }
  return __wmemmove_alias (__s1, __s2, __n);
}



extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
    const wchar_t *__restrict __s2, size_t __n,
    size_t __ns1) throw ();
extern wchar_t *__wmempcpy_alias (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmempcpy")


                           ;
extern wchar_t *__wmempcpy_chk_warn (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmempcpy_chk")



     __attribute__((__warning__ ("wmempcpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ()

{
  if (__builtin_object_size (__s1, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmempcpy_chk (__s1, __s2, __n,
          __builtin_object_size (__s1, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
 return __wmempcpy_chk_warn (__s1, __s2, __n,
        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
    }
  return __wmempcpy_alias (__s1, __s2, __n);
}



extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
          size_t __ns) throw ();
extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm__ ("" "wmemset")
                             ;
extern wchar_t *__wmemset_chk_warn (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) throw () __asm__ ("" "__wmemset_chk")


     __attribute__((__warning__ ("wmemset called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ()
{
  if (__builtin_object_size (__s, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wmemset_chk (__s, __c, __n, __builtin_object_size (__s, 0) / sizeof (wchar_t));

      if (__n > __builtin_object_size (__s, 0) / sizeof (wchar_t))
 return __wmemset_chk_warn (__s, __c, __n,
       __builtin_object_size (__s, 0) / sizeof (wchar_t));
    }
  return __wmemset_alias (__s, __c, __n);
}


extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
         const wchar_t *__restrict __src,
         size_t __n) throw ();
extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcscpy")

                                              ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcscpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcscpy_alias (__dest, __src);
}


extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest,
         const wchar_t *__restrict __src,
         size_t __destlen) throw ();
extern wchar_t *__wcpcpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcpcpy")

                                              ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcpcpy_alias (__dest, __src);
}


extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
          const wchar_t *__restrict __src, size_t __n,
          size_t __destlen) throw ();
extern wchar_t *__wcsncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncpy")


                          ;
extern wchar_t *__wcsncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcsncpy_chk")



     __attribute__((__warning__ ("wcsncpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()

{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wcsncpy_chk (__dest, __src, __n,
         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
 return __wcsncpy_chk_warn (__dest, __src, __n,
       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
    }
  return __wcsncpy_alias (__dest, __src, __n);
}


extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
          const wchar_t *__restrict __src, size_t __n,
          size_t __destlen) throw ();
extern wchar_t *__wcpncpy_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcpncpy")


                          ;
extern wchar_t *__wcpncpy_chk_warn (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcpncpy_chk")



     __attribute__((__warning__ ("wcpncpy called with length bigger than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()

{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __wcpncpy_chk (__dest, __src, __n,
         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
 return __wcpncpy_chk_warn (__dest, __src, __n,
       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
    }
  return __wcpncpy_alias (__dest, __src, __n);
}


extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
         const wchar_t *__restrict __src,
         size_t __destlen) throw ();
extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __asm__ ("" "wcscat")

                                              ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcscat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcscat_alias (__dest, __src);
}


extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
          const wchar_t *__restrict __src,
          size_t __n, size_t __destlen) throw ();
extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncat")


                          ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) wchar_t *
__attribute__ ((__leaf__)) wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ()

{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
    return __wcsncat_chk (__dest, __src, __n,
     __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
  return __wcsncat_alias (__dest, __src, __n);
}


extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
      int __flag, size_t __s_len,
      const wchar_t *__restrict __format, ...)
     throw () ;

extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) throw () __asm__ ("" "swprintf")


             ;


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...) throw ()

{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
    return __swprintf_chk (__s, __n, 2 - 1,
      __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
      __fmt, __builtin_va_arg_pack ());
  return __swprintf_alias (__s, __n, __fmt, __builtin_va_arg_pack ());
}
# 303 "/usr/include/bits/wchar2.h" 3 4
extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
       int __flag, size_t __s_len,
       const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
     throw () ;

extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw () __asm__ ("" "vswprintf")


                                     ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
    return __vswprintf_chk (__s, __n, 2 - 1,
       __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t), __fmt, __ap);
  return __vswprintf_alias (__s, __n, __fmt, __ap);
}




extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
      const wchar_t *__restrict __format, ...);
extern int __wprintf_chk (int __flag, const wchar_t *__restrict __format,
     ...);
extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
       const wchar_t *__restrict __format,
       __gnuc_va_list __ap);
extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format,
      __gnuc_va_list __ap);


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
wprintf (const wchar_t *__restrict __fmt, ...)
{
  return __wprintf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...)
{
  return __fwprintf_chk (__stream, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}







extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vwprintf_chk (2 - 1, __fmt, __ap);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
vfwprintf (__FILE *__restrict __stream,
    const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vfwprintf_chk (__stream, 2 - 1, __fmt, __ap);
}



extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
         __FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws")

                                              __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgetws_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
        __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
 return __fgetws_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
      __n, __stream);
    }
  return __fgetws_alias (__s, __n, __stream);
}


extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
           int __n, __FILE *__restrict __stream)
  __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_unlocked_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws_unlocked")


  __attribute__ ((__warn_unused_result__));
extern wchar_t *__fgetws_unlocked_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_unlocked_chk")



     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws_unlocked called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgetws_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
          __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
 return __fgetws_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
        __n, __stream);
    }
  return __fgetws_unlocked_alias (__s, __n, __stream);
}



extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar,
        mbstate_t *__restrict __p,
        size_t __buflen) throw () __attribute__ ((__warn_unused_result__));
extern size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcrtomb")

                                                __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
__attribute__ ((__leaf__)) wcrtomb (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw ()

{







  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
    return __wcrtomb_chk (__s, __wchar, __ps, __builtin_object_size (__s, 2 > 1));
  return __wcrtomb_alias (__s, __wchar, __ps);
}


extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
          const char **__restrict __src,
          size_t __len, mbstate_t *__restrict __ps,
          size_t __dstlen) throw ();
extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsrtowcs")



                   ;
extern size_t __mbsrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsrtowcs_chk")




     __attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __mbsrtowcs_chk (__dst, __src, __len, __ps,
    __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));

      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
 return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
    }
  return __mbsrtowcs_alias (__dst, __src, __len, __ps);
}


extern size_t __wcsrtombs_chk (char *__restrict __dst,
          const wchar_t **__restrict __src,
          size_t __len, mbstate_t *__restrict __ps,
          size_t __dstlen) throw ();
extern size_t __wcsrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsrtombs")



                   ;
extern size_t __wcsrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsrtombs_chk")




    __attribute__((__warning__ ("wcsrtombs called with dst buffer smaller than len")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __wcsrtombs_chk (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));

      if (__len > __builtin_object_size (__dst, 2 > 1))
 return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
    }
  return __wcsrtombs_alias (__dst, __src, __len, __ps);
}



extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
    const char **__restrict __src, size_t __nmc,
    size_t __len, mbstate_t *__restrict __ps,
    size_t __dstlen) throw ();
extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsnrtowcs")



                    ;
extern size_t __mbsnrtowcs_chk_warn (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsnrtowcs_chk")




     __attribute__((__warning__ ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
     __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));

      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
 return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
    }
  return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
}


extern size_t __wcsnrtombs_chk (char *__restrict __dst,
    const wchar_t **__restrict __src,
    size_t __nwc, size_t __len,
    mbstate_t *__restrict __ps, size_t __dstlen)
     throw ();
extern size_t __wcsnrtombs_alias (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsnrtombs")



                                                  ;
extern size_t __wcsnrtombs_chk_warn (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsnrtombs_chk")





     __attribute__((__warning__ ("wcsnrtombs called with dst buffer smaller than len")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) size_t
__attribute__ ((__leaf__)) wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ()

{
  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__len))
 return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
     __builtin_object_size (__dst, 2 > 1));

      if (__len > __builtin_object_size (__dst, 2 > 1))
 return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
          __builtin_object_size (__dst, 2 > 1));
    }
  return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
}
# 850 "/usr/include/wchar.h" 2 3 4






}
# 45 "/usr/include/c++/10/cwchar" 2 3
# 62 "/usr/include/c++/10/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 135 "/usr/include/c++/10/cwchar" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::wint_t;

  using ::btowc;
  using ::fgetwc;
  using ::fgetws;
  using ::fputwc;
  using ::fputws;
  using ::fwide;
  using ::fwprintf;
  using ::fwscanf;
  using ::getwc;
  using ::getwchar;
  using ::mbrlen;
  using ::mbrtowc;
  using ::mbsinit;
  using ::mbsrtowcs;
  using ::putwc;
  using ::putwchar;

  using ::swprintf;

  using ::swscanf;
  using ::ungetwc;
  using ::vfwprintf;

  using ::vfwscanf;


  using ::vswprintf;


  using ::vswscanf;

  using ::vwprintf;

  using ::vwscanf;

  using ::wcrtomb;
  using ::wcscat;
  using ::wcscmp;
  using ::wcscoll;
  using ::wcscpy;
  using ::wcscspn;
  using ::wcsftime;
  using ::wcslen;
  using ::wcsncat;
  using ::wcsncmp;
  using ::wcsncpy;
  using ::wcsrtombs;
  using ::wcsspn;
  using ::wcstod;

  using ::wcstof;

  using ::wcstok;
  using ::wcstol;
  using ::wcstoul;
  using ::wcsxfrm;
  using ::wctob;
  using ::wmemcmp;
  using ::wmemcpy;
  using ::wmemmove;
  using ::wmemset;
  using ::wprintf;
  using ::wscanf;
  using ::wcschr;
  using ::wcspbrk;
  using ::wcsrchr;
  using ::wcsstr;
  using ::wmemchr;
# 234 "/usr/include/c++/10/cwchar" 3

}
}







namespace __gnu_cxx
{





  using ::wcstold;
# 260 "/usr/include/c++/10/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using ::__gnu_cxx::wcstold;
  using ::__gnu_cxx::wcstoll;
  using ::__gnu_cxx::wcstoull;
}
# 280 "/usr/include/c++/10/cwchar" 3
namespace std
{

  using std::wcstof;


  using std::vfwscanf;


  using std::vswscanf;


  using std::vwscanf;



  using std::wcstold;
  using std::wcstoll;
  using std::wcstoull;

}
# 41 "/usr/include/c++/10/bits/postypes.h" 2 3
# 68 "/usr/include/c++/10/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 88 "/usr/include/c++/10/bits/postypes.h" 3
  typedef long streamoff;
# 98 "/usr/include/c++/10/bits/postypes.h" 3
  typedef ptrdiff_t streamsize;
# 111 "/usr/include/c++/10/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 133 "/usr/include/c++/10/bits/postypes.h" 3
      fpos(streamoff __off)
      : _M_off(__off), _M_state() { }


      fpos(const fpos&) = default;
      fpos& operator=(const fpos&) = default;
      ~fpos() = default;



      operator streamoff() const { return _M_off; }


      void
      state(_StateT __st)
      { _M_state = __st; }


      _StateT
      state() const
      { return _M_state; }





      fpos&
      operator+=(streamoff __off)
      {
 _M_off += __off;
 return *this;
      }





      fpos&
      operator-=(streamoff __off)
      {
 _M_off -= __off;
 return *this;
      }







      fpos
      operator+(streamoff __off) const
      {
 fpos __pos(*this);
 __pos += __off;
 return __pos;
      }







      fpos
      operator-(streamoff __off) const
      {
 fpos __pos(*this);
 __pos -= __off;
 return __pos;
      }






      streamoff
      operator-(const fpos& __other) const
      { return _M_off - __other._M_off; }
    };






  template<typename _StateT>
    inline bool
    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) == streamoff(__rhs); }

  template<typename _StateT>
    inline bool
    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) != streamoff(__rhs); }





  typedef fpos<mbstate_t> streampos;

  typedef fpos<mbstate_t> wstreampos;
# 245 "/usr/include/c++/10/bits/postypes.h" 3
  typedef fpos<mbstate_t> u16streampos;

  typedef fpos<mbstate_t> u32streampos;



}
# 41 "/usr/include/c++/10/bits/char_traits.h" 2 3
# 1 "/usr/include/c++/10/cwchar" 1 3
# 39 "/usr/include/c++/10/cwchar" 3
       
# 40 "/usr/include/c++/10/cwchar" 3
# 42 "/usr/include/c++/10/bits/char_traits.h" 2 3





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

# 61 "/usr/include/c++/10/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;
    };
# 86 "/usr/include/c++/10/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits
    {
      typedef _CharT char_type;
      typedef typename _Char_types<_CharT>::int_type int_type;
      typedef typename _Char_types<_CharT>::pos_type pos_type;
      typedef typename _Char_types<_CharT>::off_type off_type;
      typedef typename _Char_types<_CharT>::state_type state_type;

      static constexpr void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);

      static constexpr std::size_t
      length(const char_type* __s);

      static constexpr const char_type*
      find(const char_type* __s, std::size_t __n, const char_type& __a);

      static char_type*
      move(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      copy(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      assign(char_type* __s, std::size_t __n, char_type __a);

      static constexpr char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static constexpr int_type
      eof()
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c)
      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
    };

  template<typename _CharT>
    constexpr int
    char_traits<_CharT>::
    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
 if (lt(__s1[__i], __s2[__i]))
   return -1;
 else if (lt(__s2[__i], __s1[__i]))
   return 1;
      return 0;
    }

  template<typename _CharT>
    constexpr std::size_t
    char_traits<_CharT>::
    length(const char_type* __p)
    {
      std::size_t __i = 0;
      while (!eq(__p[__i], char_type()))
        ++__i;
      return __i;
    }

  template<typename _CharT>
    constexpr const typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    find(const char_type* __s, std::size_t __n, const char_type& __a)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
        if (eq(__s[__i], __a))
          return __s + __i;
      return 0;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    move(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      if (__n == 0)
 return __s1;
      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
          __n * sizeof(char_type)));
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
    {

      std::copy(__s2, __s2 + __n, __s1);
      return __s1;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    assign(char_type* __s, std::size_t __n, char_type __a)
    {

      std::fill_n(__s, __n, __a);
      return __s;
    }


}

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

# 229 "/usr/include/c++/10/bits/char_traits.h" 3
  template<typename _CharT>
    static inline __attribute__((__always_inline__)) constexpr bool
    __constant_string_p(const _CharT* __s)
    {

      (void) __s;

      return __builtin_is_constant_evaluated();





    }
# 252 "/usr/include/c++/10/bits/char_traits.h" 3
  template<typename _CharT>
    static inline __attribute__((__always_inline__)) constexpr bool
    __constant_char_array_p(const _CharT* __a, size_t __n)
    {

      (void) __a;
      (void) __n;

      return __builtin_is_constant_evaluated();






    }
# 283 "/usr/include/c++/10/bits/char_traits.h" 3
  template<class _CharT>
    struct char_traits : public __gnu_cxx::char_traits<_CharT>
    { };



  template<>
    struct char_traits<char>
    {
      typedef char char_type;
      typedef int int_type;
      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;

      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      { __c1 = __c2; }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      {

 return (static_cast<unsigned char>(__c1)
  < static_cast<unsigned char>(__c2));
      }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (__builtin_constant_p(__n)
     && __constant_char_array_p(__s1, __n)
     && __constant_char_array_p(__s2, __n))
   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

 return __builtin_memcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (__constant_string_p(__s))
   return __gnu_cxx::char_traits<char_type>::length(__s);

 return __builtin_strlen(__s);
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (__builtin_constant_p(__n)
     && __builtin_constant_p(__a)
     && __constant_char_array_p(__s, __n))
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
      }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
      }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
      }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;
 return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return static_cast<char_type>(__c); }



      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return (__c == eof()) ? 0 : __c; }
  };




  template<>
    struct char_traits<wchar_t>
    {
      typedef wchar_t char_type;
      typedef wint_t int_type;
      typedef streamoff off_type;
      typedef wstreampos pos_type;
      typedef mbstate_t state_type;

      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      { __c1 = __c2; }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (__builtin_constant_p(__n)
     && __constant_char_array_p(__s1, __n)
     && __constant_char_array_p(__s2, __n))
   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

 return wmemcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (__constant_string_p(__s))
   return __gnu_cxx::char_traits<char_type>::length(__s);

 return wcslen(__s);
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (__builtin_constant_p(__n)
     && __builtin_constant_p(__a)
     && __constant_char_array_p(__s, __n))
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return wmemchr(__s, __a, __n);
      }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return wmemmove(__s1, __s2, __n);
      }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return wmemcpy(__s1, __s2, __n);
      }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;
 return wmemset(__s, __a, __n);
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>((0xffffffffu)); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }
  };
# 616 "/usr/include/c++/10/bits/char_traits.h" 3

}



# 1 "/usr/include/c++/10/cstdint" 1 3
# 32 "/usr/include/c++/10/cstdint" 3
       
# 33 "/usr/include/c++/10/cstdint" 3
# 41 "/usr/include/c++/10/cstdint" 3
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stdint.h" 1 3 4
# 9 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stdint.h" 3 4
# 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/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





typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;


typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;





typedef signed char int_fast8_t;

typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 71 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;

typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 90 "/usr/include/stdint.h" 3 4
typedef unsigned long int uintptr_t;
# 101 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 10 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stdint.h" 2 3 4
# 42 "/usr/include/c++/10/cstdint" 2 3


namespace std
{

  using ::int8_t;
  using ::int16_t;
  using ::int32_t;
  using ::int64_t;

  using ::int_fast8_t;
  using ::int_fast16_t;
  using ::int_fast32_t;
  using ::int_fast64_t;

  using ::int_least8_t;
  using ::int_least16_t;
  using ::int_least32_t;
  using ::int_least64_t;

  using ::intmax_t;
  using ::intptr_t;

  using ::uint8_t;
  using ::uint16_t;
  using ::uint32_t;
  using ::uint64_t;

  using ::uint_fast8_t;
  using ::uint_fast16_t;
  using ::uint_fast32_t;
  using ::uint_fast64_t;

  using ::uint_least8_t;
  using ::uint_least16_t;
  using ::uint_least32_t;
  using ::uint_least64_t;

  using ::uintmax_t;
  using ::uintptr_t;





}
# 622 "/usr/include/c++/10/bits/char_traits.h" 2 3

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


  template<>
    struct char_traits<char16_t>
    {
      typedef char16_t char_type;

      typedef uint_least16_t int_type;





      typedef streamoff off_type;
      typedef u16streampos pos_type;
      typedef mbstate_t state_type;

      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      { __c1 = __c2; }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (lt(__s1[__i], __s2[__i]))
     return -1;
   else if (lt(__s2[__i], __s1[__i]))
     return 1;
 return 0;
      }

      static constexpr size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (eq(__s[__i], __a))
     return __s + __i;
 return 0;
      }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return (static_cast<char_type*>
  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
      }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return (static_cast<char_type*>
  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
      }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   assign(__s[__i], __a);
 return __s;
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return __c == eof() ? int_type(0xfffd) : int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }
    };

  template<>
    struct char_traits<char32_t>
    {
      typedef char32_t char_type;

      typedef uint_least32_t int_type;





      typedef streamoff off_type;
      typedef u32streampos pos_type;
      typedef mbstate_t state_type;

      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      { __c1 = __c2; }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (lt(__s1[__i], __s2[__i]))
     return -1;
   else if (lt(__s2[__i], __s1[__i]))
     return 1;
 return 0;
      }

      static constexpr size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (eq(__s[__i], __a))
     return __s + __i;
 return 0;
      }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return (static_cast<char_type*>
  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
      }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;
 return (static_cast<char_type*>
  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
      }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   assign(__s[__i], __a);
 return __s;
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }
    };


}
# 41 "/usr/include/c++/10/string" 2 3


# 1 "/usr/include/c++/10/bits/localefwd.h" 1 3
# 37 "/usr/include/c++/10/bits/localefwd.h" 3
       
# 38 "/usr/include/c++/10/bits/localefwd.h" 3


# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++locale.h" 1 3
# 39 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++locale.h" 3
       
# 40 "/usr/include/c++/10/x86_64-redhat-linux/bits/c++locale.h" 3

# 1 "/usr/include/c++/10/clocale" 1 3
# 39 "/usr/include/c++/10/clocale" 3
       
# 40 "/usr/include/c++/10/clocale" 3


# 1 "/usr/include/locale.h" 1 3 4
# 28 "/usr/include/locale.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 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) throw ();


extern struct lconv *localeconv (void) throw ();
# 141 "/usr/include/locale.h" 3 4
extern locale_t newlocale (int __category_mask, const char *__locale,
      locale_t __base) throw ();
# 176 "/usr/include/locale.h" 3 4
extern locale_t duplocale (locale_t __dataset) throw ();



extern void freelocale (locale_t __dataset) throw ();






extern locale_t uselocale (locale_t __dataset) throw ();







}
# 43 "/usr/include/c++/10/clocale" 2 3
# 51 "/usr/include/c++/10/clocale" 3
namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 42 "/usr/include/c++/10/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;





  inline int
  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
     char* __out,
     const int __size __attribute__ ((__unused__)),
     const char* __fmt, ...)
  {

    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 88 "/usr/include/c++/10/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/include/c++/10/bits/localefwd.h" 2 3
# 1 "/usr/include/c++/10/iosfwd" 1 3
# 36 "/usr/include/c++/10/iosfwd" 3
       
# 37 "/usr/include/c++/10/iosfwd" 3





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

# 74 "/usr/include/c++/10/iosfwd" 3
  class ios_base;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ios;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_streambuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_istream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_iostream;


namespace __cxx11 {

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
     typename _Alloc = allocator<_CharT> >
    class basic_stringbuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_istringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_ostringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_stringstream;

}

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_filebuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ifstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ofstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_fstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class ostreambuf_iterator;



  typedef basic_ios<char> ios;


  typedef basic_streambuf<char> streambuf;


  typedef basic_istream<char> istream;


  typedef basic_ostream<char> ostream;


  typedef basic_iostream<char> iostream;


  typedef basic_stringbuf<char> stringbuf;


  typedef basic_istringstream<char> istringstream;


  typedef basic_ostringstream<char> ostringstream;


  typedef basic_stringstream<char> stringstream;


  typedef basic_filebuf<char> filebuf;


  typedef basic_ifstream<char> ifstream;


  typedef basic_ofstream<char> ofstream;


  typedef basic_fstream<char> fstream;



  typedef basic_ios<wchar_t> wios;


  typedef basic_streambuf<wchar_t> wstreambuf;


  typedef basic_istream<wchar_t> wistream;


  typedef basic_ostream<wchar_t> wostream;


  typedef basic_iostream<wchar_t> wiostream;


  typedef basic_stringbuf<wchar_t> wstringbuf;


  typedef basic_istringstream<wchar_t> wistringstream;


  typedef basic_ostringstream<wchar_t> wostringstream;


  typedef basic_stringstream<wchar_t> wstringstream;


  typedef basic_filebuf<wchar_t> wfilebuf;


  typedef basic_ifstream<wchar_t> wifstream;


  typedef basic_ofstream<wchar_t> wofstream;


  typedef basic_fstream<wchar_t> wfstream;




}
# 42 "/usr/include/c++/10/bits/localefwd.h" 2 3
# 1 "/usr/include/c++/10/cctype" 1 3
# 39 "/usr/include/c++/10/cctype" 3
       
# 40 "/usr/include/c++/10/cctype" 3


# 1 "/usr/include/ctype.h" 1 3 4
# 28 "/usr/include/ctype.h" 3 4
extern "C" {
# 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)
     throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
     throw () __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
     throw () __attribute__ ((__const__));
# 108 "/usr/include/ctype.h" 3 4
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();



extern int tolower (int __c) throw ();


extern int toupper (int __c) throw ();




extern int isblank (int) throw ();




extern int isctype (int __c, int __mask) throw ();






extern int isascii (int __c) throw ();



extern int toascii (int __c) throw ();



extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 251 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, locale_t) throw ();
extern int isalpha_l (int, locale_t) throw ();
extern int iscntrl_l (int, locale_t) throw ();
extern int isdigit_l (int, locale_t) throw ();
extern int islower_l (int, locale_t) throw ();
extern int isgraph_l (int, locale_t) throw ();
extern int isprint_l (int, locale_t) throw ();
extern int ispunct_l (int, locale_t) throw ();
extern int isspace_l (int, locale_t) throw ();
extern int isupper_l (int, locale_t) throw ();
extern int isxdigit_l (int, locale_t) throw ();

extern int isblank_l (int, locale_t) throw ();



extern int __tolower_l (int __c, locale_t __l) throw ();
extern int tolower_l (int __c, locale_t __l) throw ();


extern int __toupper_l (int __c, locale_t __l) throw ();
extern int toupper_l (int __c, locale_t __l) throw ();
# 327 "/usr/include/ctype.h" 3 4
}
# 43 "/usr/include/c++/10/cctype" 2 3
# 62 "/usr/include/c++/10/cctype" 3
namespace std
{
  using ::isalnum;
  using ::isalpha;
  using ::iscntrl;
  using ::isdigit;
  using ::isgraph;
  using ::islower;
  using ::isprint;
  using ::ispunct;
  using ::isspace;
  using ::isupper;
  using ::isxdigit;
  using ::tolower;
  using ::toupper;
}







namespace std
{
  using ::isblank;
}
# 43 "/usr/include/c++/10/bits/localefwd.h" 2 3

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

# 55 "/usr/include/c++/10/bits/localefwd.h" 3
  class locale;

  template<typename _Facet>
    bool
    has_facet(const locale&) throw();

  template<typename _Facet>
    const _Facet&
    use_facet(const locale&);


  template<typename _CharT>
    bool
    isspace(_CharT, const locale&);

  template<typename _CharT>
    bool
    isprint(_CharT, const locale&);

  template<typename _CharT>
    bool
    iscntrl(_CharT, const locale&);

  template<typename _CharT>
    bool
    isupper(_CharT, const locale&);

  template<typename _CharT>
    bool
    islower(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalpha(_CharT, const locale&);

  template<typename _CharT>
    bool
    isdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    ispunct(_CharT, const locale&);

  template<typename _CharT>
    bool
    isxdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalnum(_CharT, const locale&);

  template<typename _CharT>
    bool
    isgraph(_CharT, const locale&);


  template<typename _CharT>
    bool
    isblank(_CharT, const locale&);


  template<typename _CharT>
    _CharT
    toupper(_CharT, const locale&);

  template<typename _CharT>
    _CharT
    tolower(_CharT, const locale&);


  class ctype_base;
  template<typename _CharT>
    class ctype;
  template<> class ctype<char>;

  template<> class ctype<wchar_t>;

  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;

  template<> class codecvt<wchar_t, char, mbstate_t>;


  template<> class codecvt<char16_t, char, mbstate_t>;
  template<> class codecvt<char32_t, char, mbstate_t>;





  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname;



  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class num_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class num_put;

namespace __cxx11 {
  template<typename _CharT> class numpunct;
  template<typename _CharT> class numpunct_byname;
}

namespace __cxx11 {

  template<typename _CharT>
    class collate;
  template<typename _CharT>
    class collate_byname;
}


  class time_base;
namespace __cxx11 {
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get_byname;
}
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put_byname;


  class money_base;
namespace __cxx11 {
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class money_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class money_put;
}
namespace __cxx11 {
  template<typename _CharT, bool _Intl = false>
    class moneypunct;
  template<typename _CharT, bool _Intl = false>
    class moneypunct_byname;
}


  class messages_base;
namespace __cxx11 {
  template<typename _CharT>
    class messages;
  template<typename _CharT>
    class messages_byname;
}


}
# 44 "/usr/include/c++/10/string" 2 3
# 1 "/usr/include/c++/10/bits/ostream_insert.h" 1 3
# 33 "/usr/include/c++/10/bits/ostream_insert.h" 3
       
# 34 "/usr/include/c++/10/bits/ostream_insert.h" 3


# 1 "/usr/include/c++/10/bits/cxxabi_forced.h" 1 3
# 34 "/usr/include/c++/10/bits/cxxabi_forced.h" 3
       
# 35 "/usr/include/c++/10/bits/cxxabi_forced.h" 3

#pragma GCC visibility push(default)


namespace __cxxabiv1
{







  class __forced_unwind
  {
    virtual ~__forced_unwind() throw();


    virtual void __pure_dummy() = 0;
  };
}


#pragma GCC visibility pop
# 37 "/usr/include/c++/10/bits/ostream_insert.h" 2 3

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


  template<typename _CharT, typename _Traits>
    inline void
    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
      const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
      if (__put != __n)
 __out.setstate(__ios_base::badbit);
    }

  template<typename _CharT, typename _Traits>
    inline void
    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const _CharT __c = __out.fill();
      for (; __n > 0; --__n)
 {
   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
   if (_Traits::eq_int_type(__put, _Traits::eof()))
     {
       __out.setstate(__ios_base::badbit);
       break;
     }
 }
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
       const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       if (__w > __n)
  {
    const bool __left = ((__out.flags()
     & __ios_base::adjustfield)
           == __ios_base::left);
    if (!__left)
      __ostream_fill(__out, __w - __n);
    if (__out.good())
      __ostream_write(__out, __s, __n);
    if (__left && __out.good())
      __ostream_fill(__out, __w - __n);
  }
       else
  __ostream_write(__out, __s, __n);
       __out.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(__ios_base::badbit); }
 }
      return __out;
    }




  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);


  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
          streamsize);




}
# 45 "/usr/include/c++/10/string" 2 3
# 55 "/usr/include/c++/10/string" 3
# 1 "/usr/include/c++/10/bits/basic_string.h" 1 3
# 37 "/usr/include/c++/10/bits/basic_string.h" 3
       
# 38 "/usr/include/c++/10/bits/basic_string.h" 3

# 1 "/usr/include/c++/10/ext/atomicity.h" 1 3
# 32 "/usr/include/c++/10/ext/atomicity.h" 3
       
# 33 "/usr/include/c++/10/ext/atomicity.h" 3


# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr.h" 1 3
# 30 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 148 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr.h" 3
# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr-default.h" 1 3
# 35 "/usr/include/c++/10/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/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 30 "/usr/include/sched.h" 2 3 4
# 43 "/usr/include/sched.h" 3 4
# 1 "/usr/include/bits/sched.h" 1 3 4
# 76 "/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;
};
# 77 "/usr/include/bits/sched.h" 2 3 4

extern "C" {



extern int clone (int (*__fn) (void *__arg), void *__child_stack,
    int __flags, void *__arg, ...) throw ();


extern int unshare (int __flags) throw ();


extern int sched_getcpu (void) throw ();


extern int getcpu (unsigned int *, unsigned int *) throw ();


extern int setns (int __fd, int __nstype) throw ();


}
# 44 "/usr/include/sched.h" 2 3 4
# 1 "/usr/include/bits/cpu-set.h" 1 3 4
# 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)
     throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () __attribute__ ((__warn_unused_result__));
extern void __sched_cpufree (cpu_set_t *__set) throw ();

}
# 45 "/usr/include/sched.h" 2 3 4






extern "C" {


extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
     throw ();


extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();


extern int sched_setscheduler (__pid_t __pid, int __policy,
          const struct sched_param *__param) throw ();


extern int sched_getscheduler (__pid_t __pid) throw ();


extern int sched_yield (void) throw ();


extern int sched_get_priority_max (int __algorithm) throw ();


extern int sched_get_priority_min (int __algorithm) throw ();


extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
# 121 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
         const cpu_set_t *__cpuset) throw ();


extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
         cpu_set_t *__cpuset) throw ();


}
# 23 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 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
{
  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) throw ();

}
# 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
# 48 "/usr/include/time.h" 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) throw ();


extern time_t time (time_t *__timer) throw ();


extern double difftime (time_t __time1, time_t __time0)
     throw () __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) throw ();





extern size_t strftime (char *__restrict __s, size_t __maxsize,
   const char *__restrict __format,
   const struct tm *__restrict __tp) throw ();




extern char *strptime (const char *__restrict __s,
         const char *__restrict __fmt, struct tm *__tp)
     throw ();






extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
     const char *__restrict __format,
     const struct tm *__restrict __tp,
     locale_t __loc) throw ();



extern char *strptime_l (const char *__restrict __s,
    const char *__restrict __fmt, struct tm *__tp,
    locale_t __loc) throw ();





extern struct tm *gmtime (const time_t *__timer) throw ();



extern struct tm *localtime (const time_t *__timer) throw ();




extern struct tm *gmtime_r (const time_t *__restrict __timer,
       struct tm *__restrict __tp) throw ();



extern struct tm *localtime_r (const time_t *__restrict __timer,
          struct tm *__restrict __tp) throw ();




extern char *asctime (const struct tm *__tp) throw ();


extern char *ctime (const time_t *__timer) throw ();






extern char *asctime_r (const struct tm *__restrict __tp,
   char *__restrict __buf) throw ();


extern char *ctime_r (const time_t *__restrict __timer,
        char *__restrict __buf) throw ();




extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) throw ();



extern int daylight;
extern long int timezone;
# 190 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();


extern time_t timelocal (struct tm *__tp) throw ();


extern int dysize (int __year) throw () __attribute__ ((__const__));
# 205 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
        struct timespec *__remaining);



extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();


extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
     throw ();






extern int clock_nanosleep (clockid_t __clock_id, int __flags,
       const struct timespec *__req,
       struct timespec *__rem);


extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();




extern int timer_create (clockid_t __clock_id,
    struct sigevent *__restrict __evp,
    timer_t *__restrict __timerid) throw ();


extern int timer_delete (timer_t __timerid) throw ();


extern int timer_settime (timer_t __timerid, int __flags,
     const struct itimerspec *__restrict __value,
     struct itimerspec *__restrict __ovalue) throw ();


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     throw ();


extern int timer_getoverrun (timer_t __timerid) throw ();





extern int timespec_get (struct timespec *__ts, int __base)
     throw () __attribute__ ((__nonnull__ (1)));
# 274 "/usr/include/time.h" 3 4
extern int getdate_err;
# 283 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 297 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
        struct tm *__restrict __resbufp);


}
# 24 "/usr/include/pthread.h" 2 3 4



# 1 "/usr/include/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




enum
{
  PTHREAD_CREATE_JOINABLE,

  PTHREAD_CREATE_DETACHED

};



enum
{
  PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_ADAPTIVE_NP

  ,
  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL



  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP

};




enum
{
  PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_ROBUST,
  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};





enum
{
  PTHREAD_PRIO_NONE,
  PTHREAD_PRIO_INHERIT,
  PTHREAD_PRIO_PROTECT
};
# 100 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_RWLOCK_PREFER_READER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
# 120 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_INHERIT_SCHED,

  PTHREAD_EXPLICIT_SCHED

};



enum
{
  PTHREAD_SCOPE_SYSTEM,

  PTHREAD_SCOPE_PROCESS

};



enum
{
  PTHREAD_PROCESS_PRIVATE,

  PTHREAD_PROCESS_SHARED

};
# 155 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
  void (*__routine) (void *);
  void *__arg;
  int __canceltype;
  struct _pthread_cleanup_buffer *__prev;
};


enum
{
  PTHREAD_CANCEL_ENABLE,

  PTHREAD_CANCEL_DISABLE

};
enum
{
  PTHREAD_CANCEL_DEFERRED,

  PTHREAD_CANCEL_ASYNCHRONOUS

};
# 193 "/usr/include/pthread.h" 3 4
extern "C" {




extern int pthread_create (pthread_t *__restrict __newthread,
      const pthread_attr_t *__restrict __attr,
      void *(*__start_routine) (void *),
      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));





extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));







extern int pthread_join (pthread_t __th, void **__thread_return);




extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();







extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
     const struct timespec *__abstime);
# 238 "/usr/include/pthread.h" 3 4
extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
                                 clockid_t __clockid,
     const struct timespec *__abstime);






extern int pthread_detach (pthread_t __th) throw ();



extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
  throw () __attribute__ ((__const__));







extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_destroy (pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
     int *__detachstate)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
     int __detachstate)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
          size_t *__guardsize)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
          size_t __guardsize)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
           struct sched_param *__restrict __param)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
           const struct sched_param *__restrict
           __param) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
     __attr, int *__restrict __policy)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
      __attr, int *__restrict __inherit)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
      int __inherit)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
      int *__restrict __scope)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
          __attr, void **__restrict __stackaddr)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));





extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
          void *__stackaddr)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));


extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
          __attr, size_t *__restrict __stacksize)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
          size_t __stacksize)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
      void **__restrict __stackaddr,
      size_t *__restrict __stacksize)
     throw () __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));





extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
     size_t __cpusetsize,
     const cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
     size_t __cpusetsize,
     cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (1, 3)));


extern int pthread_getattr_default_np (pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));




extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (2)));







extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
      const struct sched_param *__param)
     throw () __attribute__ ((__nonnull__ (3)));


extern int pthread_getschedparam (pthread_t __target_thread,
      int *__restrict __policy,
      struct sched_param *__restrict __param)
     throw () __attribute__ ((__nonnull__ (2, 3)));


extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
     throw ();




extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
          size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));


extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
     throw () __attribute__ ((__nonnull__ (2)));





extern int pthread_getconcurrency (void) throw ();


extern int pthread_setconcurrency (int __level) throw ();







extern int pthread_yield (void) throw ();




extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
       const cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (3)));


extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
       cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (3)));
# 470 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 482 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);



extern int pthread_setcanceltype (int __type, int *__oldtype);


extern int pthread_cancel (pthread_t __th);




extern void pthread_testcancel (void);




typedef struct
{
  struct
  {
    __jmp_buf __cancel_jmp_buf;
    int __mask_was_saved;
  } __cancel_jmp_buf[1];
  void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
# 516 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;
};




class __pthread_cleanup_class
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;

 public:
  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
  void __setdoit (int __newval) { __do_it = __newval; }
  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
        &__cancel_type); }
  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
};
# 718 "/usr/include/pthread.h" 3 4
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();





extern int pthread_mutex_init (pthread_mutex_t *__mutex,
          const pthread_mutexattr_t *__mutexattr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
        const struct timespec *__restrict
        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
        clockid_t __clockid,
        const struct timespec *__restrict
        __abstime) throw () __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
      __restrict __mutex,
      int *__restrict __prioceiling)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
      int __prioceiling,
      int *__restrict __old_ceiling)
     throw () __attribute__ ((__nonnull__ (1, 3)));




extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));

extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));
# 789 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
      __restrict __attr,
      int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
      int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
          __attr, int *__restrict __kind)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
       __restrict __attr,
       int *__restrict __protocol)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
       int __protocol)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
          __restrict __attr,
          int *__restrict __prioceiling)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
          int __prioceiling)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
     int *__robustness)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
        int *__robustness)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
     int __robustness)
     throw () __attribute__ ((__nonnull__ (1)));

extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
        int __robustness)
     throw () __attribute__ ((__nonnull__ (1)));
# 871 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
    const pthread_rwlockattr_t *__restrict
    __attr) throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
       int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pref)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
       int __pref) throw () __attribute__ ((__nonnull__ (1)));







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
         const pthread_condattr_t *__restrict __cond_attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_destroy (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_signal (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_broadcast (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));






extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
         pthread_mutex_t *__restrict __mutex)
     __attribute__ ((__nonnull__ (1, 2)));
# 997 "/usr/include/pthread.h" 3 4
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       const struct timespec *__restrict __abstime)
     __attribute__ ((__nonnull__ (1, 2, 3)));
# 1010 "/usr/include/pthread.h" 3 4
extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       __clockid_t __clock_id,
       const struct timespec *__restrict __abstime)
     __attribute__ ((__nonnull__ (1, 2, 4)));





extern int pthread_condattr_init (pthread_condattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_getpshared (const pthread_condattr_t *
     __restrict __attr,
     int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
     int __pshared) throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_condattr_getclock (const pthread_condattr_t *
          __restrict __attr,
          __clockid_t *__restrict __clock_id)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
          __clockid_t __clock_id)
     throw () __attribute__ ((__nonnull__ (1)));
# 1056 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_lock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));






extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
     const pthread_barrierattr_t *__restrict
     __attr, unsigned int __count)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
        __restrict __attr,
        int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
        int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));
# 1123 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
          void (*__destr_function) (void *))
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_key_delete (pthread_key_t __key) throw ();


extern void *pthread_getspecific (pthread_key_t __key) throw ();


extern int pthread_setspecific (pthread_key_t __key,
    const void *__pointer) throw () ;




extern int pthread_getcpuclockid (pthread_t __thread_id,
      __clockid_t *__clock_id)
     throw () __attribute__ ((__nonnull__ (2)));
# 1157 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) throw ();




extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
{
  return __thread1 == __thread2;
}


}
# 36 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr-default.h" 2 3
# 47 "/usr/include/c++/10/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;
# 102 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr-default.h" 3
static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once"), __copy__ (pthread_once)));
static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific"), __copy__ (pthread_getspecific)));
static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific"), __copy__ (pthread_setspecific)));

static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create"), __copy__ (pthread_create)));
static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join"), __copy__ (pthread_join)));
static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal"), __copy__ (pthread_equal)));
static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self"), __copy__ (pthread_self)));
static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach"), __copy__ (pthread_detach)));

static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel"), __copy__ (pthread_cancel)));

static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield"), __copy__ (sched_yield)));

static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock"), __copy__ (pthread_mutex_lock)));
static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock"), __copy__ (pthread_mutex_trylock)));

static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock"), __copy__ (pthread_mutex_timedlock)));

static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock"), __copy__ (pthread_mutex_unlock)));
static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init"), __copy__ (pthread_mutex_init)));
static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy"), __copy__ (pthread_mutex_destroy)));

static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init"), __copy__ (pthread_cond_init)));
static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast"), __copy__ (pthread_cond_broadcast)));
static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal"), __copy__ (pthread_cond_signal)));
static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait"), __copy__ (pthread_cond_wait)));
static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait"), __copy__ (pthread_cond_timedwait)));
static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy"), __copy__ (pthread_cond_destroy)));

static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create"), __copy__ (pthread_key_create)));
static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete"), __copy__ (pthread_key_delete)));
static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init"), __copy__ (pthread_mutexattr_init)));
static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype"), __copy__ (pthread_mutexattr_settype)));
static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy"), __copy__ (pthread_mutexattr_destroy)));
# 237 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr-default.h" 3
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create"), __copy__ (pthread_key_create)));
# 247 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  static void *const __gthread_active_ptr
    = __extension__ (void *) &__gthrw___pthread_key_create;
  return __gthread_active_ptr != 0;
}
# 659 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
    void *__args)
{
  return __gthrw_pthread_create (__threadid, __null, __func, __args);
}

static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
  return __gthrw_pthread_join (__threadid, __value_ptr);
}

static inline int
__gthread_detach (__gthread_t __threadid)
{
  return __gthrw_pthread_detach (__threadid);
}

static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
  return __gthrw_pthread_equal (__t1, __t2);
}

static inline __gthread_t
__gthread_self (void)
{
  return __gthrw_pthread_self ();
}

static inline int
__gthread_yield (void)
{
  return __gthrw_sched_yield ();
}

static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (__gthread_active_p ())
    return __gthrw_pthread_once (__once, __func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
  return __gthrw_pthread_key_create (__key, __dtor);
}

static inline int
__gthread_key_delete (__gthread_key_t __key)
{
  return __gthrw_pthread_key_delete (__key);
}

static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
  return __gthrw_pthread_getspecific (__key);
}

static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
  return __gthrw_pthread_setspecific (__key, __ptr);
}

static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    __gthrw_pthread_mutex_init (__mutex, __null);
}

static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_destroy (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_lock (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_trylock (__mutex);
  else
    return 0;
}


static inline int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
      const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}


static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_unlock (__mutex);
  else
    return 0;
}
# 808 "/usr/include/c++/10/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);
}
# 850 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
  return __gthrw_pthread_cond_broadcast (__cond);
}

static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
  return __gthrw_pthread_cond_signal (__cond);
}

static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
  return __gthrw_pthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
     const __gthread_time_t *__abs_timeout)
{
  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}

static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
          __gthread_recursive_mutex_t *__mutex)
{
  return __gthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
  return __gthrw_pthread_cond_destroy (__cond);
}
# 149 "/usr/include/c++/10/x86_64-redhat-linux/bits/gthr.h" 2 3


#pragma GCC visibility pop
# 36 "/usr/include/c++/10/ext/atomicity.h" 2 3
# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/atomic_word.h" 1 3
# 32 "/usr/include/c++/10/x86_64-redhat-linux/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 37 "/usr/include/c++/10/ext/atomicity.h" 2 3

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







  inline _Atomic_word
  __attribute__((__always_inline__))
  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
  { return __atomic_fetch_add(__mem, __val, 4); }

  inline void
  __attribute__((__always_inline__))
  __atomic_add(volatile _Atomic_word* __mem, int __val)
  { __atomic_fetch_add(__mem, __val, 4); }
# 64 "/usr/include/c++/10/ext/atomicity.h" 3
  inline _Atomic_word
  __attribute__((__always_inline__))
  __exchange_and_add_single(_Atomic_word* __mem, int __val)
  {
    _Atomic_word __result = *__mem;
    *__mem += __val;
    return __result;
  }

  inline void
  __attribute__((__always_inline__))
  __atomic_add_single(_Atomic_word* __mem, int __val)
  { *__mem += __val; }

  inline _Atomic_word
  __attribute__ ((__always_inline__))
  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
  {

    if (__gthread_active_p())
      return __exchange_and_add(__mem, __val);

    return __exchange_and_add_single(__mem, __val);
  }

  inline void
  __attribute__ ((__always_inline__))
  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
  {

    if (__gthread_active_p())
      {
 __atomic_add(__mem, __val);
 return;
      }

    __atomic_add_single(__mem, __val);
  }


}
# 40 "/usr/include/c++/10/bits/basic_string.h" 2 3
# 48 "/usr/include/c++/10/bits/basic_string.h" 3
# 1 "/usr/include/c++/10/string_view" 1 3
# 36 "/usr/include/c++/10/string_view" 3
       
# 37 "/usr/include/c++/10/string_view" 3
# 46 "/usr/include/c++/10/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;
  }
# 89 "/usr/include/c++/10/string_view" 3
  template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
    class basic_string_view
    {
      static_assert(!is_array_v<_CharT>);
      static_assert(is_trivial_v<_CharT> && is_standard_layout_v<_CharT>);
      static_assert(is_same_v<_CharT, typename _Traits::char_type>);

    public:


      using traits_type = _Traits;
      using value_type = _CharT;
      using pointer = value_type*;
      using const_pointer = const value_type*;
      using reference = value_type&;
      using const_reference = const value_type&;
      using const_iterator = const value_type*;
      using iterator = const_iterator;
      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
      using reverse_iterator = const_reverse_iterator;
      using size_type = size_t;
      using difference_type = ptrdiff_t;
      static constexpr size_type npos = size_type(-1);



      constexpr
      basic_string_view() noexcept
      : _M_len{0}, _M_str{nullptr}
      { }

      constexpr basic_string_view(const basic_string_view&) noexcept = default;

      __attribute__((__nonnull__)) constexpr
      basic_string_view(const _CharT* __str) noexcept
      : _M_len{traits_type::length(__str)},
 _M_str{__str}
      { }

      constexpr
      basic_string_view(const _CharT* __str, size_type __len) noexcept
      : _M_len{__len}, _M_str{__str}
      { }
# 143 "/usr/include/c++/10/string_view" 3
      constexpr basic_string_view&
      operator=(const basic_string_view&) noexcept = default;



      constexpr const_iterator
      begin() const noexcept
      { return this->_M_str; }

      constexpr const_iterator
      end() const noexcept
      { return this->_M_str + this->_M_len; }

      constexpr const_iterator
      cbegin() const noexcept
      { return this->_M_str; }

      constexpr const_iterator
      cend() const noexcept
      { return this->_M_str + this->_M_len; }

      constexpr const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->end()); }

      constexpr const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->begin()); }

      constexpr const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->end()); }

      constexpr const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->begin()); }



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

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

      constexpr size_type
      max_size() const noexcept
      {
 return (npos - sizeof(size_type) - sizeof(void*))
  / sizeof(value_type) / 4;
      }

      [[nodiscard]] constexpr bool
      empty() const noexcept
      { return this->_M_len == 0; }



      constexpr const_reference
      operator[](size_type __pos) const noexcept
      {


 return *(this->_M_str + __pos);
      }

      constexpr const_reference
      at(size_type __pos) const
      {
 if (__pos >= _M_len)
   __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)")

                            , __pos, this->size());
 return *(this->_M_str + __pos);
      }

      constexpr const_reference
      front() const noexcept
      {


 return *this->_M_str;
      }

      constexpr const_reference
      back() const noexcept
      {


 return *(this->_M_str + this->_M_len - 1);
      }

      constexpr const_pointer
      data() const noexcept
      { return this->_M_str; }



      constexpr void
      remove_prefix(size_type __n) noexcept
      {
 do { if (! (this->_M_len >= __n)) std::__replacement_assert("/usr/include/c++/10/string_view", 246, __PRETTY_FUNCTION__, "this->_M_len >= __n"); } while (false);
 this->_M_str += __n;
 this->_M_len -= __n;
      }

      constexpr void
      remove_suffix(size_type __n) noexcept
      { this->_M_len -= __n; }

      constexpr void
      swap(basic_string_view& __sv) noexcept
      {
 auto __tmp = *this;
 *this = __sv;
 __sv = __tmp;
      }



      size_type
      copy(_CharT* __str, size_type __n, size_type __pos = 0) const
      {
 ;
 __pos = std::__sv_check(size(), __pos, "basic_string_view::copy");
 const size_type __rlen = std::min(__n, _M_len - __pos);


 traits_type::copy(__str, data() + __pos, __rlen);
 return __rlen;
      }

      constexpr basic_string_view
      substr(size_type __pos = 0, size_type __n = npos) const noexcept(false)
      {
 __pos = std::__sv_check(size(), __pos, "basic_string_view::substr");
 const size_type __rlen = std::min(__n, _M_len - __pos);
 return basic_string_view{_M_str + __pos, __rlen};
      }

      constexpr int
      compare(basic_string_view __str) const noexcept
      {
 const size_type __rlen = std::min(this->_M_len, __str._M_len);
 int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
 if (__ret == 0)
   __ret = _S_compare(this->_M_len, __str._M_len);
 return __ret;
      }

      constexpr int
      compare(size_type __pos1, size_type __n1, basic_string_view __str) const
      { return this->substr(__pos1, __n1).compare(__str); }

      constexpr int
      compare(size_type __pos1, size_type __n1,
       basic_string_view __str, size_type __pos2, size_type __n2) const
      {
 return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
      }

      __attribute__((__nonnull__)) constexpr int
      compare(const _CharT* __str) const noexcept
      { return this->compare(basic_string_view{__str}); }

      __attribute__((__nonnull__)) constexpr int
      compare(size_type __pos1, size_type __n1, const _CharT* __str) const
      { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }

      constexpr int
      compare(size_type __pos1, size_type __n1,
       const _CharT* __str, size_type __n2) const noexcept(false)
      {
 return this->substr(__pos1, __n1)
     .compare(basic_string_view(__str, __n2));
      }
# 353 "/usr/include/c++/10/string_view" 3
      constexpr size_type
      find(basic_string_view __str, size_type __pos = 0) const noexcept
      { return this->find(__str._M_str, __pos, __str._M_len); }

      constexpr size_type
      find(_CharT __c, size_type __pos = 0) const noexcept;

      constexpr size_type
      find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

      __attribute__((__nonnull__)) constexpr size_type
      find(const _CharT* __str, size_type __pos = 0) const noexcept
      { return this->find(__str, __pos, traits_type::length(__str)); }

      constexpr size_type
      rfind(basic_string_view __str, size_type __pos = npos) const noexcept
      { return this->rfind(__str._M_str, __pos, __str._M_len); }

      constexpr size_type
      rfind(_CharT __c, size_type __pos = npos) const noexcept;

      constexpr size_type
      rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

      __attribute__((__nonnull__)) constexpr size_type
      rfind(const _CharT* __str, size_type __pos = npos) const noexcept
      { return this->rfind(__str, __pos, traits_type::length(__str)); }

      constexpr size_type
      find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
      { return this->find_first_of(__str._M_str, __pos, __str._M_len); }

      constexpr size_type
      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
      { return this->find(__c, __pos); }

      constexpr size_type
      find_first_of(const _CharT* __str, size_type __pos,
      size_type __n) const noexcept;

      __attribute__((__nonnull__)) constexpr size_type
      find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
      { return this->find_first_of(__str, __pos, traits_type::length(__str)); }

      constexpr size_type
      find_last_of(basic_string_view __str,
     size_type __pos = npos) const noexcept
      { return this->find_last_of(__str._M_str, __pos, __str._M_len); }

      constexpr size_type
      find_last_of(_CharT __c, size_type __pos=npos) const noexcept
      { return this->rfind(__c, __pos); }

      constexpr size_type
      find_last_of(const _CharT* __str, size_type __pos,
     size_type __n) const noexcept;

      __attribute__((__nonnull__)) constexpr size_type
      find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
      { return this->find_last_of(__str, __pos, traits_type::length(__str)); }

      constexpr size_type
      find_first_not_of(basic_string_view __str,
   size_type __pos = 0) const noexcept
      { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }

      constexpr size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;

      constexpr size_type
      find_first_not_of(const _CharT* __str,
   size_type __pos, size_type __n) const noexcept;

      __attribute__((__nonnull__)) constexpr size_type
      find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
      {
 return this->find_first_not_of(__str, __pos,
           traits_type::length(__str));
      }

      constexpr size_type
      find_last_not_of(basic_string_view __str,
         size_type __pos = npos) const noexcept
      { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }

      constexpr size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;

      constexpr size_type
      find_last_not_of(const _CharT* __str,
         size_type __pos, size_type __n) const noexcept;

      __attribute__((__nonnull__)) constexpr size_type
      find_last_not_of(const _CharT* __str,
         size_type __pos = npos) const noexcept
      {
 return this->find_last_not_of(__str, __pos,
          traits_type::length(__str));
      }

    private:

      static constexpr int
      _S_compare(size_type __n1, size_type __n2) noexcept
      {
 const difference_type __diff = __n1 - __n2;
 if (__diff > std::numeric_limits<int>::max())
   return std::numeric_limits<int>::max();
 if (__diff < std::numeric_limits<int>::min())
   return std::numeric_limits<int>::min();
 return static_cast<int>(__diff);
      }

      size_t _M_len;
      const _CharT* _M_str;
    };
# 482 "/usr/include/c++/10/string_view" 3
  template<typename _CharT, typename _Traits>
    constexpr bool
    operator==(basic_string_view<_CharT, _Traits> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.size() == __y.size() && __x.compare(__y) == 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator==(basic_string_view<_CharT, _Traits> __x,
               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return __x.size() == __y.size() && __x.compare(__y) == 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator==(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.size() == __y.size() && __x.compare(__y) == 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator!=(basic_string_view<_CharT, _Traits> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return !(__x == __y); }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator!=(basic_string_view<_CharT, _Traits> __x,
               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return !(__x == __y); }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator!=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return !(__x == __y); }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator< (basic_string_view<_CharT, _Traits> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) < 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator< (basic_string_view<_CharT, _Traits> __x,
               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return __x.compare(__y) < 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator< (__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) < 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator> (basic_string_view<_CharT, _Traits> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) > 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator> (basic_string_view<_CharT, _Traits> __x,
               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return __x.compare(__y) > 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator> (__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) > 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator<=(basic_string_view<_CharT, _Traits> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) <= 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator<=(basic_string_view<_CharT, _Traits> __x,
               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return __x.compare(__y) <= 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator<=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) <= 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator>=(basic_string_view<_CharT, _Traits> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) >= 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator>=(basic_string_view<_CharT, _Traits> __x,
               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return __x.compare(__y) >= 0; }

  template<typename _CharT, typename _Traits>
    constexpr bool
    operator>=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
               basic_string_view<_CharT, _Traits> __y) noexcept
    { return __x.compare(__y) >= 0; }


  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        basic_string_view<_CharT,_Traits> __str)
    { return __ostream_insert(__os, __str.data(), __str.size()); }




  using string_view = basic_string_view<char>;

  using wstring_view = basic_string_view<wchar_t>;




  using u16string_view = basic_string_view<char16_t>;
  using u32string_view = basic_string_view<char32_t>;



  template<typename _Tp>
    struct hash;

  template<>
    struct hash<string_view>
    : public __hash_base<size_t, string_view>
    {
      size_t
      operator()(const string_view& __str) const noexcept
      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
    };

  template<>
    struct __is_fast_hash<hash<string_view>> : std::false_type
    { };


  template<>
    struct hash<wstring_view>
    : public __hash_base<size_t, wstring_view>
    {
      size_t
      operator()(const wstring_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(wchar_t)); }
    };

  template<>
    struct __is_fast_hash<hash<wstring_view>> : std::false_type
    { };
# 665 "/usr/include/c++/10/string_view" 3
  template<>
    struct hash<u16string_view>
    : public __hash_base<size_t, u16string_view>
    {
      size_t
      operator()(const u16string_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char16_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u16string_view>> : std::false_type
    { };

  template<>
    struct hash<u32string_view>
    : public __hash_base<size_t, u32string_view>
    {
      size_t
      operator()(const u32string_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char32_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u32string_view>> : std::false_type
    { };

  inline namespace literals
  {
  inline namespace string_view_literals
  {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"
    inline constexpr basic_string_view<char>
    operator""sv(const char* __str, size_t __len) noexcept
    { return basic_string_view<char>{__str, __len}; }


    inline constexpr basic_string_view<wchar_t>
    operator""sv(const wchar_t* __str, size_t __len) noexcept
    { return basic_string_view<wchar_t>{__str, __len}; }
# 715 "/usr/include/c++/10/string_view" 3
    inline constexpr basic_string_view<char16_t>
    operator""sv(const char16_t* __str, size_t __len) noexcept
    { return basic_string_view<char16_t>{__str, __len}; }

    inline constexpr basic_string_view<char32_t>
    operator""sv(const char32_t* __str, size_t __len) noexcept
    { return basic_string_view<char32_t>{__str, __len}; }

#pragma GCC diagnostic pop
  }
  }
# 737 "/usr/include/c++/10/string_view" 3

}

# 1 "/usr/include/c++/10/bits/string_view.tcc" 1 3
# 37 "/usr/include/c++/10/bits/string_view.tcc" 3
       
# 38 "/usr/include/c++/10/bits/string_view.tcc" 3



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


  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
    {
      ;

      if (__n == 0)
 return __pos <= this->_M_len ? __pos : npos;

      if (__n <= this->_M_len)
 {
   for (; __pos <= this->_M_len - __n; ++__pos)
     if (traits_type::eq(this->_M_str[__pos], __str[0])
  && traits_type::compare(this->_M_str + __pos + 1,
     __str + 1, __n - 1) == 0)
       return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find(_CharT __c, size_type __pos) const noexcept
    {
      size_type __ret = npos;
      if (__pos < this->_M_len)
 {
   const size_type __n = this->_M_len - __pos;
   const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
   if (__p)
     __ret = __p - this->_M_str;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
    {
      ;

      if (__n <= this->_M_len)
 {
   __pos = std::min(size_type(this->_M_len - __n), __pos);
   do
     {
       if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    rfind(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->_M_len;
      if (__size > 0)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(this->_M_str[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_of(const _CharT* __str, size_type __pos,
    size_type __n) const noexcept
    {
      ;
      for (; __n && __pos < this->_M_len; ++__pos)
 {
   const _CharT* __p = traits_type::find(__str, __n,
      this->_M_str[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_of(const _CharT* __str, size_type __pos,
   size_type __n) const noexcept
    {
      ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__str, __n, this->_M_str[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_not_of(const _CharT* __str, size_type __pos,
        size_type __n) const noexcept
    {
      ;
      for (; __pos < this->_M_len; ++__pos)
 if (!traits_type::find(__str, __n, this->_M_str[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_not_of(_CharT __c, size_type __pos) const noexcept
    {
      for (; __pos < this->_M_len; ++__pos)
 if (!traits_type::eq(this->_M_str[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_not_of(const _CharT* __str, size_type __pos,
       size_type __n) const noexcept
    {
      ;
      size_type __size = this->_M_len;
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__str, __n, this->_M_str[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_not_of(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->_M_len;
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(this->_M_str[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }


}
# 741 "/usr/include/c++/10/string_view" 2 3
# 49 "/usr/include/c++/10/bits/basic_string.h" 2 3



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



namespace __cxx11 {
# 76 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_CharT>::other _Char_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;


    public:
      typedef _Traits traits_type;
      typedef typename _Traits::char_type value_type;
      typedef _Char_alloc_type allocator_type;
      typedef typename _Alloc_traits::size_type size_type;
      typedef typename _Alloc_traits::difference_type difference_type;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
       const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;


      static const size_type npos = static_cast<size_type>(-1);

    protected:




      typedef const_iterator __const_iterator;


    private:


      typedef basic_string_view<_CharT, _Traits> __sv_type;

      template<typename _Tp, typename _Res>
 using _If_sv = enable_if_t<
   __and_<is_convertible<const _Tp&, __sv_type>,
   __not_<is_convertible<const _Tp*, const basic_string*>>,
   __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
   _Res>;


      static __sv_type
      _S_to_string_view(__sv_type __svt) noexcept
      { return __svt; }





      struct __sv_wrapper
      {
 explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
 __sv_type _M_sv;
      };







      explicit
      basic_string(__sv_wrapper __svw, const _Alloc& __a)
      : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }



      struct _Alloc_hider : allocator_type
      {




 _Alloc_hider(pointer __dat, const _Alloc& __a)
 : allocator_type(__a), _M_p(__dat) { }

 _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
 : allocator_type(std::move(__a)), _M_p(__dat) { }


 pointer _M_p;
      };

      _Alloc_hider _M_dataplus;
      size_type _M_string_length;

      enum { _S_local_capacity = 15 / sizeof(_CharT) };

      union
      {
 _CharT _M_local_buf[_S_local_capacity + 1];
 size_type _M_allocated_capacity;
      };

      void
      _M_data(pointer __p)
      { _M_dataplus._M_p = __p; }

      void
      _M_length(size_type __length)
      { _M_string_length = __length; }

      pointer
      _M_data() const
      { return _M_dataplus._M_p; }

      pointer
      _M_local_data()
      {

 return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);



      }

      const_pointer
      _M_local_data() const
      {

 return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);



      }

      void
      _M_capacity(size_type __capacity)
      { _M_allocated_capacity = __capacity; }

      void
      _M_set_length(size_type __n)
      {
 _M_length(__n);
 traits_type::assign(_M_data()[__n], _CharT());
      }

      bool
      _M_is_local() const
      { return _M_data() == _M_local_data(); }


      pointer
      _M_create(size_type&, size_type);

      void
      _M_dispose()
      {
 if (!_M_is_local())
   _M_destroy(_M_allocated_capacity);
      }

      void
      _M_destroy(size_type __size) throw()
      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }



      template<typename _InIterator>
        void
        _M_construct_aux(_InIterator __beg, _InIterator __end,
    std::__false_type)
 {
          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
          _M_construct(__beg, __end, _Tag());
 }



      template<typename _Integer>
        void
        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
 { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }

      void
      _M_construct_aux_2(size_type __req, _CharT __c)
      { _M_construct(__req, __c); }

      template<typename _InIterator>
        void
        _M_construct(_InIterator __beg, _InIterator __end)
 {
   typedef typename std::__is_integer<_InIterator>::__type _Integral;
   _M_construct_aux(__beg, __end, _Integral());
        }


      template<typename _InIterator>
        void
        _M_construct(_InIterator __beg, _InIterator __end,
       std::input_iterator_tag);



      template<typename _FwdIterator>
        void
        _M_construct(_FwdIterator __beg, _FwdIterator __end,
       std::forward_iterator_tag);

      void
      _M_construct(size_type __req, _CharT __c);

      allocator_type&
      _M_get_allocator()
      { return _M_dataplus; }

      const allocator_type&
      _M_get_allocator() const
      { return _M_dataplus; }

    private:
# 309 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      _M_check(size_type __pos, const char* __s) const
      {
 if (__pos > this->size())
   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)")
                                         ,
       __s, __pos, this->size());
 return __pos;
      }

      void
      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
      {
 if (this->max_size() - (this->size() - __n1) < __n2)
   __throw_length_error((__s));
      }



      size_type
      _M_limit(size_type __pos, size_type __off) const noexcept
      {
 const bool __testoff = __off < this->size() - __pos;
 return __testoff ? __off : this->size() - __pos;
      }


      bool
      _M_disjunct(const _CharT* __s) const noexcept
      {
 return (less<const _CharT*>()(__s, _M_data())
  || less<const _CharT*>()(_M_data() + this->size(), __s));
      }



      static void
      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::copy(__d, __s, __n);
      }

      static void
      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::move(__d, __s, __n);
      }

      static void
      _S_assign(_CharT* __d, size_type __n, _CharT __c)
      {
 if (__n == 1)
   traits_type::assign(*__d, __c);
 else
   traits_type::assign(__d, __n, __c);
      }



      template<class _Iterator>
        static void
        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
        {
   for (; __k1 != __k2; ++__k1, (void)++__p)
     traits_type::assign(*__p, *__k1);
 }

      static void
      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
      noexcept
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
      { _S_copy(__p, __k1, __k2 - __k1); }

      static void
      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
      noexcept
      { _S_copy(__p, __k1, __k2 - __k1); }

      static int
      _S_compare(size_type __n1, size_type __n2) noexcept
      {
 const difference_type __d = difference_type(__n1 - __n2);

 if (__d > __gnu_cxx::__numeric_traits<int>::__max)
   return __gnu_cxx::__numeric_traits<int>::__max;
 else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
   return __gnu_cxx::__numeric_traits<int>::__min;
 else
   return int(__d);
      }

      void
      _M_assign(const basic_string&);

      void
      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
  size_type __len2);

      void
      _M_erase(size_type __pos, size_type __n);

    public:







      basic_string()
      noexcept(is_nothrow_default_constructible<_Alloc>::value)
      : _M_dataplus(_M_local_data())
      { _M_set_length(0); }




      explicit
      basic_string(const _Alloc& __a) noexcept
      : _M_dataplus(_M_local_data(), __a)
      { _M_set_length(0); }





      basic_string(const basic_string& __str)
      : _M_dataplus(_M_local_data(),
      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
      { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
# 461 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string(const basic_string& __str, size_type __pos,
     const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      {
 const _CharT* __start = __str._M_data()
   + __str._M_check(__pos, "basic_string::basic_string");
 _M_construct(__start, __start + __str._M_limit(__pos, npos));
      }







      basic_string(const basic_string& __str, size_type __pos,
     size_type __n)
      : _M_dataplus(_M_local_data())
      {
 const _CharT* __start = __str._M_data()
   + __str._M_check(__pos, "basic_string::basic_string");
 _M_construct(__start, __start + __str._M_limit(__pos, __n));
      }
# 492 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string(const basic_string& __str, size_type __pos,
     size_type __n, const _Alloc& __a)
      : _M_dataplus(_M_local_data(), __a)
      {
 const _CharT* __start
   = __str._M_data() + __str._M_check(__pos, "string::string");
 _M_construct(__start, __start + __str._M_limit(__pos, __n));
      }
# 510 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string(const _CharT* __s, size_type __n,
     const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__s, __s + __n); }
# 523 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename = _RequireAllocator<_Alloc>>

      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
# 538 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename = _RequireAllocator<_Alloc>>

      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__n, __c); }
# 552 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string(basic_string&& __str) noexcept
      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
      {
 if (__str._M_is_local())
   {
     traits_type::copy(_M_local_buf, __str._M_local_buf,
         _S_local_capacity + 1);
   }
 else
   {
     _M_data(__str._M_data());
     _M_capacity(__str._M_allocated_capacity);
   }




 _M_length(__str.length());
 __str._M_data(__str._M_local_data());
 __str._M_set_length(0);
      }






      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__l.begin(), __l.end()); }

      basic_string(const basic_string& __str, const _Alloc& __a)
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__str.begin(), __str.end()); }

      basic_string(basic_string&& __str, const _Alloc& __a)
      noexcept(_Alloc_traits::_S_always_equal())
      : _M_dataplus(_M_local_data(), __a)
      {
 if (__str._M_is_local())
   {
     traits_type::copy(_M_local_buf, __str._M_local_buf,
         _S_local_capacity + 1);
     _M_length(__str.length());
     __str._M_set_length(0);
   }
 else if (_Alloc_traits::_S_always_equal()
     || __str.get_allocator() == __a)
   {
     _M_data(__str._M_data());
     _M_length(__str.length());
     _M_capacity(__str._M_allocated_capacity);
     __str._M_data(__str._M_local_buf);
     __str._M_set_length(0);
   }
 else
   _M_construct(__str.begin(), __str.end());
      }
# 620 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>



        basic_string(_InputIterator __beg, _InputIterator __end,
       const _Alloc& __a = _Alloc())
 : _M_dataplus(_M_local_data(), __a)
 { _M_construct(__beg, __end); }
# 638 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp, typename = _If_sv<_Tp, void>>
 basic_string(const _Tp& __t, size_type __pos, size_type __n,
       const _Alloc& __a = _Alloc())
 : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }






      template<typename _Tp, typename = _If_sv<_Tp, void>>
 explicit
 basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
 : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }





      ~basic_string()
      { _M_dispose(); }





      basic_string&
      operator=(const basic_string& __str)
      {
 return this->assign(__str);
      }





      basic_string&
      operator=(const _CharT* __s)
      { return this->assign(__s); }
# 685 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 702 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      operator=(basic_string&& __str)
      noexcept(_Alloc_traits::_S_nothrow_move())
      {
 if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
     && !_Alloc_traits::_S_always_equal()
     && _M_get_allocator() != __str._M_get_allocator())
   {

     _M_destroy(_M_allocated_capacity);
     _M_data(_M_local_data());
     _M_set_length(0);
   }

 std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());

 if (__str._M_is_local())
   {

     if (__str.size())
       this->_S_copy(_M_data(), __str._M_data(), __str.size());
     _M_set_length(__str.size());
   }
 else if (_Alloc_traits::_S_propagate_on_move_assign()
     || _Alloc_traits::_S_always_equal()
     || _M_get_allocator() == __str._M_get_allocator())
   {

     pointer __data = nullptr;
     size_type __capacity;
     if (!_M_is_local())
       {
  if (_Alloc_traits::_S_always_equal())
    {

      __data = _M_data();
      __capacity = _M_allocated_capacity;
    }
  else
    _M_destroy(_M_allocated_capacity);
       }

     _M_data(__str._M_data());
     _M_length(__str.length());
     _M_capacity(__str._M_allocated_capacity);
     if (__data)
       {
  __str._M_data(__data);
  __str._M_capacity(__capacity);
       }
     else
       __str._M_data(__str._M_local_buf);
   }
 else
   assign(__str);
 __str.clear();
 return *this;
      }





      basic_string&
      operator=(initializer_list<_CharT> __l)
      {
 this->assign(__l.begin(), __l.size());
 return *this;
      }







     template<typename _Tp>
       _If_sv<_Tp, basic_string&>
       operator=(const _Tp& __svt)
       { return this->assign(__svt); }





      operator __sv_type() const noexcept
      { return __sv_type(data(), size()); }







      iterator
      begin() noexcept
      { return iterator(_M_data()); }





      const_iterator
      begin() const noexcept
      { return const_iterator(_M_data()); }





      iterator
      end() noexcept
      { return iterator(_M_data() + this->size()); }





      const_iterator
      end() const noexcept
      { return const_iterator(_M_data() + this->size()); }






      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(this->end()); }






      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->end()); }






      reverse_iterator
      rend() noexcept
      { return reverse_iterator(this->begin()); }






      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->begin()); }






      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_data()); }





      const_iterator
      cend() const noexcept
      { return const_iterator(this->_M_data() + this->size()); }






      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->end()); }






      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->begin()); }


    public:



      size_type
      size() const noexcept
      { return _M_string_length; }



      size_type
      length() const noexcept
      { return _M_string_length; }


      size_type
      max_size() const noexcept
      { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
# 925 "/usr/include/c++/10/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 938 "/usr/include/c++/10/bits/basic_string.h" 3
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }



      void
      shrink_to_fit() noexcept
      {

 if (capacity() > size())
   {
     try
       { reserve(0); }
     catch(...)
       { }
   }

      }






      size_type
      capacity() const noexcept
      {
 return _M_is_local() ? size_type(_S_local_capacity)
                      : _M_allocated_capacity;
      }
# 987 "/usr/include/c++/10/bits/basic_string.h" 3
      void
      reserve(size_type __res_arg = 0);




      void
      clear() noexcept
      { _M_set_length(0); }





      [[__nodiscard__]] bool
      empty() const noexcept
      { return this->size() == 0; }
# 1016 "/usr/include/c++/10/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const noexcept
      {
 do { if (! (__pos <= size())) std::__replacement_assert("/usr/include/c++/10/bits/basic_string.h", 1019, __PRETTY_FUNCTION__, "__pos <= size()"); } while (false);
 return _M_data()[__pos];
      }
# 1033 "/usr/include/c++/10/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {


 do { if (! (__pos <= size())) std::__replacement_assert("/usr/include/c++/10/bits/basic_string.h", 1038, __PRETTY_FUNCTION__, "__pos <= size()"); } while (false);

 ;
 return _M_data()[__pos];
      }
# 1054 "/usr/include/c++/10/bits/basic_string.h" 3
      const_reference
      at(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")

                            ,
       __n, this->size());
 return _M_data()[__n];
      }
# 1075 "/usr/include/c++/10/bits/basic_string.h" 3
      reference
      at(size_type __n)
      {
 if (__n >= size())
   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")

                            ,
       __n, this->size());
 return _M_data()[__n];
      }






      reference
      front() noexcept
      {
 do { if (! (!empty())) std::__replacement_assert("/usr/include/c++/10/bits/basic_string.h", 1094, __PRETTY_FUNCTION__, "!empty()"); } while (false);
 return operator[](0);
      }





      const_reference
      front() const noexcept
      {
 do { if (! (!empty())) std::__replacement_assert("/usr/include/c++/10/bits/basic_string.h", 1105, __PRETTY_FUNCTION__, "!empty()"); } while (false);
 return operator[](0);
      }





      reference
      back() noexcept
      {
 do { if (! (!empty())) std::__replacement_assert("/usr/include/c++/10/bits/basic_string.h", 1116, __PRETTY_FUNCTION__, "!empty()"); } while (false);
 return operator[](this->size() - 1);
      }





      const_reference
      back() const noexcept
      {
 do { if (! (!empty())) std::__replacement_assert("/usr/include/c++/10/bits/basic_string.h", 1127, __PRETTY_FUNCTION__, "!empty()"); } while (false);
 return operator[](this->size() - 1);
      }
# 1138 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      operator+=(const basic_string& __str)
      { return this->append(__str); }






      basic_string&
      operator+=(const _CharT* __s)
      { return this->append(__s); }






      basic_string&
      operator+=(_CharT __c)
      {
 this->push_back(__c);
 return *this;
      }







      basic_string&
      operator+=(initializer_list<_CharT> __l)
      { return this->append(__l.begin(), __l.size()); }
# 1180 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 operator+=(const _Tp& __svt)
 { return this->append(__svt); }







      basic_string&
      append(const basic_string& __str)
      { return _M_append(__str._M_data(), __str.size()); }
# 1208 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      append(const basic_string& __str, size_type __pos, size_type __n = npos)
      { return _M_append(__str._M_data()
    + __str._M_check(__pos, "basic_string::append"),
    __str._M_limit(__pos, __n)); }







      basic_string&
      append(const _CharT* __s, size_type __n)
      {
 ;
 _M_check_length(size_type(0), __n, "basic_string::append");
 return _M_append(__s, __n);
      }






      basic_string&
      append(const _CharT* __s)
      {
 ;
 const size_type __n = traits_type::length(__s);
 _M_check_length(size_type(0), __n, "basic_string::append");
 return _M_append(__s, __n);
      }
# 1250 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      append(size_type __n, _CharT __c)
      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }







      basic_string&
      append(initializer_list<_CharT> __l)
      { return this->append(__l.begin(), __l.size()); }
# 1274 "/usr/include/c++/10/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>



        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(end(), end(), __first, __last); }







      template<typename _Tp>
        _If_sv<_Tp, basic_string&>
        append(const _Tp& __svt)
        {
          __sv_type __sv = __svt;
          return this->append(__sv.data(), __sv.size());
        }
# 1304 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
        _If_sv<_Tp, basic_string&>
 append(const _Tp& __svt, size_type __pos, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return _M_append(__sv.data()
       + std::__sv_check(__sv.size(), __pos, "basic_string::append"),
       std::__sv_limit(__sv.size(), __pos, __n));
 }






      void
      push_back(_CharT __c)
      {
 const size_type __size = this->size();
 if (__size + 1 > this->capacity())
   this->_M_mutate(__size, size_type(0), 0, size_type(1));
 traits_type::assign(this->_M_data()[__size], __c);
 this->_M_set_length(__size + 1);
      }






      basic_string&
      assign(const basic_string& __str)
      {

 if (_Alloc_traits::_S_propagate_on_copy_assign())
   {
     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
  && _M_get_allocator() != __str._M_get_allocator())
       {


  if (__str.size() <= _S_local_capacity)
    {
      _M_destroy(_M_allocated_capacity);
      _M_data(_M_local_data());
      _M_set_length(0);
    }
  else
    {
      const auto __len = __str.size();
      auto __alloc = __str._M_get_allocator();

      auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
      _M_destroy(_M_allocated_capacity);
      _M_data(__ptr);
      _M_capacity(__len);
      _M_set_length(__len);
    }
       }
     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
   }

 this->_M_assign(__str);
 return *this;
      }
# 1379 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      assign(basic_string&& __str)
      noexcept(_Alloc_traits::_S_nothrow_move())
      {


 return *this = std::move(__str);
      }
# 1402 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n = npos)
      { return _M_replace(size_type(0), this->size(), __str._M_data()
     + __str._M_check(__pos, "basic_string::assign"),
     __str._M_limit(__pos, __n)); }
# 1418 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n)
      {
 ;
 return _M_replace(size_type(0), this->size(), __s, __n);
      }
# 1434 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s)
      {
 ;
 return _M_replace(size_type(0), this->size(), __s,
     traits_type::length(__s));
      }
# 1451 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1464 "/usr/include/c++/10/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>



        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(begin(), end(), __first, __last); }







      basic_string&
      assign(initializer_list<_CharT> __l)
      { return this->assign(__l.begin(), __l.size()); }
# 1490 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 assign(const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->assign(__sv.data(), __sv.size());
 }
# 1505 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return _M_replace(size_type(0), this->size(),
       __sv.data()
       + std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
       std::__sv_limit(__sv.size(), __pos, __n));
 }
# 1533 "/usr/include/c++/10/bits/basic_string.h" 3
      iterator
      insert(const_iterator __p, size_type __n, _CharT __c)
      {
 ;
 const size_type __pos = __p - begin();
 this->replace(__p, __p, __n, __c);
 return iterator(this->_M_data() + __pos);
      }
# 1575 "/usr/include/c++/10/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 iterator
        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
        {
   ;
   const size_type __pos = __p - begin();
   this->replace(__p, __p, __beg, __end);
   return iterator(this->_M_data() + __pos);
 }
# 1611 "/usr/include/c++/10/bits/basic_string.h" 3
      iterator
      insert(const_iterator __p, initializer_list<_CharT> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }
# 1638 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      { return this->replace(__pos1, size_type(0),
        __str._M_data(), __str.size()); }
# 1661 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos1, const basic_string& __str,
      size_type __pos2, size_type __n = npos)
      { return this->replace(__pos1, size_type(0), __str._M_data()
        + __str._M_check(__pos2, "basic_string::insert"),
        __str._M_limit(__pos2, __n)); }
# 1684 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n)
      { return this->replace(__pos, size_type(0), __s, __n); }
# 1703 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
 ;
 return this->replace(__pos, size_type(0), __s,
        traits_type::length(__s));
      }
# 1727 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
         size_type(0), __n, __c); }
# 1745 "/usr/include/c++/10/bits/basic_string.h" 3
      iterator
      insert(__const_iterator __p, _CharT __c)
      {
 ;
 const size_type __pos = __p - begin();
 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
 return iterator(_M_data() + __pos);
      }
# 1761 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 insert(size_type __pos, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->insert(__pos, __sv.data(), __sv.size());
 }
# 1777 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 insert(size_type __pos1, const _Tp& __svt,
        size_type __pos2, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos1, size_type(0),
       __sv.data()
       + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
       std::__sv_limit(__sv.size(), __pos2, __n));
 }
# 1805 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      {
 _M_check(__pos, "basic_string::erase");
 if (__n == npos)
   this->_M_set_length(__pos);
 else if (__n != 0)
   this->_M_erase(__pos, _M_limit(__pos, __n));
 return *this;
      }
# 1824 "/usr/include/c++/10/bits/basic_string.h" 3
      iterator
      erase(__const_iterator __position)
      {

                           ;
 const size_type __pos = __position - begin();
 this->_M_erase(__pos, size_type(1));
 return iterator(_M_data() + __pos);
      }
# 1843 "/usr/include/c++/10/bits/basic_string.h" 3
      iterator
      erase(__const_iterator __first, __const_iterator __last)
      {

                        ;
        const size_type __pos = __first - begin();
 if (__last == end())
   this->_M_set_length(__pos);
 else
   this->_M_erase(__pos, __last - __first);
 return iterator(this->_M_data() + __pos);
      }







      void
      pop_back() noexcept
      {
 do { if (! (!empty())) std::__replacement_assert("/usr/include/c++/10/bits/basic_string.h", 1865, __PRETTY_FUNCTION__, "!empty()"); } while (false);
 _M_erase(size() - 1, 1);
      }
# 1887 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 1909 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2 = npos)
      { return this->replace(__pos1, __n1, __str._M_data()
        + __str._M_check(__pos2, "basic_string::replace"),
        __str._M_limit(__pos2, __n2)); }
# 1934 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2)
      {
 ;
 return _M_replace(_M_check(__pos, "basic_string::replace"),
     _M_limit(__pos, __n1), __s, __n2);
      }
# 1959 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
 ;
 return this->replace(__pos, __n1, __s, traits_type::length(__s));
      }
# 1983 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
         _M_limit(__pos, __n1), __n2, __c); }
# 2001 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const basic_string& __str)
      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 2021 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const _CharT* __s, size_type __n)
      {

                      ;
 return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
      }
# 2043 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
      {
 ;
 return this->replace(__i1, __i2, __s, traits_type::length(__s));
      }
# 2064 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
       _CharT __c)
      {

                      ;
 return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
      }
# 2089 "/usr/include/c++/10/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
        basic_string&
        replace(const_iterator __i1, const_iterator __i2,
  _InputIterator __k1, _InputIterator __k2)
        {
  
                        ;
   ;
   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
        std::__false_type());
 }
# 2121 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       _CharT* __k1, _CharT* __k2)
      {

                      ;
 ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const _CharT* __k1, const _CharT* __k2)
      {

                      ;
 ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       iterator __k1, iterator __k2)
      {

                      ;
 ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }

      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const_iterator __k1, const_iterator __k2)
      {

                      ;
 ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }
# 2180 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string& replace(const_iterator __i1, const_iterator __i2,
       initializer_list<_CharT> __l)
      { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
# 2193 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 replace(size_type __pos, size_type __n, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos, __n, __sv.data(), __sv.size());
 }
# 2210 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 replace(size_type __pos1, size_type __n1, const _Tp& __svt,
  size_type __pos2, size_type __n2 = npos)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos1, __n1,
       __sv.data()
       + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
       std::__sv_limit(__sv.size(), __pos2, __n2));
 }
# 2231 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, basic_string&>
 replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->replace(__i1 - begin(), __i2 - __i1, __sv);
 }


    private:
      template<class _Integer>
 basic_string&
 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
       _Integer __n, _Integer __val, __true_type)
        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }

      template<class _InputIterator>
 basic_string&
 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
       _InputIterator __k1, _InputIterator __k2,
       __false_type);

      basic_string&
      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
       _CharT __c);

      basic_string&
      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
   const size_type __len2);

      basic_string&
      _M_append(const _CharT* __s, size_type __n);

    public:
# 2278 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 2288 "/usr/include/c++/10/bits/basic_string.h" 3
      void
      swap(basic_string& __s) noexcept;
# 2298 "/usr/include/c++/10/bits/basic_string.h" 3
      const _CharT*
      c_str() const noexcept
      { return _M_data(); }
# 2310 "/usr/include/c++/10/bits/basic_string.h" 3
      const _CharT*
      data() const noexcept
      { return _M_data(); }
# 2321 "/usr/include/c++/10/bits/basic_string.h" 3
      _CharT*
      data() noexcept
      { return _M_data(); }





      allocator_type
      get_allocator() const noexcept
      { return _M_get_allocator(); }
# 2345 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2359 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find(__str.data(), __pos, __str.size()); }
# 2371 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, size_type>
 find(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find(__sv.data(), __pos, __sv.size());
 }
# 2391 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos = 0) const noexcept
      {
 ;
 return this->find(__s, __pos, traits_type::length(__s));
      }
# 2408 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const noexcept;
# 2421 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->rfind(__str.data(), __pos, __str.size()); }
# 2433 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, size_type>
 rfind(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->rfind(__sv.data(), __pos, __sv.size());
 }
# 2455 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2469 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->rfind(__s, __pos, traits_type::length(__s));
      }
# 2486 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const noexcept;
# 2500 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find_first_of(__str.data(), __pos, __str.size()); }
# 2513 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, size_type>
 find_first_of(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_first_of(__sv.data(), __pos, __sv.size());
 }
# 2535 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2549 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      noexcept
      {
 ;
 return this->find_first_of(__s, __pos, traits_type::length(__s));
      }
# 2569 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
      { return this->find(__c, __pos); }
# 2584 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->find_last_of(__str.data(), __pos, __str.size()); }
# 2597 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, size_type>
 find_last_of(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_last_of(__sv.data(), __pos, __sv.size());
 }
# 2619 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2633 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      noexcept
      {
 ;
 return this->find_last_of(__s, __pos, traits_type::length(__s));
      }
# 2653 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
      { return this->rfind(__c, __pos); }
# 2667 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
# 2680 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, size_type>
 find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_first_not_of(__sv.data(), __pos, __sv.size());
 }
# 2702 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const noexcept;
# 2716 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
      noexcept
      {
 ;
 return this->find_first_not_of(__s, __pos, traits_type::length(__s));
      }
# 2734 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const
      noexcept;
# 2749 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
# 2762 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, size_type>
 find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_last_not_of(__sv.data(), __pos, __sv.size());
 }
# 2784 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const noexcept;
# 2798 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
      noexcept
      {
 ;
 return this->find_last_not_of(__s, __pos, traits_type::length(__s));
      }
# 2816 "/usr/include/c++/10/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const
      noexcept;
# 2832 "/usr/include/c++/10/bits/basic_string.h" 3
      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      { return basic_string(*this,
       _M_check(__pos, "basic_string::substr"), __n); }
# 2851 "/usr/include/c++/10/bits/basic_string.h" 3
      int
      compare(const basic_string& __str) const
      {
 const size_type __size = this->size();
 const size_type __osize = __str.size();
 const size_type __len = std::min(__size, __osize);

 int __r = traits_type::compare(_M_data(), __str.data(), __len);
 if (!__r)
   __r = _S_compare(__size, __osize);
 return __r;
      }







      template<typename _Tp>
 _If_sv<_Tp, int>
 compare(const _Tp& __svt) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   const size_type __size = this->size();
   const size_type __osize = __sv.size();
   const size_type __len = std::min(__size, __osize);

   int __r = traits_type::compare(_M_data(), __sv.data(), __len);
   if (!__r)
     __r = _S_compare(__size, __osize);
   return __r;
 }
# 2894 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, int>
 compare(size_type __pos, size_type __n, const _Tp& __svt) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return __sv_type(*this).substr(__pos, __n).compare(__sv);
 }
# 2913 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename _Tp>
 _If_sv<_Tp, int>
 compare(size_type __pos1, size_type __n1, const _Tp& __svt,
  size_type __pos2, size_type __n2 = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return __sv_type(*this)
     .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
 }
# 2944 "/usr/include/c++/10/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 2970 "/usr/include/c++/10/bits/basic_string.h" 3
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2 = npos) const;
# 2988 "/usr/include/c++/10/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const noexcept;
# 3012 "/usr/include/c++/10/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 3039 "/usr/include/c++/10/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const;
# 3070 "/usr/include/c++/10/bits/basic_string.h" 3
      template<typename, typename, typename> friend class basic_stringbuf;
    };
}
# 5985 "/usr/include/c++/10/bits/basic_string.h" 3
namespace __cxx11 {
  template<typename _InputIterator, typename _CharT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;



  template<typename _CharT, typename _Traits,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
      -> basic_string<_CharT, _Traits, _Allocator>;

  template<typename _CharT, typename _Traits,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(basic_string_view<_CharT, _Traits>,
   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
   const _Allocator& = _Allocator())
      -> basic_string<_CharT, _Traits, _Allocator>;
}
# 6020 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
       const basic_string<_CharT,_Traits,_Alloc>& __rhs);







  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const _CharT* __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str(__lhs);
      __str.append(__size_type(1), __rhs);
      return __str;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return std::move(__lhs.append(__rhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    {

      using _Alloc_traits = allocator_traits<_Alloc>;
      bool __use_rhs = false;
      if constexpr (typename _Alloc_traits::is_always_equal{})
 __use_rhs = true;
      else if (__lhs.get_allocator() == __rhs.get_allocator())
 __use_rhs = true;
      if (__use_rhs)

 {
   const auto __size = __lhs.size() + __rhs.size();
   if (__size > __lhs.capacity() && __size <= __rhs.capacity())
     return std::move(__rhs.insert(0, __lhs));
 }
      return std::move(__lhs.append(__rhs));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const _CharT* __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(_CharT __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, 1, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       const _CharT* __rhs)
    { return std::move(__lhs.append(__rhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       _CharT __rhs)
    { return std::move(__lhs.append(1, __rhs)); }
# 6151 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    { return __lhs.compare(__rhs) == 0; }

  template<typename _CharT>
    inline
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
    operator==(const basic_string<_CharT>& __lhs,
        const basic_string<_CharT>& __rhs) noexcept
    { return (__lhs.size() == __rhs.size()
       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
          __lhs.size())); }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const _CharT* __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) == 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) == 0; }
# 6198 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    { return !(__lhs == __rhs); }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const _CharT* __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return !(__lhs == __rhs); }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return !(__lhs == __rhs); }
# 6236 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    { return __lhs.compare(__rhs) < 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const _CharT* __rhs)
    { return __lhs.compare(__rhs) < 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const _CharT* __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) > 0; }
# 6274 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    { return __lhs.compare(__rhs) > 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const _CharT* __rhs)
    { return __lhs.compare(__rhs) > 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const _CharT* __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) < 0; }
# 6312 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    { return __lhs.compare(__rhs) <= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) <= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const _CharT* __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) >= 0; }
# 6350 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    { return __lhs.compare(__rhs) >= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) >= 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const _CharT* __lhs,
      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) <= 0; }
# 6388 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline void
    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
  basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }
# 6408 "/usr/include/c++/10/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);
# 6426 "/usr/include/c++/10/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());
    }
# 6449 "/usr/include/c++/10/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);
# 6466 "/usr/include/c++/10/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str)
    { return std::getline(__is, __str, __is.widen('\n')); }



  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>&& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    { return std::getline(__is, __str, __delim); }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>&& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str)
    { return std::getline(__is, __str); }


  template<>
    basic_istream<char>&
    getline(basic_istream<char>& __in, basic_string<char>& __str,
     char __delim);


  template<>
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
     wchar_t __delim);



}



# 1 "/usr/include/c++/10/ext/string_conversions.h" 1 3
# 32 "/usr/include/c++/10/ext/string_conversions.h" 3
       
# 33 "/usr/include/c++/10/ext/string_conversions.h" 3
# 41 "/usr/include/c++/10/ext/string_conversions.h" 3
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 42 "/usr/include/c++/10/ext/string_conversions.h" 2 3
# 1 "/usr/include/c++/10/cwchar" 1 3
# 39 "/usr/include/c++/10/cwchar" 3
       
# 40 "/usr/include/c++/10/cwchar" 3
# 43 "/usr/include/c++/10/ext/string_conversions.h" 2 3
# 1 "/usr/include/c++/10/cstdio" 1 3
# 39 "/usr/include/c++/10/cstdio" 3
       
# 40 "/usr/include/c++/10/cstdio" 3


# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/stdio.h" 2 3 4

extern "C" {



# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stdarg.h" 1 3 4
# 37 "/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;
# 40 "/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;
# 41 "/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)];
};
# 44 "/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;
# 47 "/usr/include/stdio.h" 2 3 4





typedef __gnuc_va_list va_list;
# 86 "/usr/include/stdio.h" 3 4
typedef __fpos64_t fpos_t;


typedef __fpos64_t fpos64_t;
# 133 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 134 "/usr/include/stdio.h" 2 3 4



extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;






extern int remove (const char *__filename) throw ();

extern int rename (const char *__old, const char *__new) throw ();



extern int renameat (int __oldfd, const char *__old, int __newfd,
       const char *__new) throw ();
# 164 "/usr/include/stdio.h" 3 4
extern int renameat2 (int __oldfd, const char *__old, int __newfd,
        const char *__new, unsigned int __flags) throw ();
# 176 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") __attribute__ ((__warn_unused_result__));






extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));



extern char *tmpnam (char *__s) throw () __attribute__ ((__warn_unused_result__));




extern char *tmpnam_r (char *__s) throw () __attribute__ ((__warn_unused_result__));
# 204 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));







extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);
# 227 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 237 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
# 257 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __asm__ ("" "fopen64")

  __attribute__ ((__warn_unused_result__));
extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")


  __attribute__ ((__warn_unused_result__));






extern FILE *fopen64 (const char *__restrict __filename,
        const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
extern FILE *freopen64 (const char *__restrict __filename,
   const char *__restrict __modes,
   FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));




extern FILE *fdopen (int __fd, const char *__modes) throw () __attribute__ ((__warn_unused_result__));





extern FILE *fopencookie (void *__restrict __magic_cookie,
     const char *__restrict __modes,
     cookie_io_functions_t __io_funcs) throw () __attribute__ ((__warn_unused_result__));




extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
  throw () __attribute__ ((__warn_unused_result__));




extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () __attribute__ ((__warn_unused_result__));





extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) throw ();




extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) throw ();


extern void setlinebuf (FILE *__stream) throw ();







extern int fprintf (FILE *__restrict __stream,
      const char *__restrict __format, ...);




extern int printf (const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
      const char *__restrict __format, ...) throw ();





extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
       __gnuc_va_list __arg);




extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, const char *__restrict __format,
       __gnuc_va_list __arg) throw ();



extern int snprintf (char *__restrict __s, size_t __maxlen,
       const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));





extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
        __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
extern int __asprintf (char **__restrict __ptr,
         const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
extern int asprintf (char **__restrict __ptr,
       const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));




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__ ((__warn_unused_result__));




extern int scanf (const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));

extern int sscanf (const char *__restrict __s,
     const char *__restrict __format, ...) throw ();






extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")

                          __attribute__ ((__warn_unused_result__));
extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
                         __attribute__ ((__warn_unused_result__));
extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) throw () __asm__ ("" "__isoc99_sscanf")

                      ;
# 432 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
      __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));





extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));


extern int vsscanf (const char *__restrict __s,
      const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));




extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")



     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")

     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vsscanf")



     __attribute__ ((__format__ (__scanf__, 2, 0)));
# 485 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);






extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 510 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
# 521 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);
# 537 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);







extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
     __attribute__ ((__warn_unused_result__));
# 587 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
# 603 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
                             size_t *__restrict __n, int __delimiter,
                             FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern __ssize_t getdelim (char **__restrict __lineptr,
                           size_t *__restrict __n, int __delimiter,
                           FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));







extern __ssize_t getline (char **__restrict __lineptr,
                          size_t *__restrict __n,
                          FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));







extern int fputs (const char *__restrict __s, FILE *__restrict __stream);





extern int puts (const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));




extern size_t fwrite (const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s);
# 662 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
      FILE *__restrict __stream);
# 673 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream);







extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__));




extern void rewind (FILE *__stream);
# 715 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64")

                  ;
extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");
# 739 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64")
                                          ;
extern int fsetpos (FILE *__stream, const fpos_t *__pos) __asm__ ("" "fsetpos64")
                                                          ;







extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__));
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);



extern void clearerr (FILE *__stream) throw ();

extern int feof (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));

extern int ferror (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));



extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
extern int ferror_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));







extern void perror (const char *__s);





# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];


extern int _sys_nerr;
extern const char *const _sys_errlist[];
# 782 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));




extern int fileno_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
# 800 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) __attribute__ ((__warn_unused_result__));





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) throw ();





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
      const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       const char *__restrict __format,
       __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) throw ();



extern int ftrylockfile (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));


extern void funlockfile (FILE *__stream) throw ();
# 858 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);




# 1 "/usr/include/bits/stdio.h" 1 3 4
# 46 "/usr/include/bits/stdio.h" 3 4
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
__attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x0010) != 0);
}


extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x0020) != 0);
}
# 865 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/include/bits/stdio2.h" 1 3 4
# 26 "/usr/include/bits/stdio2.h" 3 4
extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
     const char *__restrict __format, ...) throw ();
extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
      const char *__restrict __format,
      __gnuc_va_list __ap) throw ();


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) sprintf (char *__restrict __s, const char *__restrict __fmt, ...) throw ()
{
  return __builtin___sprintf_chk (__s, 2 - 1,
      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
}






extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) vsprintf (char *__restrict __s, const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __builtin___vsprintf_chk (__s, 2 - 1,
       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
}



extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
      size_t __slen, const char *__restrict __format,
      ...) throw ();
extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
       size_t __slen, const char *__restrict __format,
       __gnuc_va_list __ap) throw ();


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) snprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, ...) throw ()

{
  return __builtin___snprintf_chk (__s, __n, 2 - 1,
       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
}






extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) vsnprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
}





extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
     const char *__restrict __format, ...);
extern int __printf_chk (int __flag, const char *__restrict __format, ...);
extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
      const char *__restrict __format, __gnuc_va_list __ap);
extern int __vprintf_chk (int __flag, const char *__restrict __format,
     __gnuc_va_list __ap);


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...)
{
  return __fprintf_chk (__stream, 2 - 1, __fmt,
   __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
printf (const char *__restrict __fmt, ...)
{
  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
}







extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
vprintf (const char *__restrict __fmt, __gnuc_va_list __ap)
{

  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);



}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
vfprintf (FILE *__restrict __stream,
   const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
}


extern int __dprintf_chk (int __fd, int __flag, const char *__restrict __fmt,
     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
extern int __vdprintf_chk (int __fd, int __flag,
      const char *__restrict __fmt, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 3, 0)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
dprintf (int __fd, const char *__restrict __fmt, ...)
{
  return __dprintf_chk (__fd, 2 - 1, __fmt,
   __builtin_va_arg_pack ());
}





extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
}




extern int __asprintf_chk (char **__restrict __ptr, int __flag,
      const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
       const char *__restrict __fmt, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
     int __flag, const char *__restrict __format,
     ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
      int __flag,
      const char *__restrict __format,
      __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) throw ()
{
  return __asprintf_chk (__ptr, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) __asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) throw ()

{
  return __asprintf_chk (__ptr, 2 - 1, __fmt,
    __builtin_va_arg_pack ());
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __fmt, ...) throw ()

{
  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
          __builtin_va_arg_pack ());
}
# 209 "/usr/include/bits/stdio2.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) vasprintf (char **__restrict __ptr, const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
__attribute__ ((__leaf__)) obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __fmt, __gnuc_va_list __ap) throw ()

{
  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
    __ap);
}
# 243 "/usr/include/bits/stdio2.h" 3 4
extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")

                                        __attribute__ ((__warn_unused_result__));
extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
 return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
    }
  return __fgets_alias (__s, __n, __stream);
}

extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
      size_t __size, size_t __n,
      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")


            __attribute__ ((__warn_unused_result__));
extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")




     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
fread (void *__restrict __ptr, size_t __size, size_t __n,
       FILE *__restrict __stream)
{
  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size)
   || !__builtin_constant_p (__n)
   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
 return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);

      if (__size * __n > __builtin_object_size (__ptr, 0))
 return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
    }
  return __fread_alias (__ptr, __size, __n, __stream);
}


extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")

                                                 __attribute__ ((__warn_unused_result__));
extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")


     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) char *
fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
{
  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n) || __n <= 0)
 return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);

      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
 return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
    }
  return __fgets_unlocked_alias (__s, __n, __stream);
}




extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
        size_t __size, size_t __n,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")


                     __attribute__ ((__warn_unused_result__));
extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")




     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
                                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) size_t
fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
  FILE *__restrict __stream)
{
  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__size)
   || !__builtin_constant_p (__n)
   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
 return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
         __stream);

      if (__size * __n > __builtin_object_size (__ptr, 0))
 return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
       __stream);
    }


  if (__builtin_constant_p (__size)
      && __builtin_constant_p (__n)
      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
      && __size * __n <= 8)
    {
      size_t __cnt = __size * __n;
      char *__cptr = (char *) __ptr;
      if (__cnt == 0)
 return 0;

      for (; __cnt > 0; --__cnt)
 {
   int __c = getc_unlocked (__stream);
   if (__c == (-1))
     break;
   *__cptr++ = __c;
 }
      return (__cptr - (char *) __ptr) / __size;
    }

  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
}
# 868 "/usr/include/stdio.h" 2 3 4





}
# 43 "/usr/include/c++/10/cstdio" 2 3
# 96 "/usr/include/c++/10/cstdio" 3
namespace std
{
  using ::FILE;
  using ::fpos_t;

  using ::clearerr;
  using ::fclose;
  using ::feof;
  using ::ferror;
  using ::fflush;
  using ::fgetc;
  using ::fgetpos;
  using ::fgets;
  using ::fopen;
  using ::fprintf;
  using ::fputc;
  using ::fputs;
  using ::fread;
  using ::freopen;
  using ::fscanf;
  using ::fseek;
  using ::fsetpos;
  using ::ftell;
  using ::fwrite;
  using ::getc;
  using ::getchar;




  using ::perror;
  using ::printf;
  using ::putc;
  using ::putchar;
  using ::puts;
  using ::remove;
  using ::rename;
  using ::rewind;
  using ::scanf;
  using ::setbuf;
  using ::setvbuf;
  using ::sprintf;
  using ::sscanf;
  using ::tmpfile;

  using ::tmpnam;

  using ::ungetc;
  using ::vfprintf;
  using ::vprintf;
  using ::vsprintf;
}
# 157 "/usr/include/c++/10/cstdio" 3
namespace __gnu_cxx
{
# 175 "/usr/include/c++/10/cstdio" 3
  using ::snprintf;
  using ::vfscanf;
  using ::vscanf;
  using ::vsnprintf;
  using ::vsscanf;

}

namespace std
{
  using ::__gnu_cxx::snprintf;
  using ::__gnu_cxx::vfscanf;
  using ::__gnu_cxx::vscanf;
  using ::__gnu_cxx::vsnprintf;
  using ::__gnu_cxx::vsscanf;
}
# 44 "/usr/include/c++/10/ext/string_conversions.h" 2 3
# 1 "/usr/include/c++/10/cerrno" 1 3
# 39 "/usr/include/c++/10/cerrno" 3
       
# 40 "/usr/include/c++/10/cerrno" 3


# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
# 1 "/usr/include/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) throw () __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/include/c++/10/cerrno" 2 3
# 45 "/usr/include/c++/10/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);
    }


}
# 6506 "/usr/include/c++/10/bits/basic_string.h" 2 3
# 1 "/usr/include/c++/10/bits/charconv.h" 1 3
# 33 "/usr/include/c++/10/bits/charconv.h" 3
       
# 34 "/usr/include/c++/10/bits/charconv.h" 3





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

namespace __detail
{

  template<typename _Tp>
    constexpr unsigned
    __to_chars_len(_Tp __value, int __base = 10) noexcept
    {
      static_assert(is_integral<_Tp>::value, "implementation bug");
      static_assert(is_unsigned<_Tp>::value, "implementation bug");

      unsigned __n = 1;
      const unsigned __b2 = __base * __base;
      const unsigned __b3 = __b2 * __base;
      const unsigned long __b4 = __b3 * __base;
      for (;;)
 {
   if (__value < (unsigned)__base) return __n;
   if (__value < __b2) return __n + 1;
   if (__value < __b3) return __n + 2;
   if (__value < __b4) return __n + 3;
   __value /= __b4;
   __n += 4;
 }
    }




  template<typename _Tp>
    void
    __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept
    {
      static_assert(is_integral<_Tp>::value, "implementation bug");
      static_assert(is_unsigned<_Tp>::value, "implementation bug");

      static constexpr char __digits[201] =
 "0001020304050607080910111213141516171819"
 "2021222324252627282930313233343536373839"
 "4041424344454647484950515253545556575859"
 "6061626364656667686970717273747576777879"
 "8081828384858687888990919293949596979899";
      unsigned __pos = __len - 1;
      while (__val >= 100)
 {
   auto const __num = (__val % 100) * 2;
   __val /= 100;
   __first[__pos] = __digits[__num + 1];
   __first[__pos - 1] = __digits[__num];
   __pos -= 2;
 }
      if (__val >= 10)
 {
   auto const __num = __val * 2;
   __first[1] = __digits[__num + 1];
   __first[0] = __digits[__num];
 }
      else
 __first[0] = '0' + __val;
    }

}

}
# 6507 "/usr/include/c++/10/bits/basic_string.h" 2 3

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

namespace __cxx11 {



  inline int
  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
     __idx, __base); }

  inline long
  stol(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
        __idx, __base); }

  inline unsigned long
  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
        __idx, __base); }

  inline long long
  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
        __idx, __base); }

  inline unsigned long long
  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
        __idx, __base); }


  inline float
  stof(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }

  inline double
  stod(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }

  inline long double
  stold(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }




  inline string
  to_string(int __val)
  {
    const bool __neg = __val < 0;
    const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str(__neg + __len, '-');
    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
    return __str;
  }

  inline string
  to_string(unsigned __val)
  {
    string __str(__detail::__to_chars_len(__val), '\0');
    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
    return __str;
  }

  inline string
  to_string(long __val)
  {
    const bool __neg = __val < 0;
    const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str(__neg + __len, '-');
    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
    return __str;
  }

  inline string
  to_string(unsigned long __val)
  {
    string __str(__detail::__to_chars_len(__val), '\0');
    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
    return __str;
  }

  inline string
  to_string(long long __val)
  {
    const bool __neg = __val < 0;
    const unsigned long long __uval
      = __neg ? (unsigned long long)~__val + 1ull : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str(__neg + __len, '-');
    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
    return __str;
  }

  inline string
  to_string(unsigned long long __val)
  {
    string __str(__detail::__to_chars_len(__val), '\0');
    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
    return __str;
  }




  inline string
  to_string(float __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%f", __val);
  }

  inline string
  to_string(double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%f", __val);
  }

  inline string
  to_string(long double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%Lf", __val);
  }



  inline int
  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
     __idx, __base); }

  inline long
  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
        __idx, __base); }

  inline unsigned long
  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
        __idx, __base); }

  inline long long
  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
        __idx, __base); }

  inline unsigned long long
  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
        __idx, __base); }


  inline float
  stof(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }

  inline double
  stod(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }

  inline long double
  stold(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }



  inline wstring
  to_wstring(int __val)
  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
         L"%d", __val); }

  inline wstring
  to_wstring(unsigned __val)
  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
         4 * sizeof(unsigned),
         L"%u", __val); }

  inline wstring
  to_wstring(long __val)
  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
         L"%ld", __val); }

  inline wstring
  to_wstring(unsigned long __val)
  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
         4 * sizeof(unsigned long),
         L"%lu", __val); }

  inline wstring
  to_wstring(long long __val)
  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
         4 * sizeof(long long),
         L"%lld", __val); }

  inline wstring
  to_wstring(unsigned long long __val)
  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
         4 * sizeof(unsigned long long),
         L"%llu", __val); }

  inline wstring
  to_wstring(float __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
         L"%f", __val);
  }

  inline wstring
  to_wstring(double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
         L"%f", __val);
  }

  inline wstring
  to_wstring(long double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
         L"%Lf", __val);
  }



}

}







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






  template<>
    struct hash<string>
    : public __hash_base<size_t, string>
    {
      size_t
      operator()(const string& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
    };

  template<>
    struct __is_fast_hash<hash<string>> : std::false_type
    { };



  template<>
    struct hash<wstring>
    : public __hash_base<size_t, wstring>
    {
      size_t
      operator()(const wstring& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(wchar_t)); }
    };

  template<>
    struct __is_fast_hash<hash<wstring>> : std::false_type
    { };
# 6816 "/usr/include/c++/10/bits/basic_string.h" 3
  template<>
    struct hash<u16string>
    : public __hash_base<size_t, u16string>
    {
      size_t
      operator()(const u16string& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char16_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u16string>> : std::false_type
    { };


  template<>
    struct hash<u32string>
    : public __hash_base<size_t, u32string>
    {
      size_t
      operator()(const u32string& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char32_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u32string>> : std::false_type
    { };





  inline namespace literals
  {
  inline namespace string_literals
  {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"
    __attribute ((__abi_tag__ ("cxx11")))
    inline basic_string<char>
    operator""s(const char* __str, size_t __len)
    { return basic_string<char>{__str, __len}; }


    __attribute ((__abi_tag__ ("cxx11")))
    inline basic_string<wchar_t>
    operator""s(const wchar_t* __str, size_t __len)
    { return basic_string<wchar_t>{__str, __len}; }
# 6874 "/usr/include/c++/10/bits/basic_string.h" 3
    __attribute ((__abi_tag__ ("cxx11")))
    inline basic_string<char16_t>
    operator""s(const char16_t* __str, size_t __len)
    { return basic_string<char16_t>{__str, __len}; }

    __attribute ((__abi_tag__ ("cxx11")))
    inline basic_string<char32_t>
    operator""s(const char32_t* __str, size_t __len)
    { return basic_string<char32_t>{__str, __len}; }

#pragma GCC diagnostic pop
  }
  }


  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Traits, typename _Alloc>
      struct _Never_valueless_alt<std::basic_string<_Tp, _Traits, _Alloc>>
      : __and_<
 is_nothrow_move_constructible<std::basic_string<_Tp, _Traits, _Alloc>>,
 is_nothrow_move_assignable<std::basic_string<_Tp, _Traits, _Alloc>>
 >::type
      { };
  }




}
# 56 "/usr/include/c++/10/string" 2 3
# 1 "/usr/include/c++/10/bits/basic_string.tcc" 1 3
# 42 "/usr/include/c++/10/bits/basic_string.tcc" 3
       
# 43 "/usr/include/c++/10/bits/basic_string.tcc" 3



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




  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::npos;

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    swap(basic_string& __s) noexcept
    {
      if (this == &__s)
 return;

      _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());

      if (_M_is_local())
 if (__s._M_is_local())
   {
     if (length() && __s.length())
       {
  _CharT __tmp_data[_S_local_capacity + 1];
  traits_type::copy(__tmp_data, __s._M_local_buf,
      _S_local_capacity + 1);
  traits_type::copy(__s._M_local_buf, _M_local_buf,
      _S_local_capacity + 1);
  traits_type::copy(_M_local_buf, __tmp_data,
      _S_local_capacity + 1);
       }
     else if (__s.length())
       {
  traits_type::copy(_M_local_buf, __s._M_local_buf,
      _S_local_capacity + 1);
  _M_length(__s.length());
  __s._M_set_length(0);
  return;
       }
     else if (length())
       {
  traits_type::copy(__s._M_local_buf, _M_local_buf,
      _S_local_capacity + 1);
  __s._M_length(length());
  _M_set_length(0);
  return;
       }
   }
 else
   {
     const size_type __tmp_capacity = __s._M_allocated_capacity;
     traits_type::copy(__s._M_local_buf, _M_local_buf,
         _S_local_capacity + 1);
     _M_data(__s._M_data());
     __s._M_data(__s._M_local_buf);
     _M_capacity(__tmp_capacity);
   }
      else
 {
   const size_type __tmp_capacity = _M_allocated_capacity;
   if (__s._M_is_local())
     {
       traits_type::copy(_M_local_buf, __s._M_local_buf,
    _S_local_capacity + 1);
       __s._M_data(_M_data());
       _M_data(_M_local_buf);
     }
   else
     {
       pointer __tmp_ptr = _M_data();
       _M_data(__s._M_data());
       __s._M_data(__tmp_ptr);
       _M_capacity(__s._M_allocated_capacity);
     }
   __s._M_capacity(__tmp_capacity);
 }

      const size_type __tmp_length = length();
      _M_length(__s.length());
      __s._M_length(__tmp_length);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::pointer
    basic_string<_CharT, _Traits, _Alloc>::
    _M_create(size_type& __capacity, size_type __old_capacity)
    {


      if (__capacity > max_size())
 std::__throw_length_error(("basic_string::_M_create"));




      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
 {
   __capacity = 2 * __old_capacity;

   if (__capacity > max_size())
     __capacity = max_size();
 }



      return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
    }





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      void
      basic_string<_CharT, _Traits, _Alloc>::
      _M_construct(_InIterator __beg, _InIterator __end,
     std::input_iterator_tag)
      {
 size_type __len = 0;
 size_type __capacity = size_type(_S_local_capacity);

 while (__beg != __end && __len < __capacity)
   {
     _M_data()[__len++] = *__beg;
     ++__beg;
   }

 try
   {
     while (__beg != __end)
       {
  if (__len == __capacity)
    {

      __capacity = __len + 1;
      pointer __another = _M_create(__capacity, __len);
      this->_S_copy(__another, _M_data(), __len);
      _M_dispose();
      _M_data(__another);
      _M_capacity(__capacity);
    }
  _M_data()[__len++] = *__beg;
  ++__beg;
       }
   }
 catch(...)
   {
     _M_dispose();
     throw;
   }

 _M_set_length(__len);
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      void
      basic_string<_CharT, _Traits, _Alloc>::
      _M_construct(_InIterator __beg, _InIterator __end,
     std::forward_iterator_tag)
      {

 if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
   std::__throw_logic_error(("basic_string::" "_M_construct null not valid")
                                         );

 size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));

 if (__dnew > size_type(_S_local_capacity))
   {
     _M_data(_M_create(__dnew, size_type(0)));
     _M_capacity(__dnew);
   }


 try
   { this->_S_copy_chars(_M_data(), __beg, __end); }
 catch(...)
   {
     _M_dispose();
     throw;
   }

 _M_set_length(__dnew);
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_construct(size_type __n, _CharT __c)
    {
      if (__n > size_type(_S_local_capacity))
 {
   _M_data(_M_create(__n, size_type(0)));
   _M_capacity(__n);
 }

      if (__n)
 this->_S_assign(_M_data(), __n, __c);

      _M_set_length(__n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_assign(const basic_string& __str)
    {
      if (this != &__str)
 {
   const size_type __rsize = __str.length();
   const size_type __capacity = capacity();

   if (__rsize > __capacity)
     {
       size_type __new_capacity = __rsize;
       pointer __tmp = _M_create(__new_capacity, __capacity);
       _M_dispose();
       _M_data(__tmp);
       _M_capacity(__new_capacity);
     }

   if (__rsize)
     this->_S_copy(_M_data(), __str._M_data(), __rsize);

   _M_set_length(__rsize);
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    reserve(size_type __res)
    {

      if (__res < length())
 __res = length();

      const size_type __capacity = capacity();
      if (__res != __capacity)
 {
   if (__res > __capacity
       || __res > size_type(_S_local_capacity))
     {
       pointer __tmp = _M_create(__res, __capacity);
       this->_S_copy(__tmp, _M_data(), length() + 1);
       _M_dispose();
       _M_data(__tmp);
       _M_capacity(__res);
     }
   else if (!_M_is_local())
     {
       this->_S_copy(_M_local_data(), _M_data(), length() + 1);
       _M_destroy(__capacity);
       _M_data(_M_local_data());
     }
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
       size_type __len2)
    {
      const size_type __how_much = length() - __pos - __len1;

      size_type __new_capacity = length() + __len2 - __len1;
      pointer __r = _M_create(__new_capacity, capacity());

      if (__pos)
 this->_S_copy(__r, _M_data(), __pos);
      if (__s && __len2)
 this->_S_copy(__r + __pos, __s, __len2);
      if (__how_much)
 this->_S_copy(__r + __pos + __len2,
        _M_data() + __pos + __len1, __how_much);

      _M_dispose();
      _M_data(__r);
      _M_capacity(__new_capacity);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_erase(size_type __pos, size_type __n)
    {
      const size_type __how_much = length() - __pos - __n;

      if (__how_much && __n)
 this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);

      _M_set_length(length() - __n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    resize(size_type __n, _CharT __c)
    {
      const size_type __size = this->size();
      if (__size < __n)
 this->append(__n - __size, __c);
      else if (__n < __size)
 this->_M_set_length(__n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_append(const _CharT* __s, size_type __n)
    {
      const size_type __len = __n + this->size();

      if (__len <= this->capacity())
 {
   if (__n)
     this->_S_copy(this->_M_data() + this->size(), __s, __n);
 }
      else
 this->_M_mutate(this->size(), size_type(0), __s, __n);

      this->_M_set_length(__len);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIterator>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
     _InputIterator __k1, _InputIterator __k2,
     std::__false_type)
      {


 const basic_string __s(__k1, __k2, this->get_allocator());
 const size_type __n1 = __i2 - __i1;
 return _M_replace(__i1 - begin(), __n1, __s._M_data(),
     __s.size());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
     _CharT __c)
    {
      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");

      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __n2 - __n1;

      if (__new_size <= this->capacity())
 {
   pointer __p = this->_M_data() + __pos1;

   const size_type __how_much = __old_size - __pos1 - __n1;
   if (__how_much && __n1 != __n2)
     this->_S_move(__p + __n2, __p + __n1, __how_much);
 }
      else
 this->_M_mutate(__pos1, __n1, 0, __n2);

      if (__n2)
 this->_S_assign(this->_M_data() + __pos1, __n2, __c);

      this->_M_set_length(__new_size);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
        const size_type __len2)
    {
      _M_check_length(__len1, __len2, "basic_string::_M_replace");

      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;

      if (__new_size <= this->capacity())
 {
   pointer __p = this->_M_data() + __pos;

   const size_type __how_much = __old_size - __pos - __len1;
   if (_M_disjunct(__s))
     {
       if (__how_much && __len1 != __len2)
  this->_S_move(__p + __len2, __p + __len1, __how_much);
       if (__len2)
  this->_S_copy(__p, __s, __len2);
     }
   else
     {

       if (__len2 && __len2 <= __len1)
  this->_S_move(__p, __s, __len2);
       if (__how_much && __len1 != __len2)
  this->_S_move(__p + __len2, __p + __len1, __how_much);
       if (__len2 > __len1)
  {
    if (__s + __len2 <= __p + __len1)
      this->_S_move(__p, __s, __len2);
    else if (__s >= __p + __len1)
      this->_S_copy(__p, __s + __len2 - __len1, __len2);
    else
      {
        const size_type __nleft = (__p + __len1) - __s;
        this->_S_move(__p, __s, __nleft);
        this->_S_copy(__p + __nleft, __p + __len2,
        __len2 - __nleft);
      }
  }
     }
 }
      else
 this->_M_mutate(__pos, __len1, __s, __len2);

      this->_M_set_length(__new_size);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      _M_check(__pos, "basic_string::copy");
      __n = _M_limit(__pos, __n);
      ;
      if (__n)
 _S_copy(__s, _M_data() + __pos, __n);

      return __n;
    }
# 1158 "/usr/include/c++/10/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const _CharT* __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      ;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_CharT>::other _Char_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
      const __size_type __len = _Traits::length(__lhs);
      __string_type __str(_Alloc_traits::_S_select_on_copy(
          __rhs.get_allocator()));
      __str.reserve(__len + __rhs.size());
      __str.append(__lhs, __len);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_CharT>::other _Char_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
      __string_type __str(_Alloc_traits::_S_select_on_copy(
          __rhs.get_allocator()));
      const __size_type __len = __rhs.size();
      __str.reserve(__len + 1);
      __str.append(__size_type(1), __lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
      ;
      const size_type __size = this->size();

      if (__n == 0)
 return __pos <= __size ? __pos : npos;
      if (__pos >= __size)
 return npos;

      const _CharT __elem0 = __s[0];
      const _CharT* const __data = data();
      const _CharT* __first = __data + __pos;
      const _CharT* const __last = __data + __size;
      size_type __len = __size - __pos;

      while (__len >= __n)
 {

   __first = traits_type::find(__first, __len - __n + 1, __elem0);
   if (!__first)
     return npos;



   if (traits_type::compare(__first, __s, __n) == 0)
     return __first - __data;
   __len = __last - ++__first;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const noexcept
    {
      size_type __ret = npos;
      const size_type __size = this->size();
      if (__pos < __size)
 {
   const _CharT* __data = _M_data();
   const size_type __n = __size - __pos;
   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
   if (__p)
     __ret = __p - __data;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
      ;
      const size_type __size = this->size();
      if (__n <= __size)
 {
   __pos = std::min(size_type(__size - __n), __pos);
   const _CharT* __data = _M_data();
   do
     {
       if (traits_type::compare(__data + __pos, __s, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(_M_data()[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
      ;
      for (; __n && __pos < this->size(); ++__pos)
 {
   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
      ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
      ;
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::find(__s, __n, _M_data()[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const noexcept
    {
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::eq(_M_data()[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
      ;
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(_M_data()[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n, const basic_string& __str) const
    {
      _M_check(__pos, "basic_string::compare");
      __n = _M_limit(__pos, __n);
      const size_type __osize = __str.size();
      const size_type __len = std::min(__n, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
      if (!__r)
 __r = _S_compare(__n, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos1, size_type __n1, const basic_string& __str,
     size_type __pos2, size_type __n2) const
    {
      _M_check(__pos1, "basic_string::compare");
      __str._M_check(__pos2, "basic_string::compare");
      __n1 = _M_limit(__pos1, __n1);
      __n2 = __str._M_limit(__pos2, __n2);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos1,
         __str.data() + __pos2, __len);
      if (!__r)
 __r = _S_compare(__n1, __n2);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(const _CharT* __s) const noexcept
    {
      ;
      const size_type __size = this->size();
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__size, __osize);
      int __r = traits_type::compare(_M_data(), __s, __len);
      if (!__r)
 __r = _S_compare(__size, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s) const
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__n1, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = _S_compare(__n1, __osize);
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s,
     size_type __n2) const
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = _S_compare(__n1, __n2);
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
        basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;
      typedef ctype<_CharT> __ctype_type;
      typedef typename __ctype_type::ctype_base __ctype_base;

      __size_type __extracted = 0;
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       __str.erase();
       _CharT __buf[128];
       __size_type __len = 0;
       const streamsize __w = __in.width();
       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
                                : __str.max_size();
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(__ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    if (__len == sizeof(__buf) / sizeof(_CharT))
      {
        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
        __len = 0;
      }
    __buf[__len++] = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }
       __str.append(__buf, __len);

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }

      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   try
     {
       __str.erase();
       const __int_type __idelim = _Traits::to_int_type(__delim);
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !_Traits::eq_int_type(__c, __idelim))
  {
    __str += _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       else if (_Traits::eq_int_type(__c, __idelim))
  {
    ++__extracted;
    __in.rdbuf()->sbumpc();
  }
       else
  __err |= __ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }
      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }
# 1626 "/usr/include/c++/10/bits/basic_string.tcc" 3
  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&);
# 1647 "/usr/include/c++/10/bits/basic_string.tcc" 3
  extern template
    basic_istream<wchar_t>&
    operator>>(basic_istream<wchar_t>&, wstring&);
  extern template
    basic_ostream<wchar_t>&
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&);




}
# 57 "/usr/include/c++/10/string" 2 3


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

  namespace pmr {
    template<typename _Tp> class polymorphic_allocator;
    template<typename _CharT, typename _Traits = char_traits<_CharT>>
      using basic_string = std::basic_string<_CharT, _Traits,
          polymorphic_allocator<_CharT>>;
    using string = basic_string<char>;



    using u16string = basic_string<char16_t>;
    using u32string = basic_string<char32_t>;

    using wstring = basic_string<wchar_t>;

  }

  template<typename _Str>
    struct __hash_string_base
    : public __hash_base<size_t, _Str>
    {
      size_t
      operator()(const _Str& __s) const noexcept
      { return hash<basic_string_view<typename _Str::value_type>>{}(__s); }
    };

  template<>
    struct hash<pmr::string>
    : public __hash_string_base<pmr::string>
    { };






  template<>
    struct hash<pmr::u16string>
    : public __hash_string_base<pmr::u16string>
    { };
  template<>
    struct hash<pmr::u32string>
    : public __hash_string_base<pmr::u32string>
    { };

  template<>
    struct hash<pmr::wstring>
    : public __hash_string_base<pmr::wstring>
    { };



}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view_fwd.hpp" 2 3 4

namespace boost {

    template<typename charT, typename traits = std::char_traits<charT> > class basic_string_view;
    typedef basic_string_view<char, std::char_traits<char> > string_view;
    typedef basic_string_view<wchar_t, std::char_traits<wchar_t> > wstring_view;


    typedef basic_string_view<char16_t, std::char_traits<char16_t> > u16string_view;



    typedef basic_string_view<char32_t, std::char_traits<char32_t> > u32string_view;


}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/throw_exception.hpp" 1 3 4



       
# 5 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/throw_exception.hpp" 3
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/throw_exception.hpp" 3
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/exception.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/exception.hpp" 3 4
       
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/exception.hpp" 3
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/exception.hpp" 3
namespace boost { template <class T> class shared_ptr; };
namespace boost { namespace exception_detail { using boost::shared_ptr; } }


namespace
boost
    {
    namespace
    exception_detail
        {
        template <class T>
        class
        refcount_ptr
            {
            public:

            refcount_ptr():
                px_(0)
                {
                }

            ~refcount_ptr()
                {
                release();
                }

            refcount_ptr( refcount_ptr const & x ):
                px_(x.px_)
                {
                add_ref();
                }

            refcount_ptr &
            operator=( refcount_ptr const & x )
                {
                adopt(x.px_);
                return *this;
                }

            void
            adopt( T * px )
                {
                release();
                px_=px;
                add_ref();
                }

            T *
            get() const
                {
                return px_;
                }

            private:

            T * px_;

            void
            add_ref()
                {
                if( px_ )
                    px_->add_ref();
                }

            void
            release()
                {
                if( px_ && px_->release() )
                    px_=0;
                }
            };
        }



    template <class Tag,class T>
    class error_info;

    typedef error_info<struct throw_function_,char const *> throw_function;
    typedef error_info<struct throw_file_,char const *> throw_file;
    typedef error_info<struct throw_line_,int> throw_line;

    template <>
    class
    error_info<throw_function_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_file_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_line_,int>
        {
        public:
        typedef int value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };



#pragma GCC visibility push (default)


    class exception;


#pragma GCC visibility pop



    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() throw()
                {
                }
            };

        template <class>
        struct get_info;

        template <>
        struct get_info<throw_function>;

        template <>
        struct get_info<throw_file>;

        template <>
        struct get_info<throw_line>;

        template <class>
        struct set_info_rv;

        template <>
        struct set_info_rv<throw_function>;

        template <>
        struct set_info_rv<throw_file>;

        template <>
        struct set_info_rv<throw_line>;

        char const * get_diagnostic_information( exception const &, char const * );

        void copy_boost_exception( exception *, exception const * );

        template <class E,class Tag,class T>
        E const & set_info( E const &, error_info<Tag,T> const & );

        template <class E>
        E const & set_info( E const &, throw_function const & );

        template <class E>
        E const & set_info( E const &, throw_file const & );

        template <class E>
        E const & set_info( E const &, throw_line const & );
        }



#pragma GCC visibility push (default)


    class
    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)
            {
            }
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/exception.hpp" 3
        virtual ~exception() throw()

            = 0

            ;




        private:

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_function const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_file const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_line const & );

        template <class E,class Tag,class T>
        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );

        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );

        template <class>
        friend struct exception_detail::get_info;
        friend struct exception_detail::get_info<throw_function>;
        friend struct exception_detail::get_info<throw_file>;
        friend struct exception_detail::get_info<throw_line>;
        template <class>
        friend struct exception_detail::set_info_rv;
        friend struct exception_detail::set_info_rv<throw_function>;
        friend struct exception_detail::set_info_rv<throw_file>;
        friend struct exception_detail::set_info_rv<throw_line>;
        friend void exception_detail::copy_boost_exception( exception *, exception const * );

        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
        mutable char const * throw_function_;
        mutable char const * throw_file_;
        mutable int throw_line_;
        };


#pragma GCC visibility pop



    inline
    exception::
    ~exception() throw()
        {
        }

    namespace
    exception_detail
        {
        template <class E>
        E const &
        set_info( E const & x, throw_function const & y )
            {
            x.throw_function_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_file const & y )
            {
            x.throw_file_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_line const & y )
            {
            x.throw_line_=y.v_;
            return x;
            }
        }



    namespace
    exception_detail
        {


#pragma GCC visibility push (default)


        template <class T>
        struct
        error_info_injector:
            public T,
            public exception
            {
            explicit
            error_info_injector( T const & x ):
                T(x)
                {
                }

            ~error_info_injector() throw()
                {
                }
            };


#pragma GCC visibility pop



        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
        {


#pragma GCC visibility push (default)


        class
        clone_base
            {
            public:

            virtual clone_base const * clone() const = 0;
            virtual void rethrow() const = 0;

            virtual
            ~clone_base() throw()
                {
                }
            };


#pragma GCC visibility pop



        inline
        void
        copy_boost_exception( exception * a, exception const * b )
            {
            refcount_ptr<error_info_container> data;
            if( error_info_container * d=b->data_.get() )
                data = d->clone();
            a->throw_file_ = b->throw_file_;
            a->throw_line_ = b->throw_line_;
            a->throw_function_ = b->throw_function_;
            a->data_ = data;
            }

        inline
        void
        copy_boost_exception( void *, void const * )
            {
            }



#pragma GCC visibility push (default)


        template <class T>
        class
        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() throw()
                {
                }

            private:

            clone_base const *
            clone() const
                {
                return new clone_impl(*this,clone_tag());
                }

            void
            rethrow() const
                {
                throw*this;
                }
            };
        }


#pragma GCC visibility pop



    template <class T>
    inline
    exception_detail::clone_impl<T>
    enable_current_exception( T const & x )
        {
        return exception_detail::clone_impl<T>(x);
        }
    }
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/throw_exception.hpp" 2 3

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/current_function.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/current_function.hpp" 3 4
namespace boost
{

namespace detail
{

inline void current_function_helper()
{
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/current_function.hpp" 3 4
}

}

}
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/throw_exception.hpp" 2 3







namespace boost
{






inline void throw_exception_assert_compatibility( std::exception const & ) { }

template<class E> __attribute__ ((__noreturn__)) inline void throw_exception( E const & e )
{


    throw_exception_assert_compatibility(e);


    throw enable_current_exception(enable_error_info(e));



}




    namespace
    exception_detail
    {
        template <class E>
        __attribute__ ((__noreturn__))
        void
        throw_exception_( E const & x, char const * current_function, char const * file, int line )
        {
            boost::throw_exception(
                set_info(
                    set_info(
                        set_info(
                            enable_error_info(x),
                            throw_function(current_function)),
                        throw_file(file)),
                    throw_line(line)));
        }
    }

}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 2 3 4


# 1 "/usr/include/c++/10/stdexcept" 1 3 4
# 36 "/usr/include/c++/10/stdexcept" 3 4
       
# 37 "/usr/include/c++/10/stdexcept" 3




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





  struct __cow_string
  {
    union {
      const char* _M_p;
      char _M_bytes[sizeof(const char*)];
    };

    __cow_string();
    __cow_string(const std::string&);
    __cow_string(const char*, size_t);
    __cow_string(const __cow_string&) noexcept;
    __cow_string& operator=(const __cow_string&) noexcept;
    ~__cow_string();

    __cow_string(__cow_string&&) noexcept;
    __cow_string& operator=(__cow_string&&) noexcept;

  };

  typedef basic_string<char> __sso_string;
# 113 "/usr/include/c++/10/stdexcept" 3
  class logic_error : public exception
  {
    __cow_string _M_msg;

  public:

    explicit
    logic_error(const string& __arg) ;


    explicit
    logic_error(const char*) ;

    logic_error(logic_error&&) noexcept;
    logic_error& operator=(logic_error&&) noexcept;



    logic_error(const logic_error&) noexcept;
    logic_error& operator=(const logic_error&) noexcept;





    virtual ~logic_error() noexcept;



    virtual const char*
    what() const noexcept;





  };



  class domain_error : public logic_error
  {
  public:
    explicit domain_error(const string& __arg) ;

    explicit domain_error(const char*) ;
    domain_error(const domain_error&) = default;
    domain_error& operator=(const domain_error&) = default;
    domain_error(domain_error&&) = default;
    domain_error& operator=(domain_error&&) = default;

    virtual ~domain_error() noexcept;
  };


  class invalid_argument : public logic_error
  {
  public:
    explicit invalid_argument(const string& __arg) ;

    explicit invalid_argument(const char*) ;
    invalid_argument(const invalid_argument&) = default;
    invalid_argument& operator=(const invalid_argument&) = default;
    invalid_argument(invalid_argument&&) = default;
    invalid_argument& operator=(invalid_argument&&) = default;

    virtual ~invalid_argument() noexcept;
  };



  class length_error : public logic_error
  {
  public:
    explicit length_error(const string& __arg) ;

    explicit length_error(const char*) ;
    length_error(const length_error&) = default;
    length_error& operator=(const length_error&) = default;
    length_error(length_error&&) = default;
    length_error& operator=(length_error&&) = default;

    virtual ~length_error() noexcept;
  };



  class out_of_range : public logic_error
  {
  public:
    explicit out_of_range(const string& __arg) ;

    explicit out_of_range(const char*) ;
    out_of_range(const out_of_range&) = default;
    out_of_range& operator=(const out_of_range&) = default;
    out_of_range(out_of_range&&) = default;
    out_of_range& operator=(out_of_range&&) = default;

    virtual ~out_of_range() noexcept;
  };






  class runtime_error : public exception
  {
    __cow_string _M_msg;

  public:

    explicit
    runtime_error(const string& __arg) ;


    explicit
    runtime_error(const char*) ;

    runtime_error(runtime_error&&) noexcept;
    runtime_error& operator=(runtime_error&&) noexcept;



    runtime_error(const runtime_error&) noexcept;
    runtime_error& operator=(const runtime_error&) noexcept;





    virtual ~runtime_error() noexcept;



    virtual const char*
    what() const noexcept;





  };


  class range_error : public runtime_error
  {
  public:
    explicit range_error(const string& __arg) ;

    explicit range_error(const char*) ;
    range_error(const range_error&) = default;
    range_error& operator=(const range_error&) = default;
    range_error(range_error&&) = default;
    range_error& operator=(range_error&&) = default;

    virtual ~range_error() noexcept;
  };


  class overflow_error : public runtime_error
  {
  public:
    explicit overflow_error(const string& __arg) ;

    explicit overflow_error(const char*) ;
    overflow_error(const overflow_error&) = default;
    overflow_error& operator=(const overflow_error&) = default;
    overflow_error(overflow_error&&) = default;
    overflow_error& operator=(overflow_error&&) = default;

    virtual ~overflow_error() noexcept;
  };


  class underflow_error : public runtime_error
  {
  public:
    explicit underflow_error(const string& __arg) ;

    explicit underflow_error(const char*) ;
    underflow_error(const underflow_error&) = default;
    underflow_error& operator=(const underflow_error&) = default;
    underflow_error(underflow_error&&) = default;
    underflow_error& operator=(underflow_error&&) = default;

    virtual ~underflow_error() noexcept;
  };




}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 2 3 4

# 1 "/usr/include/c++/10/iterator" 1 3 4
# 58 "/usr/include/c++/10/iterator" 3 4
       
# 59 "/usr/include/c++/10/iterator" 3






# 1 "/usr/include/c++/10/bits/stream_iterator.h" 1 3
# 33 "/usr/include/c++/10/bits/stream_iterator.h" 3
       
# 34 "/usr/include/c++/10/bits/stream_iterator.h" 3



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








  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
    class istream_iterator
    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
    {
    public:
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

    private:
      istream_type* _M_stream;
      _Tp _M_value;



      bool _M_ok;

    public:

      constexpr istream_iterator()
      : _M_stream(0), _M_value(), _M_ok(false) {}


      istream_iterator(istream_type& __s)
      : _M_stream(std::__addressof(__s)), _M_ok(true)
      { _M_read(); }

      istream_iterator(const istream_iterator& __obj)
      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
        _M_ok(__obj._M_ok)
      { }


      istream_iterator& operator=(const istream_iterator&) = default;
      ~istream_iterator() = default;


      const _Tp&
      operator*() const
      {


                        ;
 return _M_value;
      }

      const _Tp*
      operator->() const { return std::__addressof((operator*())); }

      istream_iterator&
      operator++()
      {


                        ;
 _M_read();
 return *this;
      }

      istream_iterator
      operator++(int)
      {


                        ;
 istream_iterator __tmp = *this;
 _M_read();
 return __tmp;
      }

    private:
      bool
      _M_equal(const istream_iterator& __x) const
      {


 return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);
      }

      void
      _M_read()
      {
        if (_M_stream && !(*_M_stream >> _M_value))
          {
            _M_stream = 0;
            _M_ok = false;
          }
      }



      friend bool
      operator==(const istream_iterator& __x, const istream_iterator& __y)
      { return __x._M_equal(__y); }



      friend bool
      operator!=(const istream_iterator& __x, const istream_iterator& __y)
      { return !__x._M_equal(__y); }
    };
# 161 "/usr/include/c++/10/bits/stream_iterator.h" 3
  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT> >
    class ostream_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:


      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


    private:
      ostream_type* _M_stream;
      const _CharT* _M_string;

    public:






      ostream_iterator(ostream_type& __s)
      : _M_stream(std::__addressof(__s)), _M_string(0) {}
# 198 "/usr/include/c++/10/bits/stream_iterator.h" 3
      ostream_iterator(ostream_type& __s, const _CharT* __c)
      : _M_stream(std::__addressof(__s)), _M_string(__c) { }


      ostream_iterator(const ostream_iterator& __obj)
      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }


      ostream_iterator& operator=(const ostream_iterator&) = default;




      ostream_iterator&
      operator=(const _Tp& __value)
      {


                        ;
 *_M_stream << __value;
 if (_M_string)
          *_M_stream << _M_string;
 return *this;
      }

      ostream_iterator&
      operator*()
      { return *this; }

      ostream_iterator&
      operator++()
      { return *this; }

      ostream_iterator&
      operator++(int)
      { return *this; }
    };




}
# 66 "/usr/include/c++/10/iterator" 2 3
# 1 "/usr/include/c++/10/bits/streambuf_iterator.h" 1 3
# 33 "/usr/include/c++/10/bits/streambuf_iterator.h" 3
       
# 34 "/usr/include/c++/10/bits/streambuf_iterator.h" 3

# 1 "/usr/include/c++/10/streambuf" 1 3
# 36 "/usr/include/c++/10/streambuf" 3
       
# 37 "/usr/include/c++/10/streambuf" 3




# 1 "/usr/include/c++/10/bits/ios_base.h" 1 3
# 37 "/usr/include/c++/10/bits/ios_base.h" 3
       
# 38 "/usr/include/c++/10/bits/ios_base.h" 3



# 1 "/usr/include/c++/10/bits/locale_classes.h" 1 3
# 37 "/usr/include/c++/10/bits/locale_classes.h" 3
       
# 38 "/usr/include/c++/10/bits/locale_classes.h" 3





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

# 62 "/usr/include/c++/10/bits/locale_classes.h" 3
  class locale
  {
  public:


    typedef int category;


    class facet;
    class id;
    class _Impl;

    friend class facet;
    friend class _Impl;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Cache>
      friend struct __use_cache;
# 98 "/usr/include/c++/10/bits/locale_classes.h" 3
    static const category none = 0;
    static const category ctype = 1L << 0;
    static const category numeric = 1L << 1;
    static const category collate = 1L << 2;
    static const category time = 1L << 3;
    static const category monetary = 1L << 4;
    static const category messages = 1L << 5;
    static const category all = (ctype | numeric | collate |
        time | monetary | messages);
# 117 "/usr/include/c++/10/bits/locale_classes.h" 3
    locale() throw();
# 126 "/usr/include/c++/10/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 136 "/usr/include/c++/10/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 151 "/usr/include/c++/10/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 162 "/usr/include/c++/10/bits/locale_classes.h" 3
    explicit
    locale(const std::string& __s) : locale(__s.c_str()) { }
# 177 "/usr/include/c++/10/bits/locale_classes.h" 3
    locale(const locale& __base, const std::string& __s, category __cat)
    : locale(__base, __s.c_str(), __cat) { }
# 192 "/usr/include/c++/10/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 205 "/usr/include/c++/10/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


    ~locale() throw();
# 219 "/usr/include/c++/10/bits/locale_classes.h" 3
    const locale&
    operator=(const locale& __other) throw();
# 234 "/usr/include/c++/10/bits/locale_classes.h" 3
    template<typename _Facet>
      locale
      combine(const locale& __other) const;






    __attribute ((__abi_tag__ ("cxx11")))
    string
    name() const;
# 254 "/usr/include/c++/10/bits/locale_classes.h" 3
    bool
    operator==(const locale& __other) const throw();







    bool
    operator!=(const locale& __other) const throw()
    { return !(this->operator==(__other)); }
# 282 "/usr/include/c++/10/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;
# 298 "/usr/include/c++/10/bits/locale_classes.h" 3
    static locale
    global(const locale& __loc);




    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;





    static const char* const* const _S_categories;
# 333 "/usr/include/c++/10/bits/locale_classes.h" 3
    enum { _S_categories_size = 6 + 6 };


    static __gthread_once_t _S_once;


    explicit
    locale(_Impl*) throw();

    static void
    _S_initialize();

    static void
    _S_initialize_once() throw();

    static category
    _S_normalize_category(category);

    void
    _M_coalesce(const locale& __base, const locale& __add, category __cat);


    static const id* const _S_twinned_facets[];

  };
# 371 "/usr/include/c++/10/bits/locale_classes.h" 3
  class locale::facet
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    mutable _Atomic_word _M_refcount;


    static __c_locale _S_c_locale;


    static const char _S_c_name[2];


    static __gthread_once_t _S_once;


    static void
    _S_initialize_once();

  protected:
# 402 "/usr/include/c++/10/bits/locale_classes.h" 3
    explicit
    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
    { }


    virtual
    ~facet();

    static void
    _S_create_c_locale(__c_locale& __cloc, const char* __s,
         __c_locale __old = 0);

    static __c_locale
    _S_clone_c_locale(__c_locale& __cloc) throw();

    static void
    _S_destroy_c_locale(__c_locale& __cloc);

    static __c_locale
    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);



    static __c_locale
    _S_get_c_locale();

    __attribute__ ((__const__)) static const char*
    _S_get_c_name() throw();
# 438 "/usr/include/c++/10/bits/locale_classes.h" 3
    facet(const facet&) = delete;

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


  private:
    void
    _M_add_reference() const throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

    void
    _M_remove_reference() const throw()
    {

      ;
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
 {
          ;
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    const facet* _M_sso_shim(const id*) const;
    const facet* _M_cow_shim(const id*) const;

  protected:
    class __shim;
  };
# 483 "/usr/include/c++/10/bits/locale_classes.h" 3
  class locale::id
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();




    mutable size_t _M_index;


    static _Atomic_word _S_refcount;

    void
    operator=(const id&);

    id(const id&);

  public:



    id() { }

    size_t
    _M_id() const throw();
  };



  class locale::_Impl
  {
  public:

    friend class locale;
    friend class locale::facet;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Cache>
      friend struct __use_cache;

  private:

    _Atomic_word _M_refcount;
    const facet** _M_facets;
    size_t _M_facets_size;
    const facet** _M_caches;
    char** _M_names;
    static const locale::id* const _S_id_ctype[];
    static const locale::id* const _S_id_numeric[];
    static const locale::id* const _S_id_collate[];
    static const locale::id* const _S_id_time[];
    static const locale::id* const _S_id_monetary[];
    static const locale::id* const _S_id_messages[];
    static const locale::id* const* const _S_facet_categories[];

    void
    _M_add_reference() throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

    void
    _M_remove_reference() throw()
    {

      ;
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
 {
          ;
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    _Impl(const _Impl&, size_t);
    _Impl(const char*, size_t);
    _Impl(size_t) throw();

   ~_Impl() throw();

    _Impl(const _Impl&);

    void
    operator=(const _Impl&);

    bool
    _M_check_same_name()
    {
      bool __ret = true;
      if (_M_names[1])

 for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
      return __ret;
    }

    void
    _M_replace_categories(const _Impl*, category);

    void
    _M_replace_category(const _Impl*, const locale::id* const*);

    void
    _M_replace_facet(const _Impl*, const locale::id*);

    void
    _M_install_facet(const locale::id*, const facet*);

    template<typename _Facet>
      void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    template<typename _Facet>
      void
      _M_init_facet_unchecked(_Facet* __facet)
      {
 __facet->_M_add_reference();
 _M_facets[_Facet::id._M_id()] = __facet;
      }

    void
    _M_install_cache(const facet*, size_t);

    void _M_init_extra(facet**);
    void _M_init_extra(void*, void*, const char*, const char*);
  };
# 641 "/usr/include/c++/10/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;
# 668 "/usr/include/c++/10/bits/locale_classes.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 682 "/usr/include/c++/10/bits/locale_classes.h" 3
      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
      { }
# 699 "/usr/include/c++/10/bits/locale_classes.h" 3
      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
       const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 718 "/usr/include/c++/10/bits/locale_classes.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 732 "/usr/include/c++/10/bits/locale_classes.h" 3
      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_hash(__lo, __hi); }


      int
      _M_compare(const _CharT*, const _CharT*) const throw();

      size_t
      _M_transform(_CharT*, const _CharT*, size_t) const throw();

  protected:

      virtual
      ~collate()
      { _S_destroy_c_locale(_M_c_locale_collate); }
# 761 "/usr/include/c++/10/bits/locale_classes.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 775 "/usr/include/c++/10/bits/locale_classes.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 788 "/usr/include/c++/10/bits/locale_classes.h" 3
      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const;
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;


  template<>
    int
    collate<char>::_M_compare(const char*, const char*) const throw();

  template<>
    size_t
    collate<char>::_M_transform(char*, const char*, size_t) const throw();


  template<>
    int
    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();

  template<>
    size_t
    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();



  template<typename _CharT>
    class __cxx11:: collate_byname : public collate<_CharT>
    {
    public:


      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


      explicit
      collate_byname(const char* __s, size_t __refs = 0)
      : collate<_CharT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_collate);
     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
   }
      }


      explicit
      collate_byname(const string& __s, size_t __refs = 0)
      : collate_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~collate_byname() { }
    };


}

# 1 "/usr/include/c++/10/bits/locale_classes.tcc" 1 3
# 37 "/usr/include/c++/10/bits/locale_classes.tcc" 3
       
# 38 "/usr/include/c++/10/bits/locale_classes.tcc" 3

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


  template<typename _Facet>
    locale::
    locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);

      try
 { _M_impl->_M_install_facet(&_Facet::id, __f); }
      catch(...)
 {
   _M_impl->_M_remove_reference();
   throw;
 }
      delete [] _M_impl->_M_names[0];
      _M_impl->_M_names[0] = 0;
    }

  template<typename _Facet>
    locale
    locale::
    combine(const locale& __other) const
    {
      _Impl* __tmp = new _Impl(*_M_impl, 1);
      try
 {
   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
 }
      catch(...)
 {
   __tmp->_M_remove_reference();
   throw;
 }
      return locale(__tmp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::
    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
    __s2.data(), __s2.data() + __s2.length()) < 0);
    }
# 102 "/usr/include/c++/10/bits/locale_classes.tcc" 3
  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw()
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      return (__i < __loc._M_impl->_M_facets_size

       && dynamic_cast<const _Facet*>(__facets[__i]));



    }
# 130 "/usr/include/c++/10/bits/locale_classes.tcc" 3
  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc)
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
        __throw_bad_cast();

      return dynamic_cast<const _Facet&>(*__facets[__i]);



    }



  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
    { return 0; }


  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
    { return 0; }

  template<typename _CharT>
    int
    collate<_CharT>::
    do_compare(const _CharT* __lo1, const _CharT* __hi1,
        const _CharT* __lo2, const _CharT* __hi2) const
    {


      const string_type __one(__lo1, __hi1);
      const string_type __two(__lo2, __hi2);

      const _CharT* __p = __one.c_str();
      const _CharT* __pend = __one.data() + __one.length();
      const _CharT* __q = __two.c_str();
      const _CharT* __qend = __two.data() + __two.length();




      for (;;)
 {
   const int __res = _M_compare(__p, __q);
   if (__res)
     return __res;

   __p += char_traits<_CharT>::length(__p);
   __q += char_traits<_CharT>::length(__q);
   if (__p == __pend && __q == __qend)
     return 0;
   else if (__p == __pend)
     return -1;
   else if (__q == __qend)
     return 1;

   __p++;
   __q++;
 }
    }

  template<typename _CharT>
    typename collate<_CharT>::string_type
    collate<_CharT>::
    do_transform(const _CharT* __lo, const _CharT* __hi) const
    {
      string_type __ret;


      const string_type __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      _CharT* __c = new _CharT[__len];

      try
 {



   for (;;)
     {

       size_t __res = _M_transform(__c, __p, __len);


       if (__res >= __len)
  {
    __len = __res + 1;
    delete [] __c, __c = 0;
    __c = new _CharT[__len];
    __res = _M_transform(__c, __p, __len);
  }

       __ret.append(__c, __res);
       __p += char_traits<_CharT>::length(__p);
       if (__p == __pend)
  break;

       __p++;
       __ret.push_back(_CharT());
     }
 }
      catch(...)
 {
   delete [] __c;
   throw;
 }

      delete [] __c;

      return __ret;
    }

  template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
 __val =
   *__lo + ((__val << 7)
     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
    __digits - 7)));
      return static_cast<long>(__val);
    }




  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

  extern template
    bool
    has_facet<collate<char> >(const locale&);


  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);




}
# 852 "/usr/include/c++/10/bits/locale_classes.h" 2 3
# 42 "/usr/include/c++/10/bits/ios_base.h" 2 3




# 1 "/usr/include/c++/10/system_error" 1 3
# 32 "/usr/include/c++/10/system_error" 3
       
# 33 "/usr/include/c++/10/system_error" 3






# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/error_constants.h" 1 3
# 34 "/usr/include/c++/10/x86_64-redhat-linux/bits/error_constants.h" 3
# 1 "/usr/include/c++/10/cerrno" 1 3
# 39 "/usr/include/c++/10/cerrno" 3
       
# 40 "/usr/include/c++/10/cerrno" 3
# 35 "/usr/include/c++/10/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
    };


}
# 40 "/usr/include/c++/10/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 {
# 86 "/usr/include/c++/10/system_error" 3
  class error_category
  {
  public:
    constexpr error_category() noexcept = default;

    virtual ~error_category();

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

    virtual const char*
    name() const noexcept = 0;






  private:
    __attribute ((__abi_tag__ ("cxx11")))
    virtual __cow_string
    _M_message(int) const;

  public:
    __attribute ((__abi_tag__ ("cxx11")))
    virtual string
    message(int) const = 0;
# 122 "/usr/include/c++/10/system_error" 3
  public:
    virtual error_condition
    default_error_condition(int __i) const noexcept;

    virtual bool
    equivalent(int __i, const error_condition& __cond) const noexcept;

    virtual bool
    equivalent(const error_code& __code, int __i) const noexcept;

    bool
    operator<(const error_category& __other) const noexcept
    { return less<const error_category*>()(this, &__other); }

    bool
    operator==(const error_category& __other) const noexcept
    { return this == &__other; }

    bool
    operator!=(const error_category& __other) const noexcept
    { return this != &__other; }
  };




  __attribute__ ((__const__)) const error_category& generic_category() noexcept;


  __attribute__ ((__const__)) const error_category& system_category() noexcept;

  }

  error_code make_error_code(errc) noexcept;
# 171 "/usr/include/c++/10/system_error" 3
  struct error_code
  {
    error_code() noexcept
    : _M_value(0), _M_cat(&system_category()) { }

    error_code(int __v, const error_category& __cat) noexcept
    : _M_value(__v), _M_cat(&__cat) { }

    template<typename _ErrorCodeEnum, typename = typename
      enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
      error_code(_ErrorCodeEnum __e) noexcept
      { *this = make_error_code(__e); }

    void
    assign(int __v, const error_category& __cat) noexcept
    {
      _M_value = __v;
      _M_cat = &__cat;
    }

    void
    clear() noexcept
    { assign(0, system_category()); }


    template<typename _ErrorCodeEnum>
      typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
    error_code&>::type
      operator=(_ErrorCodeEnum __e) noexcept
      { return *this = make_error_code(__e); }

    int
    value() const noexcept { return _M_value; }

    const error_category&
    category() const noexcept { return *_M_cat; }

    error_condition
    default_error_condition() const noexcept;

    __attribute ((__abi_tag__ ("cxx11")))
    string
    message() const
    { return category().message(value()); }

    explicit operator bool() const noexcept
    { return _M_value != 0; }


  private:
    int _M_value;
    const error_category* _M_cat;
  };





  inline error_code
  make_error_code(errc __e) noexcept
  { return error_code(static_cast<int>(__e), generic_category()); }

  inline bool
  operator<(const error_code& __lhs, const error_code& __rhs) noexcept
  {
    return (__lhs.category() < __rhs.category()
     || (__lhs.category() == __rhs.category()
  && __lhs.value() < __rhs.value()));
  }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
    { return (__os << __e.category().name() << ':' << __e.value()); }



  error_condition make_error_condition(errc) noexcept;
# 259 "/usr/include/c++/10/system_error" 3
  struct error_condition
  {
    error_condition() noexcept
    : _M_value(0), _M_cat(&generic_category()) { }

    error_condition(int __v, const error_category& __cat) noexcept
    : _M_value(__v), _M_cat(&__cat) { }

    template<typename _ErrorConditionEnum, typename = typename
  enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
      error_condition(_ErrorConditionEnum __e) noexcept
      { *this = make_error_condition(__e); }

    void
    assign(int __v, const error_category& __cat) noexcept
    {
      _M_value = __v;
      _M_cat = &__cat;
    }


    template<typename _ErrorConditionEnum>
      typename enable_if<is_error_condition_enum
    <_ErrorConditionEnum>::value, error_condition&>::type
      operator=(_ErrorConditionEnum __e) noexcept
      { return *this = make_error_condition(__e); }

    void
    clear() noexcept
    { assign(0, generic_category()); }


    int
    value() const noexcept { return _M_value; }

    const error_category&
    category() const noexcept { return *_M_cat; }

    __attribute ((__abi_tag__ ("cxx11")))
    string
    message() const
    { return category().message(value()); }

    explicit operator bool() const noexcept
    { return _M_value != 0; }


  private:
    int _M_value;
    const error_category* _M_cat;
  };





  inline error_condition
  make_error_condition(errc __e) noexcept
  { return error_condition(static_cast<int>(__e), generic_category()); }



  inline bool
  operator<(const error_condition& __lhs,
     const error_condition& __rhs) noexcept
  {
    return (__lhs.category() < __rhs.category()
     || (__lhs.category() == __rhs.category()
  && __lhs.value() < __rhs.value()));
  }




  inline bool
  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
  { return (__lhs.category() == __rhs.category()
     && __lhs.value() == __rhs.value()); }



  inline bool
  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
  {
    return (__lhs.category().equivalent(__lhs.value(), __rhs)
     || __rhs.category().equivalent(__lhs, __rhs.value()));
  }



  inline bool
  operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
  {
    return (__rhs.category().equivalent(__rhs.value(), __lhs)
     || __lhs.category().equivalent(__rhs, __lhs.value()));
  }


  inline bool
  operator==(const error_condition& __lhs,
      const error_condition& __rhs) noexcept
  {
    return (__lhs.category() == __rhs.category()
     && __lhs.value() == __rhs.value());
  }


  inline bool
  operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
  { return !(__lhs == __rhs); }



  inline bool
  operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
  { return !(__lhs == __rhs); }



  inline bool
  operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
  { return !(__lhs == __rhs); }


  inline bool
  operator!=(const error_condition& __lhs,
      const error_condition& __rhs) noexcept
  { return !(__lhs == __rhs); }
# 397 "/usr/include/c++/10/system_error" 3
  class system_error : public std::runtime_error
  {
  private:
    error_code _M_code;

  public:
    system_error(error_code __ec = error_code())
    : runtime_error(__ec.message()), _M_code(__ec) { }

    system_error(error_code __ec, const string& __what)
    : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }

    system_error(error_code __ec, const char* __what)
    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }

    system_error(int __v, const error_category& __ecat, const char* __what)
    : system_error(error_code(__v, __ecat), __what) { }

    system_error(int __v, const error_category& __ecat)
    : runtime_error(error_code(__v, __ecat).message()),
      _M_code(__v, __ecat) { }

    system_error(int __v, const error_category& __ecat, const string& __what)
    : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
      _M_code(__v, __ecat) { }


    system_error (const system_error &) = default;
    system_error &operator= (const system_error &) = default;


    virtual ~system_error() noexcept;

    const error_code&
    code() const noexcept { return _M_code; }
  };


}



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






  template<>
    struct hash<error_code>
    : public __hash_base<size_t, error_code>
    {
      size_t
      operator()(const error_code& __e) const noexcept
      {
 const size_t __tmp = std::_Hash_impl::hash(__e.value());
 return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
      }
    };






  template<>
    struct hash<error_condition>
    : public __hash_base<size_t, error_condition>
    {
      size_t
      operator()(const error_condition& __e) const noexcept
      {
 const size_t __tmp = std::_Hash_impl::hash(__e.value());
 return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
      }
    };



}
# 47 "/usr/include/c++/10/bits/ios_base.h" 2 3


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






  enum _Ios_Fmtflags
    {
      _S_boolalpha = 1L << 0,
      _S_dec = 1L << 1,
      _S_fixed = 1L << 2,
      _S_hex = 1L << 3,
      _S_internal = 1L << 4,
      _S_left = 1L << 5,
      _S_oct = 1L << 6,
      _S_right = 1L << 7,
      _S_scientific = 1L << 8,
      _S_showbase = 1L << 9,
      _S_showpoint = 1L << 10,
      _S_showpos = 1L << 11,
      _S_skipws = 1L << 12,
      _S_unitbuf = 1L << 13,
      _S_uppercase = 1L << 14,
      _S_adjustfield = _S_left | _S_right | _S_internal,
      _S_basefield = _S_dec | _S_oct | _S_hex,
      _S_floatfield = _S_scientific | _S_fixed,
      _S_ios_fmtflags_end = 1L << 16,
      _S_ios_fmtflags_max = 0x7fffffff,
      _S_ios_fmtflags_min = ~0x7fffffff
    };

  inline constexpr _Ios_Fmtflags
  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline constexpr _Ios_Fmtflags
  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline constexpr _Ios_Fmtflags
  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline constexpr _Ios_Fmtflags
  operator~(_Ios_Fmtflags __a)
  { return _Ios_Fmtflags(~static_cast<int>(__a)); }

  inline const _Ios_Fmtflags&
  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a | __b; }

  inline const _Ios_Fmtflags&
  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a & __b; }

  inline const _Ios_Fmtflags&
  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a ^ __b; }


  enum _Ios_Openmode
    {
      _S_app = 1L << 0,
      _S_ate = 1L << 1,
      _S_bin = 1L << 2,
      _S_in = 1L << 3,
      _S_out = 1L << 4,
      _S_trunc = 1L << 5,
      _S_ios_openmode_end = 1L << 16,
      _S_ios_openmode_max = 0x7fffffff,
      _S_ios_openmode_min = ~0x7fffffff
    };

  inline constexpr _Ios_Openmode
  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline constexpr _Ios_Openmode
  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline constexpr _Ios_Openmode
  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline constexpr _Ios_Openmode
  operator~(_Ios_Openmode __a)
  { return _Ios_Openmode(~static_cast<int>(__a)); }

  inline const _Ios_Openmode&
  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a | __b; }

  inline const _Ios_Openmode&
  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a & __b; }

  inline const _Ios_Openmode&
  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a ^ __b; }


  enum _Ios_Iostate
    {
      _S_goodbit = 0,
      _S_badbit = 1L << 0,
      _S_eofbit = 1L << 1,
      _S_failbit = 1L << 2,
      _S_ios_iostate_end = 1L << 16,
      _S_ios_iostate_max = 0x7fffffff,
      _S_ios_iostate_min = ~0x7fffffff
    };

  inline constexpr _Ios_Iostate
  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline constexpr _Ios_Iostate
  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline constexpr _Ios_Iostate
  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline constexpr _Ios_Iostate
  operator~(_Ios_Iostate __a)
  { return _Ios_Iostate(~static_cast<int>(__a)); }

  inline const _Ios_Iostate&
  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a | __b; }

  inline const _Ios_Iostate&
  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a & __b; }

  inline const _Ios_Iostate&
  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a ^ __b; }


  enum _Ios_Seekdir
    {
      _S_beg = 0,
      _S_cur = 1,
      _S_end = 2,
      _S_ios_seekdir_end = 1L << 16
    };



  enum class io_errc { stream = 1 };

  template <> struct is_error_code_enum<io_errc> : public true_type { };

  const error_category& iostream_category() noexcept;

  inline error_code
  make_error_code(io_errc __e) noexcept
  { return error_code(static_cast<int>(__e), iostream_category()); }

  inline error_condition
  make_error_condition(io_errc __e) noexcept
  { return error_condition(static_cast<int>(__e), iostream_category()); }
# 228 "/usr/include/c++/10/bits/ios_base.h" 3
  class ios_base
  {
# 246 "/usr/include/c++/10/bits/ios_base.h" 3
  public:
# 255 "/usr/include/c++/10/bits/ios_base.h" 3
    class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
    {
    public:
      explicit
      failure(const string& __str);


      explicit
      failure(const string&, const error_code&);

      explicit
      failure(const char*, const error_code& = io_errc::stream);


      virtual
      ~failure() throw();

      virtual const char*
      what() const throw();
    };
# 323 "/usr/include/c++/10/bits/ios_base.h" 3
    typedef _Ios_Fmtflags fmtflags;


    static const fmtflags boolalpha = _S_boolalpha;


    static const fmtflags dec = _S_dec;


    static const fmtflags fixed = _S_fixed;


    static const fmtflags hex = _S_hex;




    static const fmtflags internal = _S_internal;



    static const fmtflags left = _S_left;


    static const fmtflags oct = _S_oct;



    static const fmtflags right = _S_right;


    static const fmtflags scientific = _S_scientific;



    static const fmtflags showbase = _S_showbase;



    static const fmtflags showpoint = _S_showpoint;


    static const fmtflags showpos = _S_showpos;


    static const fmtflags skipws = _S_skipws;


    static const fmtflags unitbuf = _S_unitbuf;



    static const fmtflags uppercase = _S_uppercase;


    static const fmtflags adjustfield = _S_adjustfield;


    static const fmtflags basefield = _S_basefield;


    static const fmtflags floatfield = _S_floatfield;
# 398 "/usr/include/c++/10/bits/ios_base.h" 3
    typedef _Ios_Iostate iostate;



    static const iostate badbit = _S_badbit;


    static const iostate eofbit = _S_eofbit;




    static const iostate failbit = _S_failbit;


    static const iostate goodbit = _S_goodbit;
# 429 "/usr/include/c++/10/bits/ios_base.h" 3
    typedef _Ios_Openmode openmode;


    static const openmode app = _S_app;


    static const openmode ate = _S_ate;




    static const openmode binary = _S_bin;


    static const openmode in = _S_in;


    static const openmode out = _S_out;


    static const openmode trunc = _S_trunc;
# 461 "/usr/include/c++/10/bits/ios_base.h" 3
    typedef _Ios_Seekdir seekdir;


    static const seekdir beg = _S_beg;


    static const seekdir cur = _S_cur;


    static const seekdir end = _S_end;
# 489 "/usr/include/c++/10/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 506 "/usr/include/c++/10/bits/ios_base.h" 3
    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
# 518 "/usr/include/c++/10/bits/ios_base.h" 3
    void
    register_callback(event_callback __fn, int __index);

  protected:
    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;
    iostate _M_exception;
    iostate _M_streambuf_state;



    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      _Atomic_word _M_refcount;

      _Callback_list(ios_base::event_callback __fn, int __index,
       _Callback_list* __cb)
      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void
      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }


      int
      _M_remove_reference()
      {

        ;
        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
        if (__res == 0)
          {
            ;
          }
        return __res;
      }
    };

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void) throw();


    struct _Words
    {
      void* _M_pword;
      long _M_iword;
      _Words() : _M_pword(0), _M_iword(0) { }
    };


    _Words _M_word_zero;



    enum { _S_local_word_size = 8 };
    _Words _M_local_word[_S_local_word_size];


    int _M_word_size;
    _Words* _M_word;

    _Words&
    _M_grow_words(int __index, bool __iword);


    locale _M_ios_locale;

    void
    _M_init() throw();

  public:





    class Init
    {
      friend class ios_base;
    public:
      Init();
      ~Init();


      Init(const Init&) = default;
      Init& operator=(const Init&) = default;


    private:
      static _Atomic_word _S_refcount;
      static bool _S_synced_with_stdio;
    };






    fmtflags
    flags() const
    { return _M_flags; }
# 636 "/usr/include/c++/10/bits/ios_base.h" 3
    fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 652 "/usr/include/c++/10/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 669 "/usr/include/c++/10/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }







    void
    unsetf(fmtflags __mask)
    { _M_flags &= ~__mask; }
# 695 "/usr/include/c++/10/bits/ios_base.h" 3
    streamsize
    precision() const
    { return _M_precision; }






    streamsize
    precision(streamsize __prec)
    {
      streamsize __old = _M_precision;
      _M_precision = __prec;
      return __old;
    }







    streamsize
    width() const
    { return _M_width; }






    streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }
# 746 "/usr/include/c++/10/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 758 "/usr/include/c++/10/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc) throw();
# 769 "/usr/include/c++/10/bits/ios_base.h" 3
    locale
    getloc() const
    { return _M_ios_locale; }
# 780 "/usr/include/c++/10/bits/ios_base.h" 3
    const locale&
    _M_getloc() const
    { return _M_ios_locale; }
# 799 "/usr/include/c++/10/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 815 "/usr/include/c++/10/bits/ios_base.h" 3
    long&
    iword(int __ix)
    {
      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, true);
      return __word._M_iword;
    }
# 836 "/usr/include/c++/10/bits/ios_base.h" 3
    void*&
    pword(int __ix)
    {
      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, false);
      return __word._M_pword;
    }
# 853 "/usr/include/c++/10/bits/ios_base.h" 3
    virtual ~ios_base();

  protected:
    ios_base() throw ();
# 867 "/usr/include/c++/10/bits/ios_base.h" 3
  public:
    ios_base(const ios_base&) = delete;

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

  protected:
    void
    _M_move(ios_base&) noexcept;

    void
    _M_swap(ios_base& __rhs) noexcept;

  };



  inline ios_base&
  boolalpha(ios_base& __base)
  {
    __base.setf(ios_base::boolalpha);
    return __base;
  }


  inline ios_base&
  noboolalpha(ios_base& __base)
  {
    __base.unsetf(ios_base::boolalpha);
    return __base;
  }


  inline ios_base&
  showbase(ios_base& __base)
  {
    __base.setf(ios_base::showbase);
    return __base;
  }


  inline ios_base&
  noshowbase(ios_base& __base)
  {
    __base.unsetf(ios_base::showbase);
    return __base;
  }


  inline ios_base&
  showpoint(ios_base& __base)
  {
    __base.setf(ios_base::showpoint);
    return __base;
  }


  inline ios_base&
  noshowpoint(ios_base& __base)
  {
    __base.unsetf(ios_base::showpoint);
    return __base;
  }


  inline ios_base&
  showpos(ios_base& __base)
  {
    __base.setf(ios_base::showpos);
    return __base;
  }


  inline ios_base&
  noshowpos(ios_base& __base)
  {
    __base.unsetf(ios_base::showpos);
    return __base;
  }


  inline ios_base&
  skipws(ios_base& __base)
  {
    __base.setf(ios_base::skipws);
    return __base;
  }


  inline ios_base&
  noskipws(ios_base& __base)
  {
    __base.unsetf(ios_base::skipws);
    return __base;
  }


  inline ios_base&
  uppercase(ios_base& __base)
  {
    __base.setf(ios_base::uppercase);
    return __base;
  }


  inline ios_base&
  nouppercase(ios_base& __base)
  {
    __base.unsetf(ios_base::uppercase);
    return __base;
  }


  inline ios_base&
  unitbuf(ios_base& __base)
  {
     __base.setf(ios_base::unitbuf);
     return __base;
  }


  inline ios_base&
  nounitbuf(ios_base& __base)
  {
     __base.unsetf(ios_base::unitbuf);
     return __base;
  }



  inline ios_base&
  internal(ios_base& __base)
  {
     __base.setf(ios_base::internal, ios_base::adjustfield);
     return __base;
  }


  inline ios_base&
  left(ios_base& __base)
  {
    __base.setf(ios_base::left, ios_base::adjustfield);
    return __base;
  }


  inline ios_base&
  right(ios_base& __base)
  {
    __base.setf(ios_base::right, ios_base::adjustfield);
    return __base;
  }



  inline ios_base&
  dec(ios_base& __base)
  {
    __base.setf(ios_base::dec, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  hex(ios_base& __base)
  {
    __base.setf(ios_base::hex, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  oct(ios_base& __base)
  {
    __base.setf(ios_base::oct, ios_base::basefield);
    return __base;
  }



  inline ios_base&
  fixed(ios_base& __base)
  {
    __base.setf(ios_base::fixed, ios_base::floatfield);
    return __base;
  }


  inline ios_base&
  scientific(ios_base& __base)
  {
    __base.setf(ios_base::scientific, ios_base::floatfield);
    return __base;
  }






  inline ios_base&
  hexfloat(ios_base& __base)
  {
    __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
    return __base;
  }


  inline ios_base&
  defaultfloat(ios_base& __base)
  {
    __base.unsetf(ios_base::floatfield);
    return __base;
  }



}
# 42 "/usr/include/c++/10/streambuf" 2 3



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




  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
     basic_streambuf<_CharT, _Traits>*, bool&);
# 121 "/usr/include/c++/10/streambuf" 3
  template<typename _CharT, typename _Traits>
    class basic_streambuf
    {
    public:






      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;




      typedef basic_streambuf<char_type, traits_type> __streambuf_type;


      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);

      template<bool _IsMove, typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
        __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
      istreambuf_iterator<_CharT2> >::__type
        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Distance>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            void>::__type
        advance(istreambuf_iterator<_CharT2>&, _Distance);

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&,
     basic_string<_CharT2, _Traits2, _Alloc>&);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        getline(basic_istream<_CharT2, _Traits2>&,
  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

    protected:







      char_type* _M_in_beg;
      char_type* _M_in_cur;
      char_type* _M_in_end;
      char_type* _M_out_beg;
      char_type* _M_out_cur;
      char_type* _M_out_end;


      locale _M_buf_locale;

  public:

      virtual
      ~basic_streambuf()
      { }
# 215 "/usr/include/c++/10/streambuf" 3
      locale
      pubimbue(const locale& __loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 232 "/usr/include/c++/10/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 245 "/usr/include/c++/10/streambuf" 3
      basic_streambuf*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }
# 257 "/usr/include/c++/10/streambuf" 3
      pos_type
      pubseekoff(off_type __off, ios_base::seekdir __way,
   ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekoff(__off, __way, __mode); }
# 269 "/usr/include/c++/10/streambuf" 3
      pos_type
      pubseekpos(pos_type __sp,
   ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekpos(__sp, __mode); }




      int
      pubsync() { return this->sync(); }
# 290 "/usr/include/c++/10/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 304 "/usr/include/c++/10/streambuf" 3
      int_type
      snextc()
      {
 int_type __ret = traits_type::eof();
 if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
             __ret), true))
   __ret = this->sgetc();
 return __ret;
      }
# 322 "/usr/include/c++/10/streambuf" 3
      int_type
      sbumpc()
      {
 int_type __ret;
 if (__builtin_expect(this->gptr() < this->egptr(), true))
   {
     __ret = traits_type::to_int_type(*this->gptr());
     this->gbump(1);
   }
 else
   __ret = this->uflow();
 return __ret;
      }
# 344 "/usr/include/c++/10/streambuf" 3
      int_type
      sgetc()
      {
 int_type __ret;
 if (__builtin_expect(this->gptr() < this->egptr(), true))
   __ret = traits_type::to_int_type(*this->gptr());
 else
   __ret = this->underflow();
 return __ret;
      }
# 363 "/usr/include/c++/10/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 378 "/usr/include/c++/10/streambuf" 3
      int_type
      sputbackc(char_type __c)
      {
 int_type __ret;
 const bool __testpos = this->eback() < this->gptr();
 if (__builtin_expect(!__testpos ||
        !traits_type::eq(__c, this->gptr()[-1]), false))
   __ret = this->pbackfail(traits_type::to_int_type(__c));
 else
   {
     this->gbump(-1);
     __ret = traits_type::to_int_type(*this->gptr());
   }
 return __ret;
      }
# 403 "/usr/include/c++/10/streambuf" 3
      int_type
      sungetc()
      {
 int_type __ret;
 if (__builtin_expect(this->eback() < this->gptr(), true))
   {
     this->gbump(-1);
     __ret = traits_type::to_int_type(*this->gptr());
   }
 else
   __ret = this->pbackfail();
 return __ret;
      }
# 430 "/usr/include/c++/10/streambuf" 3
      int_type
      sputc(char_type __c)
      {
 int_type __ret;
 if (__builtin_expect(this->pptr() < this->epptr(), true))
   {
     *this->pptr() = __c;
     this->pbump(1);
     __ret = traits_type::to_int_type(__c);
   }
 else
   __ret = this->overflow(traits_type::to_int_type(__c));
 return __ret;
      }
# 456 "/usr/include/c++/10/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 470 "/usr/include/c++/10/streambuf" 3
      basic_streambuf()
      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
      _M_buf_locale(locale())
      { }
# 488 "/usr/include/c++/10/streambuf" 3
      char_type*
      eback() const { return _M_in_beg; }

      char_type*
      gptr() const { return _M_in_cur; }

      char_type*
      egptr() const { return _M_in_end; }
# 504 "/usr/include/c++/10/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 515 "/usr/include/c++/10/streambuf" 3
      void
      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
      {
 _M_in_beg = __gbeg;
 _M_in_cur = __gnext;
 _M_in_end = __gend;
      }
# 535 "/usr/include/c++/10/streambuf" 3
      char_type*
      pbase() const { return _M_out_beg; }

      char_type*
      pptr() const { return _M_out_cur; }

      char_type*
      epptr() const { return _M_out_end; }
# 551 "/usr/include/c++/10/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 561 "/usr/include/c++/10/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 582 "/usr/include/c++/10/streambuf" 3
      virtual void
      imbue(const locale& __loc __attribute__ ((__unused__)))
      { }
# 597 "/usr/include/c++/10/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 608 "/usr/include/c++/10/streambuf" 3
      virtual pos_type
      seekoff(off_type, ios_base::seekdir,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 620 "/usr/include/c++/10/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 633 "/usr/include/c++/10/streambuf" 3
      virtual int
      sync() { return 0; }
# 655 "/usr/include/c++/10/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 671 "/usr/include/c++/10/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 693 "/usr/include/c++/10/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 706 "/usr/include/c++/10/streambuf" 3
      virtual int_type
      uflow()
      {
 int_type __ret = traits_type::eof();
 const bool __testeof = traits_type::eq_int_type(this->underflow(),
       __ret);
 if (!__testeof)
   {
     __ret = traits_type::to_int_type(*this->gptr());
     this->gbump(1);
   }
 return __ret;
      }
# 730 "/usr/include/c++/10/streambuf" 3
      virtual int_type
      pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
      { return traits_type::eof(); }
# 748 "/usr/include/c++/10/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 774 "/usr/include/c++/10/streambuf" 3
      virtual int_type
      overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
      { return traits_type::eof(); }
# 803 "/usr/include/c++/10/streambuf" 3
      void
      __safe_gbump(streamsize __n) { _M_in_cur += __n; }

      void
      __safe_pbump(streamsize __n) { _M_out_cur += __n; }




    protected:

      basic_streambuf(const basic_streambuf&);

      basic_streambuf&
      operator=(const basic_streambuf&);


      void
      swap(basic_streambuf& __sb)
      {
 std::swap(_M_in_beg, __sb._M_in_beg);
 std::swap(_M_in_cur, __sb._M_in_cur);
 std::swap(_M_in_end, __sb._M_in_end);
 std::swap(_M_out_beg, __sb._M_out_beg);
 std::swap(_M_out_cur, __sb._M_out_cur);
 std::swap(_M_out_end, __sb._M_out_end);
 std::swap(_M_buf_locale, __sb._M_buf_locale);
      }

    };


  template<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/include/c++/10/bits/streambuf.tcc" 1 3
# 37 "/usr/include/c++/10/bits/streambuf.tcc" 3
       
# 38 "/usr/include/c++/10/bits/streambuf.tcc" 3

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


  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->egptr() - this->gptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(__s, this->gptr(), __len);
       __ret += __len;
       __s += __len;
       this->__safe_gbump(__len);
     }

   if (__ret < __n)
     {
       const int_type __c = this->uflow();
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    traits_type::assign(*__s++, traits_type::to_char_type(__c));
    ++__ret;
  }
       else
  break;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsputn(const char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->epptr() - this->pptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(this->pptr(), __s, __len);
       __ret += __len;
       __s += __len;
       this->__safe_pbump(__len);
     }

   if (__ret < __n)
     {
       int_type __c = this->overflow(traits_type::to_int_type(*__s));
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    ++__ret;
    ++__s;
  }
       else
  break;
     }
 }
      return __ret;
    }




  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
     basic_streambuf<_CharT, _Traits>* __sbout,
     bool& __ineof)
    {
      streamsize __ret = 0;
      __ineof = true;
      typename _Traits::int_type __c = __sbin->sgetc();
      while (!_Traits::eq_int_type(__c, _Traits::eof()))
 {
   __c = __sbout->sputc(_Traits::to_char_type(__c));
   if (_Traits::eq_int_type(__c, _Traits::eof()))
     {
       __ineof = false;
       break;
     }
   ++__ret;
   __c = __sbin->snextc();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    inline streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout)
    {
      bool __ineof;
      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
    }




  extern template class basic_streambuf<char>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<char>*,
        basic_streambuf<char>*);
  extern template
    streamsize
    __copy_streambufs_eof(basic_streambuf<char>*,
     basic_streambuf<char>*, bool&);


  extern template class basic_streambuf<wchar_t>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>*,
        basic_streambuf<wchar_t>*);
  extern template
    streamsize
    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
     basic_streambuf<wchar_t>*, bool&);




}
# 863 "/usr/include/c++/10/streambuf" 2 3
# 36 "/usr/include/c++/10/bits/streambuf_iterator.h" 2 3


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

# 49 "/usr/include/c++/10/bits/streambuf_iterator.h" 3
  template<typename _CharT, typename _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
        _CharT*, _CharT>
    {
    public:
# 66 "/usr/include/c++/10/bits/streambuf_iterator.h" 3
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

      template<bool _IsMove, typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
 __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);


      template<typename _CharT2, typename _Size>
 friend __enable_if_t<__is_char<_CharT2>::__value, _CharT2*>
 __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*);


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        istreambuf_iterator<_CharT2> >::__type
 find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Distance>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            void>::__type
 advance(istreambuf_iterator<_CharT2>&, _Distance);

    private:







      mutable streambuf_type* _M_sbuf;
      int_type _M_c;

    public:

      constexpr istreambuf_iterator() noexcept
      : _M_sbuf(0), _M_c(traits_type::eof()) { }


      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;

      ~istreambuf_iterator() = default;



      istreambuf_iterator(istream_type& __s) noexcept
      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }


      istreambuf_iterator(streambuf_type* __s) noexcept
      : _M_sbuf(__s), _M_c(traits_type::eof()) { }


      istreambuf_iterator&
      operator=(const istreambuf_iterator&) noexcept = default;





      char_type
      operator*() const
      {
 int_type __c = _M_get();
# 152 "/usr/include/c++/10/bits/streambuf_iterator.h" 3
 return traits_type::to_char_type(__c);
      }


      istreambuf_iterator&
      operator++()
      {



                        ;

 _M_sbuf->sbumpc();
 _M_c = traits_type::eof();
 return *this;
      }


      istreambuf_iterator
      operator++(int)
      {



                        ;

 istreambuf_iterator __old = *this;
 __old._M_c = _M_sbuf->sbumpc();
 _M_c = traits_type::eof();
 return __old;
      }





      bool
      equal(const istreambuf_iterator& __b) const
      { return _M_at_eof() == __b._M_at_eof(); }

    private:
      int_type
      _M_get() const
      {
 int_type __ret = _M_c;
 if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
   _M_sbuf = 0;
 return __ret;
      }

      bool
      _M_at_eof() const
      { return _S_is_eof(_M_get()); }

      static bool
      _S_is_eof(int_type __c)
      {
 const int_type __eof = traits_type::eof();
 return traits_type::eq_int_type(__c, __eof);
      }
    };

  template<typename _CharT, typename _Traits>
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }

  template<typename _CharT, typename _Traits>
    inline bool
    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return !__a.equal(__b); }


  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:






      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:
# 263 "/usr/include/c++/10/bits/streambuf_iterator.h" 3
      ostreambuf_iterator(ostream_type& __s) noexcept
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator(streambuf_type* __s) noexcept
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator&
      operator=(_CharT __c)
      {
 if (!_M_failed &&
     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
   _M_failed = true;
 return *this;
      }


      ostreambuf_iterator&
      operator*()
      { return *this; }


      ostreambuf_iterator&
      operator++(int)
      { return *this; }


      ostreambuf_iterator&
      operator++()
      { return *this; }


      bool
      failed() const noexcept
      { return _M_failed; }

      ostreambuf_iterator&
      _M_put(const _CharT* __ws, streamsize __len)
      {
 if (__builtin_expect(!_M_failed, true)
     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
    false))
   _M_failed = true;
 return *this;
      }
    };


  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    copy(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last,
  ostreambuf_iterator<_CharT> __result)
    {
      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
 {
   bool __ineof;
   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
   if (!__ineof)
     __result._M_failed = true;
 }
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(_CharT* __first, _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(const _CharT* __first, const _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT> __first,
     istreambuf_iterator<_CharT> __last, _CharT* __result)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, traits_type::eof()))
     {
       const streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    traits_type::copy(__result, __sb->gptr(), __n);
    __sb->__safe_gbump(__n);
    __result += __n;
    __c = __sb->underflow();
  }
       else
  {
    *__result++ = traits_type::to_char_type(__c);
    __c = __sb->snextc();
  }
     }
 }
      return __result;
    }


  template<typename _CharT, typename _Size>
    __enable_if_t<__is_char<_CharT>::__value, _CharT*>
    __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result)
    {
      if (__n == 0)
 return __result;

     

                            ;
      _CharT* __beg = __result;
      __result += __it._M_sbuf->sgetn(__beg, __n);
     

                            ;
      return __result;
    }


  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
          istreambuf_iterator<_CharT> >::__type
    find(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last, const _CharT& __val)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;
      const int_type __eof = traits_type::eof();

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   const int_type __ival = traits_type::to_int_type(__val);
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, __eof)
   && !traits_type::eq_int_type(__c, __ival))
     {
       streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    const _CharT* __p = traits_type::find(__sb->gptr(),
       __n, __val);
    if (__p)
      __n = __p - __sb->gptr();
    __sb->__safe_gbump(__n);
    __c = __sb->sgetc();
  }
       else
  __c = __sb->snextc();
     }

   __first._M_c = __eof;
 }

      return __first;
    }

  template<typename _CharT, typename _Distance>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        void>::__type
    advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
    {
      if (__n == 0)
 return;

      do { if (! (__n > 0)) std::__replacement_assert("/usr/include/c++/10/bits/streambuf_iterator.h", 456, __PRETTY_FUNCTION__, "__n > 0"); } 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/include/c++/10/iterator" 2 3
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 2 3 4

# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3


# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/string.h" 2 3 4

extern "C" {




# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4
# 43 "/usr/include/string.h" 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
       size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, const void *__src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
        int __c, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int memcmp (const void *__s1, const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
memchr (void *__s, int __c, size_t __n) throw ()
{
  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) throw ()
{
  return __builtin_memchr (__s, __c, __n);
}

}
# 99 "/usr/include/string.h" 3 4
extern "C++" void *rawmemchr (void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));







extern "C++" void *memrchr (void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 122 "/usr/include/string.h" 3 4
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, const char *__restrict __src,
        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (const char *__s1, const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (2)));






extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));


extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
    locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));





extern char *strdup (const char *__s)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 204 "/usr/include/string.h" 3 4
extern "C++"
{
extern char *strchr (char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strchr (char *__s, int __c) throw ()
{
  return __builtin_strchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strchr (const char *__s, int __c) throw ()
{
  return __builtin_strchr (__s, __c);
}

}






extern "C++"
{
extern char *strrchr (char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strrchr (char *__s, int __c) throw ()
{
  return __builtin_strrchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strrchr (const char *__s, int __c) throw ()
{
  return __builtin_strrchr (__s, __c);
}

}
# 261 "/usr/include/string.h" 3 4
extern "C++" char *strchrnul (char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 273 "/usr/include/string.h" 3 4
extern size_t strcspn (const char *__s, const char *__reject)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (const char *__s, const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strpbrk (char *__s, const char *__accept) throw ()
{
  return __builtin_strpbrk (__s, __accept);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strpbrk (const char *__s, const char *__accept) throw ()
{
  return __builtin_strpbrk (__s, __accept);
}

}






extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strstr (char *__haystack, const char *__needle) throw ()
{
  return __builtin_strstr (__haystack, __needle);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strstr (const char *__haystack, const char *__needle) throw ()
{
  return __builtin_strstr (__haystack, __needle);
}

}







extern char *strtok (char *__restrict __s, const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (2)));



extern char *__strtok_r (char *__restrict __s,
    const char *__restrict __delim,
    char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
         char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));





extern "C++" char *strcasestr (char *__haystack, const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
         const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 369 "/usr/include/string.h" 3 4
extern void *memmem (const void *__haystack, size_t __haystacklen,
       const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



extern void *__mempcpy (void *__restrict __dest,
   const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern size_t strlen (const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




extern size_t strnlen (const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




extern char *strerror (int __errnum) throw ();
# 421 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));





extern char *strerror_l (int __errnum, locale_t __l) throw ();



# 1 "/usr/include/strings.h" 1 3 4
# 23 "/usr/include/strings.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 24 "/usr/include/strings.h" 2 3 4






extern "C" {



extern int bcmp (const void *__s1, const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern void bcopy (const void *__src, void *__dest, size_t __n)
  throw () __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));



extern "C++"
{
extern char *index (char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
index (char *__s, int __c) throw ()
{
  return __builtin_index (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
index (const char *__s, int __c) throw ()
{
  return __builtin_index (__s, __c);
}

}







extern "C++"
{
extern char *rindex (char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
rindex (char *__s, int __c) throw ()
{
  return __builtin_rindex (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
rindex (const char *__s, int __c) throw ()
{
  return __builtin_rindex (__s, __c);
}

}
# 104 "/usr/include/strings.h" 3 4
extern int ffs (int __i) throw () __attribute__ ((__const__));





extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
     throw () __attribute__ ((__const__));



extern int strcasecmp (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));



extern int strncasecmp_l (const char *__s1, const char *__s2,
     size_t __n, locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));


}





# 1 "/usr/include/bits/strings_fortified.h" 1 3 4
# 22 "/usr/include/bits/strings_fortified.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void
__attribute__ ((__leaf__)) bcopy (const void *__src, void *__dest, size_t __len) throw ()
{
  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void
__attribute__ ((__leaf__)) bzero (void *__dest, size_t __len) throw ()
{
  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
}
# 145 "/usr/include/strings.h" 2 3 4
# 433 "/usr/include/string.h" 2 3 4



extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));



extern char *strsep (char **__restrict __stringp,
       const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));







extern "C++" char *basename (char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 495 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/string_fortified.h" 1 3 4
# 30 "/usr/include/bits/string_fortified.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) throw ()

{
  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) memmove (void *__dest, const void *__src, size_t __len) throw ()
{
  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len) throw ()

{
  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
}
# 58 "/usr/include/bits/string_fortified.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void *
__attribute__ ((__leaf__)) memset (void *__dest, int __ch, size_t __len) throw ()
{
# 71 "/usr/include/bits/string_fortified.h" 3 4
  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
}




void __explicit_bzero_chk (void *__dest, size_t __len, size_t __destlen)
  throw () __attribute__ ((__nonnull__ (1)));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) void
__attribute__ ((__leaf__)) explicit_bzero (void *__dest, size_t __len) throw ()
{
  __explicit_bzero_chk (__dest, __len, __builtin_object_size (__dest, 0));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strcpy (char *__restrict __dest, const char *__restrict __src) throw ()
{
  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) stpcpy (char *__restrict __dest, const char *__restrict __src) throw ()
{
  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}



extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len) throw ()

{
  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}


extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n,
       size_t __destlen) throw ();
extern char *__stpncpy_alias (char *__dest, const char *__src, size_t __n) throw () __asm__ ("" "stpncpy")
                                 ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) stpncpy (char *__dest, const char *__src, size_t __n) throw ()
{
  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
      && (!__builtin_constant_p (__n) || __n > __builtin_object_size (__dest, 2 > 1)))
    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
  return __stpncpy_alias (__dest, __src, __n);
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strcat (char *__restrict __dest, const char *__restrict __src) throw ()
{
  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
}


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) char *
__attribute__ ((__leaf__)) strncat (char *__restrict __dest, const char *__restrict __src, size_t __len) throw ()

{
  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
}
# 496 "/usr/include/string.h" 2 3 4



}
# 43 "/usr/include/c++/10/cstring" 2 3
# 71 "/usr/include/c++/10/cstring" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::memchr;
  using ::memcmp;
  using ::memcpy;
  using ::memmove;
  using ::memset;
  using ::strcat;
  using ::strcmp;
  using ::strcoll;
  using ::strcpy;
  using ::strcspn;
  using ::strerror;
  using ::strlen;
  using ::strncat;
  using ::strncmp;
  using ::strncpy;
  using ::strspn;
  using ::strtok;
  using ::strxfrm;
  using ::strchr;
  using ::strpbrk;
  using ::strrchr;
  using ::strstr;
# 122 "/usr/include/c++/10/cstring" 3

}
}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 2 3 4







namespace boost {

    namespace detail {

        template <typename charT, typename traits>
        class string_view_traits_eq {
        public:
            string_view_traits_eq ( charT ch ) : ch_(ch) {}
            bool operator()( charT val ) const { return traits::eq (ch_, val); }
            charT ch_;
            };
        }

    template<typename charT, typename traits>
    class basic_string_view {
    public:

      typedef traits traits_type;
      typedef charT value_type;
      typedef charT* pointer;
      typedef const charT* const_pointer;
      typedef charT& reference;
      typedef const charT& const_reference;
      typedef const_pointer const_iterator;
      typedef const_iterator iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef const_reverse_iterator reverse_iterator;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;
      static constexpr size_type npos = size_type(-1);


      constexpr basic_string_view() noexcept
        : ptr_(__null), len_(0) {}



      constexpr basic_string_view(const basic_string_view &rhs) noexcept

        = default;




      basic_string_view& operator=(const basic_string_view &rhs) noexcept

            = default;
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 3 4
      template<typename Allocator>
        basic_string_view(const std::basic_string<charT, traits, Allocator>& str) noexcept
          : ptr_(str.data()), len_(str.length()) {}
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 3 4
      constexpr basic_string_view(const charT* str)
        : ptr_(str), len_(traits::length(str)) {}

      constexpr basic_string_view(const charT* str, size_type len)
        : ptr_(str), len_(len) {}


        constexpr const_iterator begin() const noexcept { return ptr_; }
        constexpr const_iterator cbegin() const noexcept { return ptr_; }
        constexpr const_iterator end() const noexcept { return ptr_ + len_; }
        constexpr const_iterator cend() const noexcept { return ptr_ + len_; }
                const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
                const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
                const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
                const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }


        constexpr size_type size() const noexcept { return len_; }
        constexpr size_type length() const noexcept { return len_; }
        constexpr size_type max_size() const noexcept { return len_; }
        constexpr bool empty() const noexcept { return len_ == 0; }


        constexpr const_reference operator[](size_type pos) const noexcept { return ptr_[pos]; }

        constexpr const_reference at(size_t pos) const {
            return pos >= len_ ? ::boost::exception_detail::throw_exception_(std::out_of_range("boost::string_view::at"),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp",130), ptr_[0] : ptr_[pos];
            }

        constexpr const_reference front() const { return ptr_[0]; }
        constexpr const_reference back() const { return ptr_[len_-1]; }
        constexpr const_pointer data() const noexcept { return ptr_; }


        void clear() noexcept { len_ = 0; }

        constexpr void remove_prefix(size_type n) {
            if ( n > len_ )
                n = len_;
            ptr_ += n;
            len_ -= n;
            }

        constexpr void remove_suffix(size_type n) {
            if ( n > len_ )
                n = len_;
            len_ -= n;
            }

        constexpr void swap(basic_string_view& s) noexcept {
            std::swap(ptr_, s.ptr_);
            std::swap(len_, s.len_);
            }



        template<typename Allocator>
        explicit operator std::basic_string<charT, traits, Allocator>() const {
            return std::basic_string<charT, traits, Allocator>(begin(), end());
            }



        template<typename Allocator = std::allocator<charT> >
        std::basic_string<charT, traits, Allocator> to_string(const Allocator& a = Allocator()) const {
            return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
            }
# 182 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 3 4
        size_type copy(charT* s, size_type n, size_type pos=0) const {
            if (pos > size())
                ::boost::exception_detail::throw_exception_(std::out_of_range("string_view::copy" ),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp",184);
            size_type rlen = (std::min)(n, len_ - pos);
      traits_type::copy(s, data() + pos, rlen);
            return rlen;
            }

        constexpr basic_string_view substr(size_type pos, size_type n=npos) const {
            if ( pos > size())
                ::boost::exception_detail::throw_exception_(std::out_of_range ( "string_view::substr" ),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp",192);
            return basic_string_view(data() + pos, (std::min)(size() - pos, n));
            }

        constexpr int compare(basic_string_view x) const noexcept {
            const int cmp = traits::compare(ptr_, x.ptr_, (std::min)(len_, x.len_));
            return cmp != 0 ? cmp : (len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1);
            }

        constexpr int compare(size_type pos1, size_type n1, basic_string_view x)
          const noexcept {
            return substr(pos1, n1).compare(x);
            }

        constexpr int compare(size_type pos1, size_type n1,
          basic_string_view x, size_type pos2, size_type n2) const {
            return substr(pos1, n1).compare(x.substr(pos2, n2));
            }

        constexpr int compare(const charT* x) const {
            return compare(basic_string_view(x));
            }

        constexpr int compare(size_type pos1, size_type n1, const charT* x) const {
            return substr(pos1, n1).compare(basic_string_view(x));
            }

        constexpr int compare(size_type pos1, size_type n1,
          const charT* x, size_type n2) const {
            return substr(pos1, n1).compare(basic_string_view(x, n2));
            }


        constexpr bool starts_with(charT c) const noexcept {
            return !empty() && traits::eq(c, front());
            }

        constexpr bool starts_with(basic_string_view x) const noexcept {
            return len_ >= x.len_ && traits::compare(ptr_, x.ptr_, x.len_) == 0;
            }

        constexpr bool ends_with(charT c) const noexcept {
            return !empty() && traits::eq(c, back());
            }

        constexpr bool ends_with(basic_string_view x) const noexcept {
            return len_ >= x.len_ &&
               traits::compare(ptr_ + len_ - x.len_, x.ptr_, x.len_) == 0;
            }


        constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept {
            if (pos > size())
              return npos;
            if (s.empty())
              return pos;
            const_iterator iter = std::search(this->cbegin() + pos, this->cend(),
                                               s.cbegin (), s.cend (), traits::eq);
            return iter == this->cend () ? npos : std::distance(this->cbegin (), iter);
            }
        constexpr size_type find(charT c, size_type pos = 0) const noexcept
            { return find(basic_string_view(&c, 1), pos); }
        constexpr size_type find(const charT* s, size_type pos, size_type n) const noexcept
            { return find(basic_string_view(s, n), pos); }
        constexpr size_type find(const charT* s, size_type pos = 0) const noexcept
            { return find(basic_string_view(s), pos); }


        constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept {
            if (len_ < s.len_)
              return npos;
            if (pos > len_ - s.len_)
              pos = len_ - s.len_;
            if (s.len_ == 0u)
              return pos;
            for (const charT* cur = ptr_ + pos; ; --cur) {
                if (traits::compare(cur, s.ptr_, s.len_) == 0)
                  return cur - ptr_;
                if (cur == ptr_)
                  return npos;
                };
            }
        constexpr size_type rfind(charT c, size_type pos = npos) const noexcept
            { return rfind(basic_string_view(&c, 1), pos); }
        constexpr size_type rfind(const charT* s, size_type pos, size_type n) const noexcept
            { return rfind(basic_string_view(s, n), pos); }
        constexpr size_type rfind(const charT* s, size_type pos = npos) const noexcept
            { return rfind(basic_string_view(s), pos); }


        constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept {
            if (pos >= len_ || s.len_ == 0)
              return npos;
            const_iterator iter = std::find_first_of
                (this->cbegin () + pos, this->cend (), s.cbegin (), s.cend (), traits::eq);
            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
            }
        constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept
            { return find_first_of(basic_string_view(&c, 1), pos); }
        constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const noexcept
            { return find_first_of(basic_string_view(s, n), pos); }
        constexpr size_type find_first_of(const charT* s, size_type pos = 0) const noexcept
            { return find_first_of(basic_string_view(s), pos); }


        constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept {
            if (s.len_ == 0u)
              return npos;
            if (pos >= len_)
              pos = 0;
            else
              pos = len_ - (pos+1);
            const_reverse_iterator iter = std::find_first_of
                ( this->crbegin () + pos, this->crend (), s.cbegin (), s.cend (), traits::eq );
            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter);
            }
        constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept
            { return find_last_of(basic_string_view(&c, 1), pos); }
        constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const noexcept
            { return find_last_of(basic_string_view(s, n), pos); }
        constexpr size_type find_last_of(const charT* s, size_type pos = npos) const noexcept
            { return find_last_of(basic_string_view(s), pos); }


        constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept {
            if (pos >= len_)
              return npos;
            if (s.len_ == 0)
              return pos;
            const_iterator iter = find_not_of ( this->cbegin () + pos, this->cend (), s );
            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
            }
        constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept
            { return find_first_not_of(basic_string_view(&c, 1), pos); }
        constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const noexcept
            { return find_first_not_of(basic_string_view(s, n), pos); }
        constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const noexcept
            { return find_first_not_of(basic_string_view(s), pos); }


        constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept {
            if (pos >= len_)
              pos = len_ - 1;
            if (s.len_ == 0u)
              return pos;
            pos = len_ - (pos+1);
            const_reverse_iterator iter = find_not_of ( this->crbegin () + pos, this->crend (), s );
            return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
            }
        constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept
            { return find_last_not_of(basic_string_view(&c, 1), pos); }
        constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const noexcept
            { return find_last_not_of(basic_string_view(s, n), pos); }
        constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const noexcept
            { return find_last_not_of(basic_string_view(s), pos); }

    private:
        template <typename r_iter>
        size_type reverse_distance(r_iter first, r_iter last) const noexcept {

            return len_ - 1 - std::distance ( first, last );
            }

        template <typename Iterator>
        Iterator find_not_of(Iterator first, Iterator last, basic_string_view s) const noexcept {
            for (; first != last ; ++first)
                if ( 0 == traits::find(s.ptr_, s.len_, *first))
                    return first;
            return last;
            }

        const charT *ptr_;
        std::size_t len_;
        };




    template<typename charT, typename traits>
    inline constexpr bool operator==(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) noexcept {
        if (x.size () != y.size ()) return false;
        return x.compare(y) == 0;
        }


    template<typename charT, typename traits>
    inline constexpr bool operator!=(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) noexcept {
        if ( x.size () != y.size ()) return true;
        return x.compare(y) != 0;
        }


    template<typename charT, typename traits>
    inline constexpr bool operator<(basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept {
        return x.compare(y) < 0;
        }


    template<typename charT, typename traits>
    inline constexpr bool operator>(basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept {
        return x.compare(y) > 0;
        }


    template<typename charT, typename traits>
    inline constexpr bool operator<=(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) noexcept {
        return x.compare(y) <= 0;
        }


    template<typename charT, typename traits>
    inline constexpr bool operator>=(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) noexcept {
        return x.compare(y) >= 0;
        }


    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator==(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) noexcept {
        return x == basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator==(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) == y;
        }

    template<typename charT, typename traits>
    inline constexpr bool operator==(basic_string_view<charT, traits> x,
                                              const charT * y) noexcept {
        return x == basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline constexpr bool operator==(const charT * x,
                           basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) == y;
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator!=(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) noexcept {
        return x != basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) != y;
        }

    template<typename charT, typename traits>
    inline constexpr bool operator!=(basic_string_view<charT, traits> x,
                           const charT * y) noexcept {
        return x != basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline constexpr bool operator!=(const charT * x,
                           basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) != y;
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator<(basic_string_view<charT, traits> x,
                    const std::basic_string<charT, traits, Allocator> & y) noexcept {
        return x < basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator<(const std::basic_string<charT, traits, Allocator> & x,
                                basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) < y;
        }

    template<typename charT, typename traits>
    inline constexpr bool operator<(basic_string_view<charT, traits> x,
                          const charT * y) noexcept {
        return x < basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline constexpr bool operator<(const charT * x,
                          basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) < y;
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator>(basic_string_view<charT, traits> x,
                    const std::basic_string<charT, traits, Allocator> & y) noexcept {
        return x > basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator>(const std::basic_string<charT, traits, Allocator> & x,
                                basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) > y;
        }

    template<typename charT, typename traits>
    inline constexpr bool operator>(basic_string_view<charT, traits> x,
                          const charT * y) noexcept {
        return x > basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline constexpr bool operator>(const charT * x,
                          basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) > y;
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator<=(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) noexcept {
        return x <= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) <= y;
        }

    template<typename charT, typename traits>
    inline constexpr bool operator<=(basic_string_view<charT, traits> x,
                           const charT * y) noexcept {
        return x <= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline constexpr bool operator<=(const charT * x,
                           basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) <= y;
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator>=(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) noexcept {
        return x >= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline constexpr bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) >= y;
        }

    template<typename charT, typename traits>
    inline constexpr bool operator>=(basic_string_view<charT, traits> x,
                           const charT * y) noexcept {
        return x >= basic_string_view<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline constexpr bool operator>=(const charT * x,
                           basic_string_view<charT, traits> y) noexcept {
        return basic_string_view<charT, traits>(x) >= y;
        }

    namespace detail {

        template<class charT, class traits>
        inline void sv_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
            enum { chunk_size = 8 };
            charT fill_chars[chunk_size];
            std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
            for (; n >= chunk_size && os.good(); n -= chunk_size)
                os.write(fill_chars, static_cast< std::size_t >(chunk_size));
            if (n > 0 && os.good())
                os.write(fill_chars, n);
            }

        template<class charT, class traits>
        void sv_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_view<charT,traits>& str) {
            const std::size_t size = str.size();
            const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
            const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
            if (!align_left) {
                detail::sv_insert_fill_chars(os, alignment_size);
                if (os.good())
                    os.write(str.data(), size);
                }
            else {
                os.write(str.data(), size);
                if (os.good())
                    detail::sv_insert_fill_chars(os, alignment_size);
                }
            }

        }


    template<class charT, class traits>
    inline std::basic_ostream<charT, traits>&
    operator<<(std::basic_ostream<charT, traits>& os,
      const basic_string_view<charT,traits>& str) {
        if (os.good()) {
            const std::size_t size = str.size();
            const std::size_t w = static_cast< std::size_t >(os.width());
            if (w <= size)
                os.write(str.data(), size);
            else
                detail::sv_insert_aligned(os, str);
            os.width(0);
            }
        return os;
        }
# 678 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_view.hpp" 3 4
}
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/workaround.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/workaround.hpp" 3 4
         
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/type_traits.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/type_traits.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/workaround.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/workaround.hpp" 3 4
         
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 3 4
         

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils_core.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils_core.hpp" 3 4
         




namespace boost {
namespace move_detail {




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>
{};




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 : enable_if_c<Cond::value, T> {};




template <bool B, class T = void>
struct disable_if_c
   : enable_if_c<!B, T>
{};




template <class Cond, class T = void>
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 = void>
struct enable_if_same : enable_if<is_same<T, U>, R> {};




template <class T, class U, class R = void>
struct disable_if_same : disable_if<is_same<T, U>, R> {};

}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 2 3 4




namespace boost {


template <class T> class rv;

namespace move_detail {




template<class T, class U>
struct is_different
{
   static const bool value = !is_same<T, U>::value;
};




template<class F, class Param>
struct apply
{
   typedef typename F::template apply<Param>::type type;
};





template< bool C_ >
struct bool_ : integral_constant<bool, C_>
{
     operator bool() const { return C_; }
   bool operator()() const { return C_; }
};

typedef bool_<true> true_;
typedef bool_<false> false_;




struct nat{};




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;
};
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 3 4
template< class T > struct remove_pointer { typedef T type; };
template< class T > struct remove_pointer<T*> { typedef T type; };
template< class T > struct remove_pointer<T* const> { typedef T type; };
template< class T > struct remove_pointer<T* volatile> { typedef T type; };
template< class T > struct remove_pointer<T* const volatile> { typedef T type; };




template< class T >
struct add_pointer
{
   typedef typename remove_reference<T>::type* type;
};




template<class T>
struct add_const
{
   typedef const T type;
};

template<class T>
struct add_const<T&>
{
   typedef const T& type;
};



template<class T>
struct add_const<T&&>
{
   typedef T&& type;
};






template<class T>
struct add_lvalue_reference
{ typedef T& type; };

template<class T> struct add_lvalue_reference<T&> { typedef T& type; };
template<> struct add_lvalue_reference<void> { typedef void type; };
template<> struct add_lvalue_reference<const void> { typedef const void type; };
template<> struct add_lvalue_reference<volatile void> { typedef volatile void type; };
template<> struct add_lvalue_reference<const volatile void>{ typedef const volatile void type; };

template<class T>
struct add_const_lvalue_reference
{
   typedef typename remove_reference<T>::type t_unreferenced;
   typedef typename add_const<t_unreferenced>::type t_unreferenced_const;
   typedef typename add_lvalue_reference
      <t_unreferenced_const>::type type;
};




template<class T>
struct is_lvalue_reference
{
    static const bool value = false;
};

template<class T>
struct is_lvalue_reference<T&>
{
    static const bool value = true;
};





template <class T>
struct identity
{
   typedef T type;
   typedef typename add_const_lvalue_reference<T>::type reference;
   reference operator()(reference t)
   { return t; }
};




template<class T>
struct is_class_or_union
{
   struct twochar { char dummy[2]; };
   template <class U>
   static char is_class_or_union_tester(void(U::*)(void));
   template <class U>
   static twochar is_class_or_union_tester(...);
   static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
};




template<class T>
struct addr_impl_ref
{
   T & v_;
   inline __attribute__ ((__always_inline__)) addr_impl_ref( T & v ): v_( v ) {}
   inline __attribute__ ((__always_inline__)) operator T& () const { return v_; }

   private:
   addr_impl_ref & operator=(const addr_impl_ref &);
};

template<class T>
struct addressof_impl
{
   inline __attribute__ ((__always_inline__)) static T * f( T & v, long )
   {
      return reinterpret_cast<T*>(
         &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
   }

   inline __attribute__ ((__always_inline__)) static T * f( T * v, int )
   { return v; }
};

template<class T>
inline __attribute__ ((__always_inline__)) T * addressof( T & v )
{
   return ::boost::move_detail::addressof_impl<T>::f
      ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
}




template <class T>
struct has_pointer_type
{
   struct two { char c[2]; };
   template <class U> static two test(...);
   template <class U> static char test(typename U::pointer* = 0);
   static const bool value = sizeof(test<T>(0)) == 1;
};
# 300 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; };
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 3 4
template< class T >
struct add_rvalue_reference
{ typedef T&& type; };
# 553 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; };
# 580 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 3 4
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 584 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/meta_utils.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/static_assert.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 2 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 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>
{};
# 564 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>
{};
# 666 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>
{};
# 713 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
};
# 739 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 3 4
template<class T>
struct is_copy_constructible
{
# 750 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);



};
# 775 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 3 4
template <class T>
struct is_copy_assignable
{
# 787 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 = (__has_trivial_destructor(T) ); };




template<class T>
struct is_trivially_default_constructible
{ static const bool value = ((__has_trivial_constructor(T) )); };




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 && ((__has_trivial_copy(T) )));
};




template<class T>
struct is_trivially_move_constructible
{ static const bool value = ::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 && ((__has_trivial_assign(T) ) ));
};




template<class T>
struct is_trivially_move_assignable
{ static const bool value = ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_default_constructible
   : is_pod<T>
{ static const bool value = (__has_nothrow_constructor(T) ); };




template<class T>
struct is_nothrow_copy_constructible
{ static const bool value = ((__has_nothrow_copy(T) )); };




template<class T>
struct is_nothrow_move_constructible
{ static const bool value = ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_copy_assignable
{ static const bool value = ((__has_nothrow_assign(T) )); };




template<class T>
struct is_nothrow_move_assignable
{ static const bool value = ::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();
};

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
# 923 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
typedef int (alignment_dummy::*member_function_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_;
   member_function_ptr member_function_ptr_;
   alignment_struct alignment_struct_;
};

typedef union max_align max_align_t;







template<std::size_t Len, std::size_t Align>
struct aligned_struct;
# 981 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 3 4
template<std::size_t Len>struct alignas(0x1) aligned_struct<Len, 0x1>{ char data[Len];};
template<std::size_t Len>struct alignas(0x2) aligned_struct<Len, 0x2>{ char data[Len];};
template<std::size_t Len>struct alignas(0x4) aligned_struct<Len, 0x4>{ char data[Len];};
template<std::size_t Len>struct alignas(0x8) aligned_struct<Len, 0x8>{ char data[Len];};
template<std::size_t Len>struct alignas(0x10) aligned_struct<Len, 0x10>{ char data[Len];};
template<std::size_t Len>struct alignas(0x20) aligned_struct<Len, 0x20>{ char data[Len];};
template<std::size_t Len>struct alignas(0x40) aligned_struct<Len, 0x40>{ char data[Len];};
template<std::size_t Len>struct alignas(0x80) aligned_struct<Len, 0x80>{ char data[Len];};
template<std::size_t Len>struct alignas(0x100) aligned_struct<Len, 0x100>{ char data[Len];};
template<std::size_t Len>struct alignas(0x200) aligned_struct<Len, 0x200>{ char data[Len];};
template<std::size_t Len>struct alignas(0x400) aligned_struct<Len, 0x400>{ char data[Len];};
template<std::size_t Len>struct alignas(0x800) aligned_struct<Len, 0x800>{ char data[Len];};
template<std::size_t Len>struct alignas(0x1000) aligned_struct<Len, 0x1000>{ char data[Len];};





template<std::size_t Len, std::size_t Align>
union aligned_struct_wrapper
{
   aligned_struct<Len, Align> aligner;
   char data[sizeof(aligned_struct<Len, Align>)];
};

template<std::size_t Len, std::size_t Align>
struct aligned_storage_impl
{
   typedef aligned_struct_wrapper<Len, Align> type;
};
# 1063 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 1085 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/type_traits.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/type_traits.hpp" 2 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::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::max_align_t;

}
}
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/container_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/container_fwd.hpp" 3 4
         
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/container_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/std_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/std_fwd.hpp" 3 4
         






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/std_ns_begin.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 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;

 }
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/std_ns_end.hpp" 1 3 4
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/std_fwd.hpp" 2 3 4
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
}}}
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/container_fwd.hpp" 3 4
namespace boost {
namespace container {



template<class T>
class new_allocator;

template <class T
         ,class Allocator = new_allocator<T>
         ,class Options = void>
class vector;

template <class T
         ,class Allocator = new_allocator<T> >
class stable_vector;

template <class T, std::size_t Capacity>
class static_vector;

template < class T, std::size_t N
         , class Allocator= new_allocator<T> >
class small_vector;

template <class T
         ,class Allocator = new_allocator<T> >
class deque;

template <class T
         ,class Allocator = new_allocator<T> >
class list;

template <class T
         ,class Allocator = new_allocator<T> >
class slist;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<Key>
         ,class Options = void>
class set;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<Key>
         ,class Options = void >
class multiset;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<std::pair<const Key, T> >
         ,class Options = void >
class map;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<std::pair<const Key, T> >
         ,class Options = void >
class multimap;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<Key> >
class flat_set;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<Key> >
class flat_multiset;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<std::pair<Key, T> > >
class flat_map;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = new_allocator<std::pair<Key, T> > >
class flat_multimap;

template <class CharT
         ,class Traits = std::char_traits<CharT>
         ,class Allocator = new_allocator<CharT> >
class basic_string;

typedef basic_string
   <char
   ,std::char_traits<char>
   ,new_allocator<char> >
string;

typedef basic_string
   <wchar_t
   ,std::char_traits<wchar_t>
   ,new_allocator<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;
   }
};

}




}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/mpl.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/mpl.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/mpl.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/mpl.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/mpl.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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::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;
};
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/mpl.hpp" 3 4
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/mpl.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

template <class FirstType>
struct select1st
{
   typedef FirstType type;

   template<class T>
   const type& operator()(const T& x) const
   { return x.first; }

   template<class T>
   type& operator()(T& x)
   { return const_cast<type&>(x.first); }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/mpl.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/placement_new.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/workaround.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/workaround.hpp" 3 4
         
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_rebind.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; };

}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/pointer_element.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/pointer_element.hpp" 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_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; };

}
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 3 4
template <typename Ptr>
struct pointer_traits
{
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_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;
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 3 4
   static pointer pointer_to(reference r)
   {


      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);
   }
# 145 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 3 4
   template<class UPtr>
   static pointer static_cast_from(const UPtr &uptr)
   {
      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);
   }
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 3 4
   template<class UPtr>
   static pointer const_cast_from(const UPtr &uptr)
   {
      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);
   }
# 187 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 3 4
   template<class UPtr>
   static pointer dynamic_cast_from(const UPtr &uptr)
   {
      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>
   static T* to_raw_pointer(T* p)
   { return p; }

   template <class Pointer>
   static typename pointer_traits<Pointer>::element_type*
      to_raw_pointer(const Pointer &p)
   { return pointer_traits::to_raw_pointer(p.operator->()); }


   static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r)
   { return Ptr::pointer_to(r); }

   static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r)
   { return pointer(boost::intrusive::detail::addressof(r)); }


   template<class UPtr>
   static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
   { return Ptr::static_cast_from(uptr); }

   template<class UPtr>
   static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
   { return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer(); }


   template<class UPtr>
   static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
   { return Ptr::const_cast_from(uptr); }

   template<class UPtr>
   static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
   { return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer(); }


   template<class UPtr>
   static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr)
   { return Ptr::dynamic_cast_from(uptr); }

   template<class UPtr>
   static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr)
   { 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;
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 static pointer pointer_to(reference r)
   { return boost::intrusive::detail::addressof(r); }



   template<class U>
   inline static pointer static_cast_from(U *uptr)
   { return static_cast<pointer>(uptr); }



   template<class U>
   inline static pointer const_cast_from(U *uptr)
   { return const_cast<pointer>(uptr); }



   template<class U>
   inline static pointer dynamic_cast_from(U *uptr)
   { return dynamic_cast<pointer>(uptr); }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_traits.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility_core.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility_core.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility_core.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/core.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/core.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/core.hpp" 2 3 4
# 310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
   };

   }
# 483 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/core.hpp" 3 4
   namespace boost {
   namespace move_detail {

   template< class T> struct forward_type { typedef T type; };

   }}



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 493 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/core.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility_core.hpp" 2 3 4
# 174 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility_core.hpp" 3 4
      namespace boost {







      template<class T>
      struct enable_move_utility_emulation
      {
         static const bool value = false;
      };
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility_core.hpp" 3 4
         template <class T>
         inline __attribute__ ((__always_inline__)) T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) noexcept
         { return static_cast<T&&>(t); }

         template <class T>
         inline __attribute__ ((__always_inline__)) T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) noexcept
         {

            static_assert(!boost::move_detail::is_lvalue_reference<T>::value, "!boost::move_detail::is_lvalue_reference<T>::value");
            return static_cast<T&&>(t);
         }
# 282 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility_core.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/fwd_macros.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4



namespace boost {
namespace container {



template<class Allocator>
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>
struct is_std_allocator< small_vector_allocator< std::allocator<T> > >
{ 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;
# 199 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> >;
# 285 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)...); }
# 453 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; }


};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 476 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/allocator_traits.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/new_allocator.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/new_allocator.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/new_allocator.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 3 4
namespace boost {
namespace container {
# 105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 3 4
   inline void throw_bad_alloc()
   {
      throw std::bad_alloc();
   }
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 3 4
   inline void throw_out_of_range(const char* str)
   {
      throw std::out_of_range(str);
   }
# 137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 3 4
   inline void throw_length_error(const char* str)
   {
      throw std::length_error(str);
   }
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 3 4
   inline void throw_logic_error(const char* str)
   {
      throw std::logic_error(str);
   }
# 170 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 3 4
   inline void throw_runtime_error(const char* str)
   {
      throw std::runtime_error(str);
   }



}}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 180 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/throw_exception.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
   {}



   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
   {}



   template<class T2>
   new_allocator(const new_allocator<T2> &) noexcept
   {}



   pointer allocate(size_type count)
   {
      if(__builtin_expect(count > this->max_size(), 0))
         throw_bad_alloc();
      return static_cast<T*>(::operator new(count*sizeof(T)));
   }



   void deallocate(pointer ptr, size_type) noexcept
     { ::operator delete((void*)ptr); }



   size_type max_size() const noexcept
   { return size_type(-1)/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 178 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/new_allocator.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/options.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/options.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/options.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pack_options.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pack_options.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pack_options.hpp" 2 3 4


         


namespace boost {
namespace intrusive {





template<class Prev, class Next>
struct do_pack
{

   typedef typename Next::template pack<Prev> type;
};

template<class Prev>
struct do_pack<Prev, void>
{

   typedef Prev type;
};

template
   < class DefaultOptions
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   , class O7 = void
   , class O8 = void
   , class O9 = void
   , class O10 = void
   , class O11 = void
   >
struct pack_options
{

   typedef
      typename do_pack
      < typename do_pack
         < typename do_pack
            < typename do_pack
               < typename do_pack
                  < typename do_pack
                     < typename do_pack
                        < typename do_pack
                           < typename do_pack
                              < typename do_pack
                                 < typename do_pack
                                    < DefaultOptions
                                    , O1
                                    >::type
                                 , O2
                                 >::type
                              , O3
                              >::type
                           , O4
                           >::type
                        , O5
                        >::type
                     , O6
                     >::type
                  , O7
                  >::type
               , O8
               >::type
            , O9
            >::type
         , O10
         >::type
      , O11
      >::type
   type;
};
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pack_options.hpp" 3 4
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pack_options.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/options.hpp" 2 3 4

namespace boost {
namespace container {
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 { template<class Base> struct pack : Base { static const tree_type_enum tree_type = TreeType; }; };



template< bool Enabled> struct optimize_size { template<class Base> struct pack : Base { static const bool optimize_size = Enabled; }; };
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/options.hpp" 3 4
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;
# 175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/options.hpp" 3 4
template< class GrowthFactor> struct growth_factor { template<class Base> struct pack : Base { typedef GrowthFactor growth_factor_type; }; };
# 202 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 244 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/options.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 3 4
         





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterator.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/iterator.hpp" 3 4
         



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/std_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/std_fwd.hpp" 3 4
         






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/std_ns_begin.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/std_ns_end.hpp" 1 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/std_fwd.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/iterator.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/iterator_traits.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/iterator_traits.hpp" 3 4
         





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/std_ns_begin.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/iterator_traits.hpp" 2 3 4
namespace std __attribute__ ((__visibility__ ("default"))) {

struct input_iterator_tag;
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;
struct output_iterator_tag;

 }
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/std_ns_end.hpp" 1 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/iterator_traits.hpp" 2 3 4

namespace boost{ namespace movelib{

template<class Iterator>
struct iterator_traits
{
   typedef typename Iterator::difference_type difference_type;
   typedef typename Iterator::value_type value_type;
   typedef typename Iterator::pointer pointer;
   typedef typename Iterator::reference reference;
   typedef typename Iterator::iterator_category iterator_category;
   typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
};

template<class T>
struct iterator_traits<T*>
{
   typedef std::ptrdiff_t difference_type;
   typedef T value_type;
   typedef T* pointer;
   typedef T& reference;
   typedef std::random_access_iterator_tag iterator_category;
   typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
};

template<class T>
struct iterator_traits<const T*>
{
   typedef std::ptrdiff_t difference_type;
   typedef T value_type;
   typedef const T* pointer;
   typedef const T& reference;
   typedef std::random_access_iterator_tag iterator_category;
   typedef typename boost::move_detail::make_unsigned<difference_type>::type size_type;
};

}}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/iterator.hpp" 2 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;




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 I>
struct is_boost_iterator
{
   static const bool value = false;
};

template<class Category, class Traversal>
struct is_boost_iterator< boost::iterators::detail::iterator_category_with_traversal<Category, Traversal> >
{
   static const bool value = true;
};

template<class I, class R = void>
struct iterator_enable_if_boost_iterator
   : ::boost::move_detail::enable_if_c
      < is_boost_iterator<typename boost::intrusive::iterator_traits<I>::iterator_category >::value
      , R>
{};




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 boost::intrusive::iterator_traits<I>::iterator_category
         , 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 boost::intrusive::iterator_traits<I>::iterator_category
         , 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 boost::intrusive::iterator_traits<I>::iterator_category
         , Tag
         >::value &&
        !::boost::move_detail::is_same_or_convertible
         < typename boost::intrusive::iterator_traits<I>::iterator_category
         , Tag2
         >::value
         , R>
{};




template<class I, class Tag>
struct iterator_enable_if_tag_difference_type
   : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
{};

template<class I, class Tag>
struct iterator_disable_if_tag_difference_type
   : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iterator_traits<I>::difference_type>
{};





template<class InputIt, class Distance>
inline typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
    ++it;
}

template<class InputIt, class Distance>
typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
    ++it;
}

template<class InputIt, class Distance>
inline typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
   iterator_advance(InputIt& it, Distance n)
{
   for (; 0 < n; --n)
    ++it;
   for (; n < 0; ++n)
    --it;
}

template<class InputIt, class Distance>
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 typename iterator_enable_if_convertible_tag
   <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
    ++it;
}

template<class InputIt, class Distance>
inline typename iterator_enable_if_convertible_tag
   <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
    ++it;
}

template<class InputIt, class Distance>
inline typename iterator_enable_if_convertible_tag
   <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
   iterator_advance(InputIt& it, Distance n)
{
   while(n--)
    ++it;
}

template<class InputIt, class Distance>
inline typename iterator_enable_if_convertible_tag
   <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
   iterator_advance(InputIt& it, Distance n)
{
   for (; 0 < n; --n)
    ++it;
   for (; n < 0; ++n)
    --it;
}

class fake{};

template<class InputIt, class Distance>
inline typename iterator_enable_if_convertible_tag
   <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
   iterator_advance(InputIt& it, Distance n)
{
   it += n;
}




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 iterator_traits<InputIt>::difference_type off = 0;
   while(first != last){
    ++off;
      ++first;
   }
   return off;
}

template<class InputIt>
inline typename iterator_enable_if_tag_difference_type
   <InputIt, std::random_access_iterator_tag>::type
      iterator_distance(InputIt first, InputIt last)
{
   typename iterator_traits<InputIt>::difference_type off = last - first;
   return off;
}

template<class I>
inline typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
{ return i.operator->(); }

template<class T>
inline T * iterator_arrow_result(T *p)
{ return p; }

}
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterator.hpp" 2 3 4


namespace boost {
namespace container {

using ::boost::intrusive::iterator_traits;
using ::boost::intrusive::iterator_distance;
using ::boost::intrusive::iterator_advance;
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; }
};


}
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/iterator_to_raw_pointer.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/iterator_to_raw_pointer.hpp" 3 4
         



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/to_raw_pointer.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/to_raw_pointer.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/to_raw_pointer.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/iterator_to_raw_pointer.hpp" 2 3 4


namespace boost {
namespace movelib {
namespace detail {

template <class T>
inline T* iterator_to_pointer(T* i)
{ return i; }

template <class Iterator>
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 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/construct_in_place.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/construct_in_place.hpp" 3 4
         



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/value_init.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/value_init.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/value_init.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/reverse_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/reverse_iterator.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/reverse_iterator.hpp" 2 3 4



namespace boost {
namespace intrusive {

template<class It>
class reverse_iterator
{
   public:
   typedef typename boost::intrusive::iterator_traits<It>::pointer pointer;
   typedef typename boost::intrusive::iterator_traits<It>::reference reference;
   typedef typename boost::intrusive::iterator_traits<It>::difference_type difference_type;
   typedef typename boost::intrusive::iterator_traits<It>::iterator_category iterator_category;
   typedef typename boost::intrusive::iterator_traits<It>::value_type value_type;


   typedef It iterator_type;

   reverse_iterator()
      : m_current()
   {}

   explicit reverse_iterator(It r)
      : m_current(r)
   {}

   reverse_iterator(const reverse_iterator& r)
      : m_current(r.base())
   {}

   template<class OtherIt>
   reverse_iterator( const reverse_iterator<OtherIt>& r
                   , typename boost::intrusive::detail::enable_if_convertible<OtherIt, It>::type* =0
                   )
      : m_current(r.base())
   {}

   reverse_iterator & operator=( const reverse_iterator& r)
   { m_current = r.base(); return *this; }

   template<class OtherIt>
   typename boost::intrusive::detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
         operator=( const reverse_iterator<OtherIt>& r)
   { m_current = r.base(); return *this; }

   It base() const
   { return m_current; }

   reference operator*() const
   {
      It temp(m_current);
      --temp;
      reference r = *temp;
      return r;
   }

   pointer operator->() const
   {
      It temp(m_current);
      --temp;
      return iterator_arrow_result(temp);
   }

   reference operator[](difference_type off) const
   {
      return this->m_current[-off - 1];
   }

   reverse_iterator& operator++()
   {
      --m_current;
      return *this;
   }

   reverse_iterator operator++(int)
   {
      reverse_iterator temp((*this));
      --m_current;
      return temp;
   }

   reverse_iterator& operator--()
   {
      ++m_current;
      return *this;
   }

   reverse_iterator operator--(int)
   {
      reverse_iterator temp((*this));
      ++m_current;
      return temp;
   }

   friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current == r.m_current; }

   friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current != r.m_current; }

   friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current > r.m_current; }

   friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current >= r.m_current; }

   friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current < r.m_current; }

   friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current <= r.m_current; }

   reverse_iterator& operator+=(difference_type off)
   { m_current -= off; return *this; }

   reverse_iterator& operator-=(difference_type off)
   { m_current += off; return *this; }

   friend reverse_iterator operator+(reverse_iterator l, difference_type off)
   { return (l += off); }

   friend reverse_iterator operator+(difference_type off, reverse_iterator r)
   { return (r += off); }

   friend reverse_iterator operator-(reverse_iterator l, difference_type off)
   { return (l-= off); }

   friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
   { return r.m_current - l.m_current; }

   private:
   It m_current;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/reverse_iterator.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/variadic_templates_tools.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/variadic_templates_tools.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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(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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/variadic_templates_tools.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 2 3 4



namespace boost {
namespace container {

template <class T, class Difference = std::ptrdiff_t>
class constant_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
{
   typedef constant_iterator<T, Difference> this_type;

   public:
   explicit constant_iterator(const T &ref, Difference range_size)
      : m_ptr(&ref), m_num(range_size){}


   constant_iterator()
      : m_ptr(0), m_num(0){}

   constant_iterator& operator++()
   { increment(); return *this; }

   constant_iterator operator++(int)
   {
      constant_iterator result (*this);
      increment();
      return result;
   }

   constant_iterator& operator--()
   { decrement(); return *this; }

   constant_iterator operator--(int)
   {
      constant_iterator result (*this);
      decrement();
      return result;
   }

   friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
   { return i.equal(i2); }

   friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
   { return !(i == i2); }

   friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
   { return i.less(i2); }

   friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
   { return i2 < i; }

   friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
   { return !(i > i2); }

   friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
   { return !(i < i2); }

   friend Difference operator- (const constant_iterator& i, const constant_iterator& i2)
   { return i2.distance_to(i); }


   constant_iterator& operator+=(Difference off)
   { this->advance(off); return *this; }

   constant_iterator operator+(Difference off) const
   {
      constant_iterator other(*this);
      other.advance(off);
      return other;
   }

   friend constant_iterator operator+(Difference off, const constant_iterator& right)
   { return right + off; }

   constant_iterator& operator-=(Difference off)
   { this->advance(-off); return *this; }

   constant_iterator operator-(Difference off) const
   { return *this + (-off); }

   const T& operator*() const
   { return dereference(); }

   const T& operator[] (Difference ) const
   { return dereference(); }

   const T* operator->() const
   { return &(dereference()); }

   private:
   const T * m_ptr;
   Difference m_num;

   void increment()
   { --m_num; }

   void decrement()
   { ++m_num; }

   bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   bool less(const this_type &other) const
   { return other.m_num < m_num; }

   const T & dereference() const
   { return *m_ptr; }

   void advance(Difference n)
   { m_num -= n; }

   Difference distance_to(const this_type &other)const
   { return m_num - other.m_num; }
};

template <class T, class Difference>
class value_init_construct_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
{
   typedef value_init_construct_iterator<T, Difference> this_type;

   public:
   explicit value_init_construct_iterator(Difference range_size)
      : m_num(range_size){}


   value_init_construct_iterator()
      : m_num(0){}

   value_init_construct_iterator& operator++()
   { increment(); return *this; }

   value_init_construct_iterator operator++(int)
   {
      value_init_construct_iterator result (*this);
      increment();
      return result;
   }

   value_init_construct_iterator& operator--()
   { decrement(); return *this; }

   value_init_construct_iterator operator--(int)
   {
      value_init_construct_iterator result (*this);
      decrement();
      return result;
   }

   friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i.equal(i2); }

   friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return !(i == i2); }

   friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i.less(i2); }

   friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i2 < i; }

   friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return !(i > i2); }

   friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return !(i < i2); }

   friend Difference operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i2.distance_to(i); }


   value_init_construct_iterator& operator+=(Difference off)
   { this->advance(off); return *this; }

   value_init_construct_iterator operator+(Difference off) const
   {
      value_init_construct_iterator other(*this);
      other.advance(off);
      return other;
   }

   friend value_init_construct_iterator operator+(Difference off, const value_init_construct_iterator& right)
   { return right + off; }

   value_init_construct_iterator& operator-=(Difference off)
   { this->advance(-off); return *this; }

   value_init_construct_iterator operator-(Difference off) const
   { return *this + (-off); }
# 238 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 3 4
   private:
   Difference m_num;

   void increment()
   { --m_num; }

   void decrement()
   { ++m_num; }

   bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   bool less(const this_type &other) const
   { return other.m_num < m_num; }

   const T & dereference() const
   {
      static T dummy;
      return dummy;
   }

   void advance(Difference n)
   { m_num -= n; }

   Difference distance_to(const this_type &other)const
   { return m_num - other.m_num; }
};

template <class T, class Difference>
class default_init_construct_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
{
   typedef default_init_construct_iterator<T, Difference> this_type;

   public:
   explicit default_init_construct_iterator(Difference range_size)
      : m_num(range_size){}


   default_init_construct_iterator()
      : m_num(0){}

   default_init_construct_iterator& operator++()
   { increment(); return *this; }

   default_init_construct_iterator operator++(int)
   {
      default_init_construct_iterator result (*this);
      increment();
      return result;
   }

   default_init_construct_iterator& operator--()
   { decrement(); return *this; }

   default_init_construct_iterator operator--(int)
   {
      default_init_construct_iterator result (*this);
      decrement();
      return result;
   }

   friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i.equal(i2); }

   friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return !(i == i2); }

   friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i.less(i2); }

   friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i2 < i; }

   friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return !(i > i2); }

   friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return !(i < i2); }

   friend Difference operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i2.distance_to(i); }


   default_init_construct_iterator& operator+=(Difference off)
   { this->advance(off); return *this; }

   default_init_construct_iterator operator+(Difference off) const
   {
      default_init_construct_iterator other(*this);
      other.advance(off);
      return other;
   }

   friend default_init_construct_iterator operator+(Difference off, const default_init_construct_iterator& right)
   { return right + off; }

   default_init_construct_iterator& operator-=(Difference off)
   { this->advance(-off); return *this; }

   default_init_construct_iterator operator-(Difference off) const
   { return *this + (-off); }
# 349 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 3 4
   private:
   Difference m_num;

   void increment()
   { --m_num; }

   void decrement()
   { ++m_num; }

   bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   bool less(const this_type &other) const
   { return other.m_num < m_num; }

   const T & dereference() const
   {
      static T dummy;
      return dummy;
   }

   void advance(Difference n)
   { m_num -= n; }

   Difference distance_to(const this_type &other)const
   { return m_num - other.m_num; }
};


template <class T, class Difference = std::ptrdiff_t>
class repeat_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, Difference, T*, T&>
{
   typedef repeat_iterator<T, Difference> this_type;
   public:
   explicit repeat_iterator(T &ref, Difference range_size)
      : m_ptr(&ref), m_num(range_size){}


   repeat_iterator()
      : m_ptr(0), m_num(0){}

   this_type& operator++()
   { increment(); return *this; }

   this_type operator++(int)
   {
      this_type result (*this);
      increment();
      return result;
   }

   this_type& operator--()
   { increment(); return *this; }

   this_type operator--(int)
   {
      this_type result (*this);
      increment();
      return result;
   }

   friend bool operator== (const this_type& i, const this_type& i2)
   { return i.equal(i2); }

   friend bool operator!= (const this_type& i, const this_type& i2)
   { return !(i == i2); }

   friend bool operator< (const this_type& i, const this_type& i2)
   { return i.less(i2); }

   friend bool operator> (const this_type& i, const this_type& i2)
   { return i2 < i; }

   friend bool operator<= (const this_type& i, const this_type& i2)
   { return !(i > i2); }

   friend bool operator>= (const this_type& i, const this_type& i2)
   { return !(i < i2); }

   friend Difference operator- (const this_type& i, const this_type& i2)
   { return i2.distance_to(i); }


   this_type& operator+=(Difference off)
   { this->advance(off); return *this; }

   this_type operator+(Difference off) const
   {
      this_type other(*this);
      other.advance(off);
      return other;
   }

   friend this_type operator+(Difference off, const this_type& right)
   { return right + off; }

   this_type& operator-=(Difference off)
   { this->advance(-off); return *this; }

   this_type operator-(Difference off) const
   { return *this + (-off); }

   T& operator*() const
   { return dereference(); }

   T& operator[] (Difference ) const
   { return dereference(); }

   T *operator->() const
   { return &(dereference()); }

   private:
   T * m_ptr;
   Difference m_num;

   void increment()
   { --m_num; }

   void decrement()
   { ++m_num; }

   bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   bool less(const this_type &other) const
   { return other.m_num < m_num; }

   T & dereference() const
   { return *m_ptr; }

   void advance(Difference n)
   { m_num -= n; }

   Difference distance_to(const this_type &other)const
   { return m_num - other.m_num; }
};

template <class T, class EmplaceFunctor, class Difference >
class emplace_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
{
   typedef emplace_iterator this_type;

   public:
   typedef Difference 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; }

   this_type operator++(int)
   {
      this_type result (*this);
      increment();
      return result;
   }

   inline __attribute__ ((__always_inline__)) this_type& operator--()
   { decrement(); return *this; }

   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; }

   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>
   void construct_in_place(Allocator &a, T* ptr)
   { (*m_pe)(a, ptr); }

   template<class DestIt>
   void assign_in_place(DestIt dest)
   { (*m_pe)(dest); }

   private:
   difference_type 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;

   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;
};
# 695 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

   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(iterator_from_iiterator<IIterator, false> const& other) noexcept
      : m_iit(other.get())
   {}

   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 == r); }

   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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 874 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/iterators.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/construct_in_place.hpp" 2 3 4


namespace boost {
namespace container {



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, class D>
inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T *dest, value_init_construct_iterator<U, D>)
{
   boost::container::allocator_traits<Allocator>::construct(a, dest);
}

template <class T, class Difference>
class default_init_construct_iterator;

template<class Allocator, class T, class U, class D>
inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T *dest, default_init_construct_iterator<U, D>)
{
   boost::container::allocator_traits<Allocator>::construct(a, dest, default_init);
}

template <class T, class EmplaceFunctor, class Difference>
class emplace_iterator;

template<class Allocator, class T, class U, class EF, class D>
inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T *dest, emplace_iterator<U, EF, D> 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, class D>
inline __attribute__ ((__always_inline__)) void assign_in_place(DstIt dest, value_init_construct_iterator<U, D>)
{
   dtl::value_init<U> val;
   *dest = boost::move(val.get());
}

template <class DstIt, class Difference>
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, D>)
{
   U u;
   *dest = boost::move(u);
}

template <class T, class EmplaceFunctor, class Difference>
class emplace_iterator;

template<class DstIt, class U, class EF, class D>
inline __attribute__ ((__always_inline__)) void assign_in_place(DstIt dest, emplace_iterator<U, EF, D> ei)
{
   ei.assign_in_place(dest);
}

}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/adl_move_swap.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/adl_move_swap.hpp" 3 4
         
# 185 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
}

}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/iterator.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/iterator.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/iterator.hpp" 2 3 4




namespace boost {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/iterator.hpp" 3 4
template<class It>
inline move_iterator<It> make_move_iterator(const It &it)
{ return move_iterator<It>(it); }
# 185 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/iterator.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/no_exceptions_support.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 2 3 4

# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 2 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::iterator_traits<I>::value_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::iterator_traits<I>::value_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::iterator_traits<I>::value_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
   <typename I,
    typename F>
inline F memmove(I f, I l, F r) noexcept
{
   typedef typename boost::container::iterator_traits<I>::value_type value_type;
   typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
   if(n){
      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
      boost::container::iterator_advance(r, n);
   }
   return r;
}

template
   <typename I,
    typename U,
    typename F>
F memmove_n(I f, U n, F r) noexcept
{
   typedef typename boost::container::iterator_traits<I>::value_type value_type;
   if(n){
      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
      boost::container::iterator_advance(r, n);
   }
   return r;
}

template
   <typename I,
    typename U,
    typename F>
I memmove_n_source(I f, U n, F r) noexcept
{
   if(n){
      typedef typename boost::container::iterator_traits<I>::value_type value_type;
      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
      boost::container::iterator_advance(f, n);
   }
   return f;
}

template
   <typename I,
    typename U,
    typename F>
I memmove_n_source_dest(I f, U n, F &r) noexcept
{
   typedef typename boost::container::iterator_traits<I>::value_type value_type;
   if(n){
      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
      boost::container::iterator_advance(f, n);
      boost::container::iterator_advance(r, 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


      || dtl::is_pod<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::iterator_traits<I>::value_type>::value
               , R>
{};

template <typename I, typename R>
struct disable_if_trivially_destructible
   : enable_if_c <!dtl::is_trivially_destructible
                  <typename boost::container::iterator_traits<I>::value_type>::value
               , R>
{};

}
# 272 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 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); }
# 317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
{
   F back = r;
   { try{
      while (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 typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_move_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) noexcept
{ return dtl::memmove_n(f, n, r); }
# 362 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
{
   F back = r;
   { try{
      while (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 typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
   uninitialized_move_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) noexcept
{ return dtl::memmove_n_source(f, n, r); }
# 407 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 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); }
# 452 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
{
   F back = r;
   { try{
      while (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 typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_copy_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) noexcept
{ return dtl::memmove_n(f, n, r); }
# 497 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, typename boost::container::allocator_traits<Allocator>::size_type 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;
      }
   }
   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 typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
   uninitialized_copy_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) noexcept
{ return dtl::memmove_n_source(f, n, r); }
# 542 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
{
   F back = r;
   { try{
      while (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 typename dtl::enable_if_memzero_initializable<F, F>::type
   uninitialized_value_init_alloc_n(Allocator &, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
{
   typedef typename boost::container::iterator_traits<F>::value_type value_type;
   std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
   boost::container::iterator_advance(r, n);
   return r;
}
# 590 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename F>
inline F uninitialized_default_init_alloc_n(Allocator &a, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
{
   F back = r;
   { try{
      while (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;
}
# 625 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;;
   }
   }
}
# 661 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
{
   F back = r;
   { try{
      while (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--) {
      *r = *f;
      ++f; ++r;
   }
   return r;
}

template
<typename I,
typename U,
typename F>
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--) {
      boost::container::assign_in_place(r, f);
      ++f; ++r;
   }
   return f;
}

template
<typename I,
typename U,
typename F>
inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   copy_n_source(I f, U n, F r) noexcept
{ return dtl::memmove_n_source(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_dest(I f, U n, F &r)
{
   while (n--) {
      *r = *f;
      ++f; ++r;
   }
   return f;
}

template
<typename I,
typename U,
typename F>
inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   copy_n_source_dest(I f, U 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--) {
      *r = ::boost::move(*f);
      ++f; ++r;
   }
   return r;
}

template
<typename I,
typename U,
typename F>
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); }
# 855 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
   move_backward(I f, I l, F r) noexcept
{
   typedef typename boost::container::iterator_traits<I>::value_type value_type;
   const typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
   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--) {
      *r = ::boost::move(*f);
      ++f; ++r;
   }
   return f;
}

template
<typename I
,typename U
,typename F>
inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   move_n_source_dest(I f, U 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--) {
      *r = ::boost::move(*f);
      ++f; ++r;
   }
   return f;
}

template
<typename I
,typename U
,typename F>
inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   move_n_source(I f, U n, F r) noexcept
{ return dtl::memmove_n_source(f, n, r); }







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 typename dtl::enable_if_trivially_destructible<I, void>::type
   destroy_alloc_n(Allocator &, I, U)
{}







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, typename allocator_traits<Allocator>::size_type n_i
                    , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
{
   typename allocator_traits<Allocator>::size_type 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, n_j - n_i, short_range_f);
   boost::container::destroy_alloc_n(a, large_range_f, 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, typename allocator_traits<Allocator>::size_type n_i
                    , G large_range_f, typename allocator_traits<Allocator>::size_type 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_advance(large_range_f, n_i);
   boost::container::iterator_advance(short_range_f, n_i);
   boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);
   boost::container::destroy_alloc_n(a, large_range_f, 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, typename allocator_traits<Allocator>::size_type n_i
                    , G large_range_f, typename allocator_traits<Allocator>::size_type 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)*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;
         __attribute__((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;
         __attribute__((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;
         __attribute__((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_advance(large_range_f, n_i);
   boost::container::iterator_advance(short_range_f, n_i);
   boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);
   boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
}
# 1099 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, typename allocator_traits<Allocator>::size_type n_i
                              , O out_start, typename allocator_traits<Allocator>::size_type 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, 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, n_o - n_i);
   }
}







template
   <typename Allocator
   ,typename I
   ,typename O
   >
void move_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i
                              , O out_start, typename allocator_traits<Allocator>::size_type 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, 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, n_o - n_i);
   }
}

}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/destroyers.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/destroyers.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/destroyers.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/version_type.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/version_type.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

    version_type(const version_type<T, 0>&);
};

namespace impl{

template <class T,
          bool = dtl::is_convertible<version_type<T, 0>, typename T::version>::value>
struct extract_version
{
   static const unsigned value = 1;
};

template <class T>
struct extract_version<T, true>
{
   static const unsigned value = T::version::value;
};

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>::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/version_type.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
   typedef typename AllocTraits::size_type size_type;

   null_scoped_deallocator(pointer, Allocator&, size_type)
   {}

   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, size_type length)
      : m_ptr(p), m_alloc(a), m_length(length) {}

   ~scoped_array_deallocator()
   { if (m_ptr) m_alloc.deallocate(m_ptr, m_length); }

   void release()
   { m_ptr = 0; }

   private:
   pointer m_ptr;
   Allocator& m_alloc;
   size_type m_length;
};

template <class Allocator>
struct null_scoped_array_deallocator
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;
   typedef typename AllocTraits::size_type size_type;

   null_scoped_array_deallocator(pointer, Allocator&, size_type)
   {}

   void release()
   {}
};

template <class Allocator>
struct scoped_destroy_deallocator
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;
   typedef typename AllocTraits::size_type size_type;
   typedef dtl::integral_constant<unsigned,
      boost::container::dtl::
         version<Allocator>::value> alloc_version;

   scoped_destroy_deallocator(pointer p, Allocator& a)
      : m_ptr(p), m_alloc(a) {}

   ~scoped_destroy_deallocator()
   {
      if(m_ptr){
         AllocTraits::destroy(m_alloc, boost::movelib::to_raw_pointer(m_ptr));
         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>
struct scoped_destructor_n
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;
   typedef typename AllocTraits::value_type value_type;
   typedef typename AllocTraits::size_type size_type;

   scoped_destructor_n(pointer p, Allocator& a, size_type n)
      : m_p(p), m_a(a), m_n(n)
   {}

   void release()
   { m_p = 0; }

   void increment_size(size_type inc)
   { m_n += inc; }

   void increment_size_backwards(size_type inc)
   { m_n += inc; m_p -= inc; }

   void shrink_forward(size_type inc)
   { m_n -= inc; m_p += inc; }

   ~scoped_destructor_n()
   {
      if(!m_p) return;
      value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
      while(m_n--){
         AllocTraits::destroy(m_a, raw_ptr++);
      }
   }

   private:
   pointer m_p;
   Allocator & m_a;
   size_type m_n;
};



template <class Allocator>
struct null_scoped_destructor_n
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;
   typedef typename AllocTraits::size_type size_type;

   null_scoped_destructor_n(pointer, Allocator&, size_type)
   {}

   void increment_size(size_type)
   {}

   void increment_size_backwards(size_type)
   {}

   void shrink_forward(size_type)
   {}

   void release()
   {}
};

template<class Allocator>
class scoped_destructor
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   public:
   typedef typename Allocator::value_type value_type;
   scoped_destructor(Allocator &a, value_type *pv)
      : pv_(pv), a_(a)
   {}

   ~scoped_destructor()
   {
      if(pv_){
         AllocTraits::destroy(a_, pv_);
      }
   }

   void release()
   { pv_ = 0; }


   void set(value_type *ptr) { pv_ = ptr; }

   value_type *get() const { return pv_; }

   private:
   value_type *pv_;
   Allocator &a_;
};


template<class Allocator, class Value = typename Allocator::value_type>
class value_destructor
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   public:
   typedef Value value_type;
   value_destructor(Allocator &a, value_type &rv)
      : rv_(rv), a_(a)
   {}

   ~value_destructor()
   {
      AllocTraits::destroy(a_, &rv_);
   }

   private:
   value_type &rv_;
   Allocator &a_;
};

template <class Allocator>
class allocator_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:
   void priv_deallocate(const pointer &p, version_1)
   { AllocTraits::deallocate(a_,p, 1); }

   void priv_deallocate(const pointer &p, version_2)
   { a_.deallocate_one(p); }

   public:
   explicit allocator_destroyer(Allocator &a)
      : a_(a)
   {}

   void operator()(const pointer &p)
   {
      AllocTraits::destroy(a_, boost::movelib::to_raw_pointer(p));
      this->priv_deallocate(p, alloc_version());
   }
};

template <class Allocator>
class allocator_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:
   allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
      : a_(a), c_(c)
   {}

   void operator()(const typename Allocator::pointer &p)
   {
      allocator_traits<Allocator>::destroy(a_, boost::movelib::to_raw_pointer(p));
      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_destroyer_and_chain_builder<Allocator> chain_builder;

   Allocator & a_;
   multiallocation_chain c_;

   public:
   allocator_multialloc_chain_node_deallocator(Allocator &a)
      : a_(a), c_()
   {}

   chain_builder get_chain_builder()
   { return chain_builder(a_, c_); }

   ~allocator_multialloc_chain_node_deallocator()
   {
      a_.deallocate_individual(c_);
   }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 377 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/destroyers.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4


namespace boost { namespace container { namespace dtl {

template<class Allocator, class FwdIt, class Iterator>
struct move_insert_range_proxy
{
   typedef typename allocator_traits<Allocator>::size_type size_type;
   typedef typename allocator_traits<Allocator>::value_type value_type;

   explicit move_insert_range_proxy(FwdIt first)
      : first_(first)
   {}

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
   {
      this->first_ = ::boost::container::uninitialized_move_alloc_n_source
         (a, this->first_, n, p);
   }

   void copy_n_and_update(Allocator &, Iterator p, size_type n)
   {
      this->first_ = ::boost::container::move_n_source(this->first_, n, p);
   }

   FwdIt first_;
};


template<class Allocator, class FwdIt, class Iterator>
struct insert_range_proxy
{
   typedef typename allocator_traits<Allocator>::size_type size_type;
   typedef typename allocator_traits<Allocator>::value_type value_type;

   explicit insert_range_proxy(FwdIt first)
      : first_(first)
   {}

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
   {
      this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
   }

   void copy_n_and_update(Allocator &, Iterator p, size_type n)
   {
      this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
   }

   FwdIt first_;
};


template<class Allocator, class Iterator>
struct insert_n_copies_proxy
{
   typedef typename allocator_traits<Allocator>::size_type size_type;
   typedef typename allocator_traits<Allocator>::value_type value_type;

   explicit insert_n_copies_proxy(const value_type &v)
      : v_(v)
   {}

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
   { boost::container::uninitialized_fill_alloc_n(a, v_, n, p); }

   void copy_n_and_update(Allocator &, Iterator p, size_type n) const
   {
      for (; 0 < n; --n, ++p){
         *p = v_;
      }
   }

   const value_type &v_;
};

template<class Allocator, class Iterator>
struct insert_value_initialized_n_proxy
{
   typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename allocator_traits<Allocator>::size_type size_type;
   typedef typename allocator_traits<Allocator>::value_type value_type;

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
   { boost::container::uninitialized_value_init_alloc_n(a, n, p); }

   void copy_n_and_update(Allocator &, Iterator, size_type) const
   { (static_cast<void> (0)); }
};

template<class Allocator, class Iterator>
struct insert_default_initialized_n_proxy
{
   typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename allocator_traits<Allocator>::size_type size_type;
   typedef typename allocator_traits<Allocator>::value_type value_type;

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
   { boost::container::uninitialized_default_init_alloc_n(a, n, p); }

   void copy_n_and_update(Allocator &, Iterator, size_type) const
   { (static_cast<void> (0)); }
};

template<class Allocator, class Iterator>
struct insert_copy_proxy
{
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename alloc_traits::size_type size_type;
   typedef typename alloc_traits::value_type value_type;

   explicit insert_copy_proxy(const value_type &v)
      : v_(v)
   {}

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
   {
      (static_cast<void> (0)); (void)n;
      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
   }

   void copy_n_and_update(Allocator &, Iterator p, size_type n) const
   {
      (static_cast<void> (0)); (void)n;
      *p = v_;
   }

   const value_type &v_;
};


template<class Allocator, class Iterator>
struct insert_move_proxy
{
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename alloc_traits::size_type size_type;
   typedef typename alloc_traits::value_type value_type;

   explicit insert_move_proxy(value_type &v)
      : v_(v)
   {}

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
   {
      (static_cast<void> (0)); (void)n;
      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
   }

   void copy_n_and_update(Allocator &, Iterator p, size_type n) const
   {
      (static_cast<void> (0)); (void)n;
      *p = ::boost::move(v_);
   }

   value_type &v_;
};

template<class It, class Allocator>
insert_move_proxy<Allocator, It> get_insert_value_proxy(typename boost::container::iterator_traits<It>::value_type && v)
{
   return insert_move_proxy<Allocator, It>(v);
}

template<class It, class Allocator>
insert_copy_proxy<Allocator, It> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
{
   return insert_copy_proxy<Allocator, It>(v);
}

}}}






namespace boost {
namespace container {
namespace dtl {

template<class Allocator, class Iterator, class ...Args>
struct insert_nonmovable_emplace_proxy
{
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename alloc_traits::size_type size_type;
   typedef typename alloc_traits::value_type value_type;

   typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;

   explicit insert_nonmovable_emplace_proxy(Args &&... args)
      : args_(args...)
   {}

   void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
   { this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n); }

   private:
   template<std::size_t ...IdxPack>
   void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
   {
      (static_cast<void> (0)); (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 Iterator, class ...Args>
struct insert_emplace_proxy
   : public insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...>
{
   typedef insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...> base_t;
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename base_t::value_type value_type;
   typedef typename base_t::size_type size_type;
   typedef typename base_t::index_tuple_t index_tuple_t;

   explicit insert_emplace_proxy(Args &&... args)
      : base_t(::boost::forward<Args>(args)...)
   {}

   void copy_n_and_update(Allocator &a, Iterator p, size_type n)
   { this->priv_copy_some_and_update(a, index_tuple_t(), p, n); }

   private:

   template<std::size_t ...IdxPack>
   void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
   {
      (static_cast<void> (0)); (void)n;
      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
      value_type *vp = static_cast<value_type *>(static_cast<void *>(v.data));
      alloc_traits::construct(a, vp,
         ::boost::forward<Args>(get<IdxPack>(this->args_))...);
      { try{
         *p = ::boost::move(*vp);
      }
      catch(...){
         alloc_traits::destroy(a, vp);
         throw;
      }
      }
      alloc_traits::destroy(a, vp);
   }
};


template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator, typename boost::container::allocator_traits<Allocator>::value_type>
   : public insert_move_proxy<Allocator, Iterator>
{
   explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
   : insert_move_proxy<Allocator, Iterator>(v)
   {}
};




template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator
   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
   >
   : public insert_copy_proxy<Allocator, Iterator>
{
   explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
   : insert_copy_proxy<Allocator, Iterator>(v)
   {}
};

template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator, typename boost::container::allocator_traits<Allocator>::value_type &>
   : public insert_copy_proxy<Allocator, Iterator>
{
   explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
   : insert_copy_proxy<Allocator, Iterator>(v)
   {}
};

template<class Allocator, class Iterator>
struct insert_emplace_proxy<Allocator, Iterator
   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
   >
   : public insert_copy_proxy<Allocator, Iterator>
{
   explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
   : insert_copy_proxy<Allocator, Iterator>(v)
   {}
};

}}}
# 475 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 476 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/algorithm.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/algorithm.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/algorithm.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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()); }

}
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/algorithm.hpp" 2 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 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/alloc_helpers.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/alloc_helpers.hpp" 3 4
         






namespace boost {
namespace container {
namespace dtl {

template<class AllocatorType>
inline void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
   noexcept
{}

template<class AllocatorType>
inline void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
{ boost::adl_move_swap(l, r); }

template<class AllocatorType>
inline void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
   noexcept
{}

template<class AllocatorType>
inline void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
{ l = r; }

template<class AllocatorType>
inline void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
   noexcept
{}

template<class AllocatorType>
inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
{ l = ::boost::move(r); }

}
}
}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/allocation_type.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/allocation_type.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/allocation_type.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/next_capacity.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/next_capacity.hpp" 3 4
         





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/min_max.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; }

}
}
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 = cur_cap * Numerator / Denominator;
      }
      else if(Denominator == 1 || (SizeType(new_cap = cur_cap) / Denominator) > overflow_limit){
         new_cap = (SizeType)-1;
      }
      else{
         new_cap *= Numerator;
      }
      return max_value(SizeType(Minimum), max_value(cur_cap+add_min_cap, min_value(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>
{};

}
}
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/value_functors.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/value_functors.hpp" 3 4
         



template<class ValueType>
struct value_less
{
   bool operator()(const ValueType &a, const ValueType &b) const
      { return a < b; }
};

template<class ValueType>
struct value_equal
{
   bool operator()(const ValueType &a, const ValueType &b) const
      { return a == b; }
};
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/traits.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/traits.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/traits.hpp" 2 3 4







namespace boost {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/traits.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/move_helpers.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/move_helpers.hpp" 3 4
         
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_merge.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_merge.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 1 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/reverse_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/reverse_iterator.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/reverse_iterator.hpp" 2 3 4



namespace boost {
namespace movelib {

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;

   reverse_iterator()
      : m_current()
   {}

   explicit reverse_iterator(It r)
      : m_current(r)
   {}

   reverse_iterator(const reverse_iterator& r)
      : m_current(r.base())
   {}

   template<class OtherIt>
   reverse_iterator( const reverse_iterator<OtherIt>& r
                   , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
                   )
      : m_current(r.base())
   {}

   reverse_iterator & operator=( const reverse_iterator& r)
   { m_current = r.base(); return *this; }

   template<class OtherIt>
   typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
         operator=( const reverse_iterator<OtherIt>& r)
   { m_current = r.base(); return *this; }

   It base() const
   { return m_current; }

   reference operator*() const
   {
      It temp(m_current);
      --temp;
      reference r = *temp;
      return r;
   }

   pointer operator->() const
   {
      It temp(m_current);
      --temp;
      return iterator_arrow_result(temp);
   }

   reference operator[](difference_type off) const
   {
      return this->m_current[-off - 1];
   }

   reverse_iterator& operator++()
   {
      --m_current;
      return *this;
   }

   reverse_iterator operator++(int)
   {
      reverse_iterator temp((*this));
      --m_current;
      return temp;
   }

   reverse_iterator& operator--()
   {
      ++m_current;
      return *this;
   }

   reverse_iterator operator--(int)
   {
      reverse_iterator temp((*this));
      ++m_current;
      return temp;
   }

   friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current == r.m_current; }

   friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current != r.m_current; }

   friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current > r.m_current; }

   friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current >= r.m_current; }

   friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current < r.m_current; }

   friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current <= r.m_current; }

   reverse_iterator& operator+=(difference_type off)
   { m_current -= off; return *this; }

   reverse_iterator& operator-=(difference_type off)
   { m_current += off; return *this; }

   friend reverse_iterator operator+(reverse_iterator l, difference_type off)
   { return (l += off); }

   friend reverse_iterator operator+(difference_type off, reverse_iterator r)
   { return (r += off); }

   friend reverse_iterator operator-(reverse_iterator l, difference_type off)
   { return (l-= off); }

   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 >
reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
{
    return reverse_iterator<Iterator>(i);
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 170 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/reverse_iterator.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/move.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/move.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/move.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/no_exceptions_support.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/move.hpp" 2 3 4

namespace boost {
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
   }
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
   }
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
}
# 152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/move.hpp" 3 4
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 155 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/move.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/basic_op.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
   }
};


}}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/destruct_n.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/predicate.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/predicate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/predicate.hpp" 2 3 4

namespace boost {
namespace movelib {

template<class Comp>
struct antistable
{
   explicit antistable(Comp &comp)
      : m_comp(comp)
   {}

   template<class U, class V>
   bool operator()(const U &u, const V & v)
   { return !m_comp(v, u); }

   private:
   antistable & operator=(const antistable &);
   Comp &m_comp;
};

template <class Comp>
class negate
{
   public:
   negate()
   {}

   explicit negate(Comp comp)
      : m_comp(comp)
   {}

   template <class T1, class T2>
   bool operator()(const T1& l, const T2& r)
   {
      return !m_comp(l, r);
   }

   private:
   Comp m_comp;
};


template <class Comp>
class inverse
{
   public:
   inverse()
   {}

   explicit inverse(Comp comp)
      : m_comp(comp)
   {}

   template <class T1, class T2>
   bool operator()(const T1& l, const T2& r)
   {
      return m_comp(r, l);
   }

   private:
   Comp m_comp;
};

}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge.hpp" 2 3 4

namespace boost {
namespace movelib {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 <<=1, x>>=1, y>>=1;
      }
      while(x && y){
         if(!(x&1))
            x >>=1;
         else if(!(y&1))
            y >>=1;
         else if(x >=y)
            x = (x-y) >> 1;
         else
            y = (y-x) >> 1;
      }
      return z*(x+y);
   }
}

template<typename RandIt>
RandIt rotate_gcd(RandIt first, RandIt middle, RandIt last)
{
   typedef typename iterator_traits<RandIt>::size_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 T, class Compare>
RandIt lower_bound
   (RandIt first, const RandIt last, const T& key, Compare comp)
{
   typedef typename iterator_traits
      <RandIt>::size_type size_type;
   size_type len = size_type(last - first);
   RandIt middle;

   while (len) {
      size_type step = len >> 1;
      middle = first;
      middle += step;

      if (comp(*middle, key)) {
         first = ++middle;
         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 iterator_traits
      <RandIt>::size_type size_type;
   size_type len = size_type(last - first);
   RandIt middle;

   while (len) {
      size_type step = len >> 1;
      middle = first;
      middle += step;

      if (!comp(key, *middle)) {
         first = ++middle;
         len -= step + 1;
      }
      else{
         len = step;
      }
   }
   return first;
}


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>
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 = 32;

template <class RandIt, class Distance, class Compare>
void merge_bufferless_ONlogN_recursive
   (RandIt first, RandIt middle, RandIt last, Distance len1, Distance len2, Compare comp)
{
   typedef typename iterator_traits<RandIt>::size_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;
      Distance len11 = 0;
      Distance 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 Distance len_internal = 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 -= len11;
         len2 -= len22;
      }
      else {
         merge_bufferless_ONlogN_recursive(new_middle, second_cut, last, len1 - len11, 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)
{
   merge_bufferless_ONlogN_recursive
      (first, middle, last, middle - first, 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<void> (0));
   while ( first != last ) {
      if (r_first == r_last) {
         InputOutIterator end = op(forward_t(), first, last, dest_first);
         (static_cast<void> (0));
         (void)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<void> (0));
   while( r_first != r_last ) {
      if(first == last) {
         BidirOutIterator res = op(backward_t(), r_first, r_last, dest_last);
         (static_cast<void> (0));
         (void)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<void> (0));
   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<void> (0));
         (void)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);
}
# 550 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge.hpp" 3 4
}
}
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/insertion_sort.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/insertion_sort.hpp" 3 4
         







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/placement_new.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)
{}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/insertion_sort.hpp" 2 3 4





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();
   }
}

}}
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge_sort.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge_sort.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge_sort.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge_sort.hpp" 3 4
# 1 "/usr/include/c++/10/cassert" 1 3 4
# 41 "/usr/include/c++/10/cassert" 3 4
       
# 42 "/usr/include/c++/10/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 45 "/usr/include/c++/10/cassert" 2 3
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge_sort.hpp" 2 3 4

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 iterator_traits<RandIt>::size_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 iterator_traits<RandIt>::size_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 = count/2;
      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 iterator_traits<RandIt>::size_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(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 iterator_traits<RandIt>::size_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 = count/2;
      size_type const rest = 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));
   }
}

}}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/merge_sort.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/heap_sort.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/heap_sort.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/heap_sort.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/is_sorted.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
}

}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/heap_sort.hpp" 2 3 4


namespace boost { namespace movelib{

template <class RandomAccessIterator, class Compare>
class heap_sort_helper
{
   typedef typename boost::movelib::iterator_traits<RandomAccessIterator>::size_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 = 2 * (hole_index + 1);

      while (second_child < len) {
         if (comp(*(first + second_child), *(first + (second_child - 1))))
            second_child--;
         *(first + hole_index) = boost::move(*(first + second_child));
         hole_index = second_child;
         second_child = 2 * (second_child + 1);
      }
      if (second_child == len) {
         *(first + hole_index) = boost::move(*(first + (second_child - 1)));
         hole_index = second_child - 1;
      }

      {
         size_type parent = (hole_index - 1) / 2;
         while (hole_index > top_index && comp(*(first + parent), value)) {
            *(first + hole_index) = boost::move(*(first + parent));
            hole_index = parent;
            parent = (hole_index - 1) / 2;
         }
         *(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 = 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<void> (0));
   }
};

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);
}

}}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 110 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/heap_sort.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 3 4
       
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 3
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 3
namespace boost {
    using ::intptr_t;
    using ::uintptr_t;
}
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
namespace boost {
namespace movelib {
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iterator_traits<ForwardIt>::size_type
   count_if_with(ForwardIt first, ForwardIt last, Pred pred, const V &v)
{
   typedef typename iterator_traits<ForwardIt>::size_type size_type;
   size_type count = 0;
   while(first != last) {
      count += static_cast<size_type>(0 != pred(*first, v));
      ++first;
   }
   return count;
}

template<class T, class RandRawIt = T*>
class adaptive_xbuf
{
   adaptive_xbuf(const adaptive_xbuf &);
   adaptive_xbuf & operator=(const adaptive_xbuf &);

   public:
   typedef RandRawIt iterator;

   adaptive_xbuf()
      : m_ptr(), m_size(0), m_capacity(0)
   {}

   adaptive_xbuf(RandRawIt raw_memory, std::size_t capacity)
      : m_ptr(raw_memory), m_size(0), m_capacity(capacity)
   {}

   template<class RandIt>
   void move_assign(RandIt first, std::size_t n)
   {
      if(n <= m_size){
         boost::move(first, first+n, m_ptr);
         std::size_t size = m_size;
         while(size-- != n){
            m_ptr[size].~T();
         }
         m_size = n;
      }
      else{
         RandRawIt result = boost::move(first, first+m_size, m_ptr);
         boost::uninitialized_move(first+m_size, first+n, result);
         m_size = n;
      }
   }

   template<class RandIt>
   void push_back(RandIt first, std::size_t n)
   {
      (static_cast<void> (0));
      boost::uninitialized_move(first, first+n, m_ptr+m_size);
      m_size += n;
   }

   template<class RandIt>
   iterator add(RandIt it)
   {
      (static_cast<void> (0));
      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);
      }
   }

   void set_size(std::size_t size)
   {
      m_size = size;
   }

   void shrink_to_fit(std::size_t const size)
   {
      if(m_size > size){
         for(std::size_t szt_i = size; szt_i != m_size; ++szt_i){
            m_ptr[szt_i].~T();
         }
         m_size = size;
      }
   }

   void initialize_until(std::size_t const size, T &t)
   {
      (static_cast<void> (0));
      if(m_size < size){
         ::new((void*)&m_ptr[m_size]) T(::boost::move(t));
         ++m_size;
         for(; m_size != size; ++m_size){
            ::new((void*)&m_ptr[m_size]) T(::boost::move(m_ptr[m_size-1]));
         }
         t = ::boost::move(m_ptr[m_size-1]);
      }
   }

   private:
   template<class RIt>
   static bool is_raw_ptr(RIt)
   {
      return false;
   }

   static bool is_raw_ptr(T*)
   {
      return true;
   }

   public:
   template<class U>
   bool supports_aligned_trailing(std::size_t size, std::size_t trail_count) const
   {
      if(this->is_raw_ptr(this->data()) && m_capacity){
         uintptr_t u_addr_sz = uintptr_t(&*(this->data()+size));
         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>
   U *aligned_trailing() const
   {
      return this->aligned_trailing<U>(this->size());
   }

   template<class U>
   U *aligned_trailing(std::size_t 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;
   }

   ~adaptive_xbuf()
   {
      this->clear();
   }

   std::size_t capacity() const
   { return m_capacity; }

   iterator data() const
   { return m_ptr; }

   iterator end() const
   { return m_ptr+m_size; }

   std::size_t size() const
   { return m_size; }

   bool empty() const
   { return !m_size; }

   void clear()
   {
      this->shrink_to_fit(0u);
   }

   private:
   RandRawIt m_ptr;
   std::size_t m_size;
   std::size_t m_capacity;
};

template<class Iterator, class Op>
class range_xbuf
{
   range_xbuf(const range_xbuf &);
   range_xbuf & operator=(const range_xbuf &);

   public:
   typedef typename iterator_traits<Iterator>::size_type 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, std::size_t n)
   {
      (static_cast<void> (0));
      m_last = Op()(forward_t(), first, first+n, m_first);
   }

   ~range_xbuf()
   {}

   std::size_t capacity() const
   { return m_cap-m_first; }

   Iterator data() const
   { return m_first; }

   Iterator end() const
   { return m_last; }

   std::size_t 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(std::size_t size)
   {
      m_last = m_first;
      m_last += size;
   }

   private:
   Iterator const m_first;
   Iterator m_last;
   Iterator const m_cap;
};


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);
      ::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;
      }
   }
}
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 n_block_a + n_block_b;
}

template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
typename iterator_traits<RandIt>::size_type
   find_next_block
      ( RandItKeys key_first
      , KeyCompare key_comp
      , RandIt const first
      , typename iterator_traits<RandIt>::size_type const l_block
      , typename iterator_traits<RandIt>::size_type const ix_first_block
      , typename iterator_traits<RandIt>::size_type const ix_last_block
      , Compare comp)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;
   typedef typename iterator_traits<RandItKeys>::value_type key_type;
   (static_cast<void> (0));
   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[ix_min_block*l_block];
      const value_type &cur_val = first[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 key_first
   , KeyCompare key_comp
   , RandIt const first
   , typename iterator_traits<RandIt>::size_type const l_block
   , typename iterator_traits<RandIt>::size_type const l_irreg1
   , typename iterator_traits<RandIt>::size_type const n_block_a
   , typename iterator_traits<RandIt>::size_type const n_block_b
   , typename iterator_traits<RandIt>::size_type const l_irreg2
   , Compare comp)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)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 + l_irreg1 + (n_block_a+n_block_b)*l_block;
   RandIt const last_irr2 = first_irr2 + l_irreg2;

   {
      size_type n_block_left = 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(min_check+1, n_block_left);
      for (RandIt f = first+l_irreg1; n_block_left; --n_block_left, ++key_range2, f += l_block, min_check -= min_check != 0, max_check -= max_check != 0) {
         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(max_value(max_check, next_key_idx+2), n_block_left);

         RandIt const first_min = f + 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 += l_irreg_pos_count;

         swap_and_update_key(key_next, key_range2, key_mid, f, f + l_block, first_min);
         ;
         ;
         ;
      }
   }
   ;

   RandIt first1 = first;
   RandIt last1 = first+l_irreg1;
   RandItKeys const key_end (key_first+n_bef_irreg2);
   bool is_range1_A = true;

   for( ; key_first != key_end; ++key_first){
      bool is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_first, *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 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 iterator_traits<RandIt>::size_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, class XBuf>
typename iterator_traits<RandIt>::size_type
   collect_unique
      ( RandIt const first, RandIt const last
      , typename iterator_traits<RandIt>::size_type const max_collected, Compare comp
      , XBuf & xbuf)
{
   typedef typename iterator_traits<RandIt>::size_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 const n)
{
   Unsigned x = n;
   Unsigned y = x/2 + (x&1);
   while (y < x){
      x = y;
      y = (x + n / x)/2;
   }
   return x;
}

template<class Unsigned>
Unsigned ceil_sqrt(Unsigned const n)
{
   Unsigned r = floor_sqrt(n);
   return 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 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 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; }
};
# 742 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iterator_traits<RandIt>::size_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 += AdaptiveSortInsertionSortThreshold;
      }
      insertion_sort(first+m, last, comp);
   }

   size_type h = AdaptiveSortInsertionSortThreshold;
   for(bool do_merge = L > h; do_merge; h*=2){
      do_merge = (L - h) > h;
      size_type p0 = 0;
      if(do_merge){
         size_type const h_2 = 2*h;
         while((L-p0) > h_2){
            merge_bufferless(first+p0, first+p0+h, first+p0+h_2, comp);
            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<void> (0));







   if(!l_block){


      (static_cast<void> (0));



      Unsigned const new_buf = n_keys/2;
      Unsigned const new_keys = 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 iterator_traits<RandIt>::size_type size_type;
   size_type const len = size_type(last - first);
   size_type const half_len = len/2 + (len&1);
   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);(void)xbuf;
}

template<class RandIt, class Compare, class XBuf>
void stable_merge
      ( RandIt first, RandIt const middle, RandIt last
      , Compare comp
      , XBuf &xbuf)
{
   (static_cast<void> (0));
   typedef typename iterator_traits<RandIt>::size_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(len1, len2);
   if(xbuf.capacity() >= l_min){
      buffered_merge(first, middle, last, comp, xbuf);
      xbuf.clear();
   }
   else{
      merge_bufferless(first, middle, last, comp);
   }
}

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<void> (0));
}

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 = 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 = 2*l_prev_merged;
   size_type l_irreg_combined = len%l_combined;
   size_type l_total_combined = len;
   if(l_irreg_combined <= l_prev_merged){
      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 = l_prev_merged%l_block;
   l_irreg2 = (l_combined-l_irreg1)%l_block;
   (static_cast<void> (0));
   size_type const n_reg_block = (l_combined-l_irreg1-l_irreg2)/l_block;
   n_block_a = l_prev_merged/l_block;
   n_block_b = n_reg_block - n_block_a;
   (static_cast<void> (0));


   if (do_initialize_keys) {
      initialize_keys(keys, keys + needed_keys_count(n_block_a, n_block_b), key_comp, xbuf);
   }
}
# 933 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
}
# 976 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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<void> (0));
   }


   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)
      ;
}
# 1148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iterator_traits<RandIt>::size_type const l_block
   , typename iterator_traits<RandIt>::size_type n_block_left
   , typename iterator_traits<RandIt>::size_type min_check
   , typename iterator_traits<RandIt>::size_type max_check
   , Compare comp, bool const is_stable, Op op)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;

   for(; n_block_left; --n_block_left, ++key_first, min_check -= min_check != 0, max_check -= max_check != 0){
      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, next_key_idx+2), n_block_left);
      RandIt const last_reg = first_reg + l_block;
      RandIt first_min = first_reg + next_key_idx*l_block;
      RandIt const last_min = first_min + l_block; (void)last_min;

      ;
      ;
      ;

      OutputIt orig_dest = dest; (void)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;
   }
   return dest;
}
# 1209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iterator_traits<RandIt>::size_type const l_block
   , typename iterator_traits<RandIt>::size_type const l_irreg1
   , typename iterator_traits<RandIt>::size_type const n_block_a
   , typename iterator_traits<RandIt>::size_type const n_block_b
   , typename iterator_traits<RandIt>::size_type const l_irreg2
   , Compare comp, Op op)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)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 = 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 + 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(min_check+1, n_block_left);
   for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
      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, next_key_idx+2), n_block_left);
      RandIt const first_min = first2 + next_key_idx*l_block;
      RandIt const last_min = first_min + l_block; (void)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<void> (0));
         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);
         }
         (void)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;
   }

   ;
   (static_cast<void> (0));




   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);(void)buffer;
   ;
}
# 1364 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iterator_traits<RandIt>::size_type const l_block
   , typename iterator_traits<RandIt>::size_type const l_irreg1
   , typename iterator_traits<RandIt>::size_type const n_block_a
   , typename iterator_traits<RandIt>::size_type const n_block_b
   , typename iterator_traits<RandIt>::size_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());
   }
}
# 1395 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iterator_traits<RandIt>::size_type const l_block
   , typename iterator_traits<RandIt>::size_type const n_block_a
   , typename iterator_traits<RandIt>::size_type const n_block_b
   , typename iterator_traits<RandIt>::size_type const l_irreg2
   , Compare comp
   , bool const xbuf_used)
{
   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 + ((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);
}
# 1428 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iterator_traits<RandIt>::size_type const l_block
   , typename iterator_traits<RandIt>::size_type const l_irreg1
   , typename iterator_traits<RandIt>::size_type const n_block_a
   , typename iterator_traits<RandIt>::size_type const n_block_b
   , typename iterator_traits<RandIt>::size_type const l_irreg2
   , Compare comp
   , Op op
   , RandItBuf const buf_first)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)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 = 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 + 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(min_check+1, n_block_left);
   for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
      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, next_key_idx+2), n_block_left);
      RandIt first_min = first2 + next_key_idx*l_block;
      RandIt const last_min = first_min + l_block; (void)last_min;
      RandIt const last2 = first2 + l_block;

      bool const buffer_empty = buffer == buffer_end; (void)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<void> (0)); (void)res;
         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
         ;
         ;
         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<void> (0));
         if(is_range_1_empty){
            buffer = buffer_end = buf_first;
            first_min = last_min - (last2 - first2);
         }
         else{
            first_min = last_min;
         }
         ;
         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);

         ;
         is_range1_A ^= is_range_1_empty;
         first1 = unmerged;
         ;
      }
      (static_cast<void> (0));
      is_range2_A ? --n_block_a_left : --n_block_b_left;
      last1 += l_block;
      first2 = last2;
   }

   RandIt res = op(forward_t(), buffer, buffer_end, first1); (void)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<void> (0));
   op_merge_with_left_placed(is_range1_A ? first1 : last1, last1, dest, buffer, buffer_end, comp, op);

   ;
}
# 1564 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare, class Op>
typename iterator_traits<RandIt>::size_type
   op_insertion_sort_step_left
      ( RandIt const first
      , typename iterator_traits<RandIt>::size_type const length
      , typename iterator_traits<RandIt>::size_type const step
      , Compare comp, Op op)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   size_type const s = min_value<size_type>(step, AdaptiveSortInsertionSortThreshold);
   size_type m = 0;

   while((length - m) > s){
      insertion_sort_op(first+m, first+m+s, first+m-s, comp, op);
      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 iterator_traits<RandIt>::size_type const elements_in_blocks
      , typename iterator_traits<RandIt>::size_type const l_build_buf
      , Compare comp
      , Op op)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   size_type restk = elements_in_blocks%(2*l_build_buf);
   size_type p = elements_in_blocks - restk;
   (static_cast<void> (0));

   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 -= 2*l_build_buf;
      op_merge_right(first_block+p, first_block+p+l_build_buf, first_block+p+2*l_build_buf, first_block+p+3*l_build_buf, comp, op);
   }
}
# 1619 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare>
typename iterator_traits<RandIt>::size_type
   insertion_sort_step
      ( RandIt const first
      , typename iterator_traits<RandIt>::size_type const length
      , typename iterator_traits<RandIt>::size_type const step
      , Compare comp)
{
   typedef typename iterator_traits<RandIt>::size_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 += s;
   }
   insertion_sort(first+m, first+length, comp);
   return s;
}
# 1648 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare, class Op>
typename iterator_traits<RandIt>::size_type
   op_merge_left_step_multiple
      ( RandIt first_block
      , typename iterator_traits<RandIt>::size_type const elements_in_blocks
      , typename iterator_traits<RandIt>::size_type l_merged
      , typename iterator_traits<RandIt>::size_type const l_build_buf
      , typename iterator_traits<RandIt>::size_type l_left_space
      , Compare comp
      , Op op)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   for(; l_merged < l_build_buf && l_left_space >= l_merged; l_merged*=2){
      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+2*l_merged, comp, op);
         ;
         p0 += 2*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 -= l_merged;
   }
   return l_merged;
}


}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 1689 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_merge.hpp" 2 3 4

namespace boost {
namespace movelib {


namespace detail_adaptive {

template<class RandIt, class Compare, class XBuf>
inline void adaptive_merge_combine_blocks( RandIt first
                                      , typename iterator_traits<RandIt>::size_type len1
                                      , typename iterator_traits<RandIt>::size_type len2
                                      , typename iterator_traits<RandIt>::size_type collected
                                      , typename iterator_traits<RandIt>::size_type n_keys
                                      , typename iterator_traits<RandIt>::size_type l_block
                                      , bool use_internal_buf
                                      , bool xbuf_used
                                      , Compare comp
                                      , XBuf & xbuf
                                      )
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   size_type const len = len1+len2;
   size_type const l_combine = len-collected;
   size_type const l_combine1 = 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<void> (0));
         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<void> (0));
      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 iterator_traits<RandIt>::size_type len1
                                      , typename iterator_traits<RandIt>::size_type len2
                                      , typename iterator_traits<RandIt>::size_type collected
                                      , typename iterator_traits<RandIt>::size_type l_intbuf
                                      , typename iterator_traits<RandIt>::size_type l_block
                                      , bool use_internal_buf
                                      , bool xbuf_used
                                      , Compare comp
                                      , XBuf & xbuf
                                      )
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   (void)l_block;
   size_type n_keys = collected-l_intbuf;
   size_type len = len1+len2;
   if(use_internal_buf){
      if(xbuf_used){
         xbuf.clear();

         if(n_keys){
            unstable_sort(first, first+n_keys, comp, xbuf);
            stable_merge(first, first+n_keys, first+len, comp, xbuf);
            ;
         }
      }
      else{
         xbuf.clear();
         unstable_sort(first, first+collected, comp, xbuf);
         ;
         stable_merge(first, first+collected, first+len, comp, xbuf);
         ;
      }
   }
   else{
      xbuf.clear();
      unstable_sort(first, first+collected, comp, xbuf);
      ;
      stable_merge(first, first+collected, first+len1+len2, comp, xbuf);
      ;
   }
   ;
}

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;

   while(xbuf.capacity() >= l_block*2){
      l_block *= 2;
   }


   size_type n_keys = len1/l_block+len2/l_block;
   while(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block)){
      --n_keys;
   }
   ++n_keys;
   (static_cast<void> (0));

   if(xbuf.template supports_aligned_trailing<size_type>(l_block, n_keys)){
      n_keys = 0u;
   }
   l_intbuf_inout = l_intbuf;
   rl_block = l_block;
   return n_keys;
}
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_merge.hpp" 3 4
template<class RandIt, class Compare, class XBuf>
void adaptive_merge_impl
   ( RandIt first
   , typename iterator_traits<RandIt>::size_type len1
   , typename iterator_traits<RandIt>::size_type len2
   , Compare comp
   , XBuf & xbuf
   )
{
   typedef typename iterator_traits<RandIt>::size_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 = 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 = 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);
   }
}

}
# 303 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
                , std::size_t uninitialized_len = 0)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;

   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type> xbuf(uninitialized, uninitialized_len);
   ::boost::movelib::detail_adaptive::adaptive_merge_impl(first, size_type(middle - first), size_type(last - middle), comp, xbuf);
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 319 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_merge.hpp" 2 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/unique.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/unique.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/unique.hpp" 2 3 4


namespace boost {
namespace movelib {
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/unique.hpp" 2 3 4
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/set_difference.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/set_difference.hpp" 3 4
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;
}
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
}



}
}
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 typename boost::intrusive::pointer_traits<Pointer>::element_type value_type;
   typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type difference_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;

   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(vec_iterator<Pointer, false> const& other) noexcept
      : m_ptr(other.get_ptr())
   {}


   inline __attribute__ ((__always_inline__)) reference operator*() const noexcept
   { return *m_ptr; }

   inline __attribute__ ((__always_inline__)) pointer operator->() const noexcept
   { return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->operator*()); }

   inline __attribute__ ((__always_inline__)) reference operator[](difference_type off) const noexcept
   { return m_ptr[off]; }


   inline __attribute__ ((__always_inline__)) vec_iterator& operator++() noexcept
   { ++m_ptr; return *this; }

   inline __attribute__ ((__always_inline__)) vec_iterator operator++(int) noexcept
   { return vec_iterator(m_ptr++); }

   inline __attribute__ ((__always_inline__)) vec_iterator& operator--() noexcept
   { --m_ptr; return *this; }

   inline __attribute__ ((__always_inline__)) vec_iterator operator--(int) noexcept
   { return vec_iterator(m_ptr--); }


   inline __attribute__ ((__always_inline__)) vec_iterator& operator+=(difference_type off) noexcept
   { m_ptr += off; return *this; }

   inline __attribute__ ((__always_inline__)) vec_iterator& operator-=(difference_type off) noexcept
   { m_ptr -= off; return *this; }

   inline __attribute__ ((__always_inline__)) friend vec_iterator operator+(const vec_iterator &x, difference_type off) noexcept
   { return vec_iterator(x.m_ptr+off); }

   inline __attribute__ ((__always_inline__)) friend vec_iterator operator+(difference_type off, vec_iterator right) noexcept
   { right.m_ptr += off; return right; }

   inline __attribute__ ((__always_inline__)) friend vec_iterator operator-(vec_iterator left, difference_type off) noexcept
   { left.m_ptr -= off; return left; }

   inline __attribute__ ((__always_inline__)) friend difference_type operator-(const vec_iterator &left, const vec_iterator& right) noexcept
   { return left.m_ptr - right.m_ptr; }


   inline __attribute__ ((__always_inline__)) friend bool operator== (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr == r.m_ptr; }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr != r.m_ptr; }

   inline __attribute__ ((__always_inline__)) friend bool operator< (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr < r.m_ptr; }

   inline __attribute__ ((__always_inline__)) friend bool operator<= (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr <= r.m_ptr; }

   inline __attribute__ ((__always_inline__)) friend bool operator> (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr > r.m_ptr; }

   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;
};

struct initial_capacity_t{};

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 vector_uninitialized_size_t {};
static const vector_uninitialized_size_t vector_uninitialized_size = vector_uninitialized_size_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;
   static const bool trivial_copy = dtl::is_trivially_copy_constructible<T>::value;
   static const bool nothrow_copy = dtl::is_nothrow_copy_constructible<T>::value || trivial_copy;
   static const bool trivial_assign = dtl::is_trivially_copy_assignable<T>::value;
   static const bool nothrow_assign = dtl::is_nothrow_copy_assignable<T>::value || trivial_assign;
};


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> 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;

   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::equal(from_alloc, to_alloc));
   }

   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>::value))
      : Allocator(), m_start(), m_size(), m_capacity()
   {}


   template<class AllocConvertible>
   explicit vector_alloc_holder(AllocConvertible && a) noexcept
      : Allocator(boost::forward<AllocConvertible>(a)), m_start(), m_size(), m_capacity()
   {}


   template<class AllocConvertible>
   vector_alloc_holder(vector_uninitialized_size_t, AllocConvertible && a, size_type initial_size)
      : Allocator(boost::forward<AllocConvertible>(a))
      , m_start()

      , m_size(static_cast<stored_size_type>(initial_size))
      , m_capacity()
   {
      if(initial_size){
         pointer reuse = pointer();
         size_type final_cap = initial_size;
         m_start = this->allocation_command(allocate_new, initial_size, final_cap, reuse);
         m_capacity = static_cast<stored_size_type>(final_cap);
      }
   }


   vector_alloc_holder(vector_uninitialized_size_t, size_type initial_size)
      : Allocator()
      , m_start()

      , m_size(static_cast<stored_size_type>(initial_size))
      , m_capacity()
   {
      if(initial_size){
         pointer reuse = pointer();
         size_type final_cap = initial_size;
         m_start = this->allocation_command(allocate_new, initial_size, final_cap, reuse);
         m_capacity = static_cast<stored_size_type>(final_cap);
      }
   }

   vector_alloc_holder(vector_alloc_holder && holder) noexcept
      : Allocator(::boost::move((Allocator&)(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;
   }

   vector_alloc_holder(initial_capacity_t, pointer p, size_type capacity, vector_alloc_holder && holder)
      : Allocator(::boost::move((Allocator&)(holder)))
      , m_start(p)
      , m_size(holder.m_size)
      , m_capacity(static_cast<stored_size_type>(capacity))
   {
      allocator_type &this_alloc = this->alloc();
      allocator_type &x_alloc = holder.alloc();
      if(this->is_propagable_from(x_alloc, holder.start(), this_alloc, true)){
         if(this->m_capacity){
            this->deallocate(this->m_start, this->m_capacity);
         }
         m_start = holder.m_start;
         m_capacity = holder.m_capacity;
         holder.m_start = pointer();
         holder.m_capacity = holder.m_size = 0;
      }
      else if(this->m_capacity < holder.m_size){
         size_type const n = holder.m_size;
         pointer reuse = pointer();
         size_type final_cap = n;
         m_start = this->allocation_command(allocate_new, n, final_cap, reuse);
         m_capacity = static_cast<stored_size_type>(final_cap);



      }
   }

   vector_alloc_holder(initial_capacity_t, pointer p, size_type n)
      noexcept((dtl::is_nothrow_default_constructible<Allocator>::value))
      : Allocator()
      , 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(::boost::forward<AllocFwd>(a))
      , m_start(p)
      , m_size()
      , m_capacity(n)
   {}

   inline __attribute__ ((__always_inline__)) ~vector_alloc_holder() noexcept
   {
      if(this->m_capacity){
         this->deallocate(this->m_start, this->m_capacity);
      }
   }

   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 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 ( max < n )
         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 = 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<void> (0));
      size_type max = allocator_traits_type::max_size(this->alloc());
      (clamp_by_stored_size_type)(max, stored_size_type());
      const size_type remaining_cap = max - size_type(this->m_capacity);
      const size_type min_additional_cap = 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 &alloc() noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) const Allocator &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<void> (0)); m_capacity = c; }

   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;



      }
   }

   inline __attribute__ ((__always_inline__)) static void clamp_by_stored_size_type(size_type &, size_type)
   {}

   template<class SomeStoredSizeType>
   inline __attribute__ ((__always_inline__)) static void clamp_by_stored_size_type(size_type &s, SomeStoredSizeType)
   {
      if (s >= SomeStoredSizeType(-1) )
         s = SomeStoredSizeType(-1);
   }

   inline __attribute__ ((__always_inline__)) 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<void> (0));
      (static_cast<void> (0));

      if (limit_size > stored_size_type(-1)){
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
      }
      (clamp_by_stored_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 (limit_size > stored_size_type(-1)){
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
      }
      (clamp_by_stored_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)(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 boost::container::allocator_traits<Allocator> 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>::value))
      : Allocator(), m_size()
   {}


   template<class AllocConvertible>
   explicit vector_alloc_holder(AllocConvertible && a) noexcept
      : Allocator(boost::forward<AllocConvertible>(a)), m_size()
   {}


   template<class AllocConvertible>
   vector_alloc_holder(vector_uninitialized_size_t, AllocConvertible && a, size_type initial_size)
      : Allocator(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()
      , m_size(initial_size)
   {

      this->priv_first_allocation(initial_size);
   }

   vector_alloc_holder(vector_alloc_holder && holder)
      : Allocator(::boost::move((Allocator&)(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()));
   }

   template<class OtherAllocator, class OtherStoredSizeType, class OtherAllocatorVersion>
   vector_alloc_holder( vector_alloc_holder<OtherAllocator, OtherStoredSizeType, OtherAllocatorVersion> && holder)
      : Allocator()
      , 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()));
   }

   inline __attribute__ ((__always_inline__)) void priv_first_allocation(size_type cap)
   {
      if(cap > Allocator::internal_capacity){
         throw_bad_alloc();
      }
   }

   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)
   {
      if(this->m_size > OtherAllocator::internal_capacity || x.m_size > Allocator::internal_capacity){
         throw_bad_alloc();
      }
      this->priv_deep_swap(x);
   }

   inline __attribute__ ((__always_inline__)) void swap_resources(vector_alloc_holder &) noexcept
   {
      throw_bad_alloc();
   }


   inline __attribute__ ((__always_inline__)) void steal_resources(vector_alloc_holder &)
   {
      throw_bad_alloc();
   }

   inline __attribute__ ((__always_inline__)) Allocator &alloc() noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) const Allocator &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::internal_storage(); }
   inline __attribute__ ((__always_inline__)) size_type capacity() const noexcept { return Allocator::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::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;

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<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;
};
# 719 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
template <class T, class Allocator , class Options >
class vector
{


   typedef typename boost::container::allocator_traits<Allocator>::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 alloc_version;
   typedef boost::container::vector_alloc_holder<Allocator, stored_size_type> alloc_holder_t;
   alloc_holder_t m_holder;
   typedef allocator_traits<Allocator> allocator_traits_type;
   template <class U, class UAllocator, class UOptions>
   friend class vector;

   typedef typename allocator_traits_type::pointer pointer_impl;
   typedef vec_iterator<pointer_impl, false> iterator_impl;
   typedef vec_iterator<pointer_impl, true > const_iterator_impl;

   protected:
   static bool is_propagable_from(const Allocator &from_alloc, pointer_impl p, const Allocator &to_alloc, bool const propagate_allocator)
   { return alloc_holder_t::is_propagable_from(from_alloc, p, to_alloc, propagate_allocator); }

   static bool are_swap_propagable( const Allocator &l_a, pointer_impl l_p
                                  , const Allocator &r_a, pointer_impl r_p, bool const propagate_allocator)
   { return alloc_holder_t::are_swap_propagable(l_a, l_p, r_a, r_p, propagate_allocator); }


   public:






   typedef T value_type;
   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
   typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer;
   typedef typename ::boost::container::allocator_traits<Allocator>::reference reference;
   typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference;
   typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type;
   typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type;
   typedef Allocator allocator_type;
   typedef Allocator stored_allocator_type;
   typedef iterator_impl iterator;
   typedef const_iterator_impl const_iterator;
   typedef boost::container::reverse_iterator<iterator> reverse_iterator;
   typedef boost::container::reverse_iterator<const_iterator> const_reverse_iterator;


   private:
  
   typedef vector_value_traits<Allocator> value_traits;
   typedef constant_iterator<T, difference_type> cvalue_iterator;

   protected:

   inline __attribute__ ((__always_inline__)) void steal_resources(vector &x)
   { return this->m_holder.steal_resources(x.m_holder); }

   template<class AllocFwd>
   inline __attribute__ ((__always_inline__)) vector(initial_capacity_t, pointer initial_memory, size_type capacity, AllocFwd && a)
      : m_holder(initial_capacity_t(), initial_memory, capacity, ::boost::forward<AllocFwd>(a))
   {}

   inline __attribute__ ((__always_inline__)) vector(initial_capacity_t, pointer initial_memory, size_type capacity)
      : m_holder(initial_capacity_t(), initial_memory, capacity)
   {}



   public:
# 809 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   vector() noexcept((dtl::is_nothrow_default_constructible<Allocator>::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());
   }
# 845 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
   }
# 864 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
   }
# 883 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
   }
# 900 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
   }
# 917 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
   }
# 934 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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); }
# 950 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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); }
# 967 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)"); }
# 996 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   vector(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
      : m_holder(a)
   {
      this->assign(il.begin(), il.end());
   }
# 1012 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   template<class OtherAllocator>
   vector( vector<T, OtherAllocator> && x
         , typename dtl::enable_if_c
            < dtl::is_version<OtherAllocator, 0>::value>::type * = 0
         )
      : m_holder(boost::move(x.m_holder))
   {}
# 1030 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
   }
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, true) ? 0 : x.size()
                 )
   {
      if(is_propagable_from(x.get_stored_allocator(), x.m_holder.start(), a, true)){
         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);

   }
# 1088 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) vector& operator=(const vector & x)
   {
      if (&x != this){
         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;
   }
# 1118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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))

   {
      (static_cast<void> (0));
      this->priv_move_assign(boost::move(x));
      return *this;
   }
# 1139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   template<class OtherAllocator>
   inline __attribute__ ((__always_inline__)) typename dtl::enable_if_and
                           < vector&
                           , dtl::is_version<OtherAllocator, 0>
                           , dtl::is_different<OtherAllocator, allocator_type>
                           >::type
      operator=( vector<value_type, OtherAllocator> && x)
   {
      this->priv_move_assign(boost::move(x));
      return *this;
   }
# 1161 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   template<class OtherAllocator>
   inline __attribute__ ((__always_inline__)) typename dtl::enable_if_and
                           < vector&
                           , dtl::is_version<OtherAllocator, 0>
                           , dtl::is_different<OtherAllocator, allocator_type>
                           >::type
      operator=(const vector<value_type, OtherAllocator> &x)
   {
      this->priv_copy_assign(x);
      return *this;
   }
# 1181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
   }
# 1230 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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





      )
   {


      const size_type input_sz = static_cast<size_type>(boost::container::iterator_distance(first, last));
      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);

         }
      }

      iterator cur = this->begin();
      const iterator end_it = this->end();
      for ( ; first != last && cur != end_it; ++cur, ++first){
         *cur = *first;
      }

      if (first == last){

         this->priv_destroy_last_n(this->size() - input_sz);
      }
      else{

         this->priv_uninitialized_construct_at_end(first, last);
      }
   }







   inline __attribute__ ((__always_inline__)) void assign(size_type n, const value_type& val)
   { this->assign(cvalue_iterator(val, n), cvalue_iterator()); }






   allocator_type get_allocator() const noexcept
   { return this->m_holder.alloc(); }
# 1312 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) stored_allocator_type &get_stored_allocator() noexcept
   { return this->m_holder.alloc(); }
# 1322 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) const stored_allocator_type &get_stored_allocator() const noexcept
   { return this->m_holder.alloc(); }
# 1336 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator begin() noexcept
   { return iterator(this->m_holder.start()); }






   inline __attribute__ ((__always_inline__)) const_iterator begin() const noexcept
   { return const_iterator(this->m_holder.start()); }






   inline __attribute__ ((__always_inline__)) iterator end() noexcept
   { return iterator(this->m_holder.start() + this->m_holder.m_size); }






   inline __attribute__ ((__always_inline__)) const_iterator end() const noexcept
   { return this->cend(); }







   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__)) reverse_iterator rend() noexcept
   { return reverse_iterator(this->begin()); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator rend() const noexcept
   { return this->crend(); }






   inline __attribute__ ((__always_inline__)) const_iterator cbegin() const noexcept
   { return const_iterator(this->m_holder.start()); }






   inline __attribute__ ((__always_inline__)) const_iterator cend() const noexcept
   { return const_iterator(this->m_holder.start() + this->m_holder.m_size); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator crbegin() const noexcept
   { return const_reverse_iterator(this->end());}







   inline __attribute__ ((__always_inline__)) const_reverse_iterator crend() const noexcept
   { return const_reverse_iterator(this->begin()); }
# 1444 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) bool empty() const noexcept
   { return !this->m_holder.m_size; }






   inline __attribute__ ((__always_inline__)) size_type size() const noexcept
   { return this->m_holder.m_size; }






   inline __attribute__ ((__always_inline__)) size_type max_size() const noexcept
   { return allocator_traits_type::max_size(this->m_holder.alloc()); }







   void resize(size_type new_size)
   { this->priv_resize(new_size, value_init); }
# 1480 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   void resize(size_type new_size, default_init_t)
   { this->priv_resize(new_size, default_init); }







   void resize(size_type new_size, const T& x)
   { this->priv_resize(new_size, x); }







   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_reserve_no_capacity(new_cap, alloc_version());
      }
   }







   inline __attribute__ ((__always_inline__)) void shrink_to_fit()
   { this->priv_shrink_to_fit(alloc_version()); }
# 1537 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   reference front() noexcept
   {
      (static_cast<void> (0));
      return *this->m_holder.start();
   }
# 1551 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   const_reference front() const noexcept
   {
      (static_cast<void> (0));
      return *this->m_holder.start();
   }
# 1565 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   reference back() noexcept
   {
      (static_cast<void> (0));
      return this->m_holder.start()[this->m_holder.m_size - 1];
   }
# 1579 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   const_reference back() const noexcept
   {
      (static_cast<void> (0));
      return this->m_holder.start()[this->m_holder.m_size - 1];
   }
# 1593 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   reference operator[](size_type n) noexcept
   {
      (static_cast<void> (0));
      return this->m_holder.start()[n];
   }
# 1607 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   const_reference operator[](size_type n) const noexcept
   {
      (static_cast<void> (0));
      return this->m_holder.start()[n];
   }
# 1624 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   iterator nth(size_type n) noexcept
   {
      (static_cast<void> (0));
      return iterator(this->m_holder.start()+n);
   }
# 1641 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   const_iterator nth(size_type n) const noexcept
   {
      (static_cast<void> (0));
      return const_iterator(this->m_holder.start()+n);
   }
# 1657 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   size_type index_of(iterator p) noexcept
   {

      return this->priv_index_of(vector_iterator_get_ptr(p));
   }
# 1673 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   size_type index_of(const_iterator p) const noexcept
   {

      return this->priv_index_of(vector_iterator_get_ptr(p));
   }
# 1687 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   reference at(size_type n)
   {
      this->priv_throw_if_out_of_range(n);
      return this->m_holder.start()[n];
   }
# 1701 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   const_reference at(size_type n) const
   {
      this->priv_throw_if_out_of_range(n);
      return this->m_holder.start()[n];
   }
# 1719 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   T* data() noexcept
   { return this->priv_raw_begin(); }







   const T * data() const noexcept
   { return this->priv_raw_begin(); }
# 1747 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   template<class ...Args>
   inline __attribute__ ((__always_inline__)) reference emplace_back(Args &&...args)
   {
      if (__builtin_expect(this->room_enough(), 1)){

         T* const p = this->priv_raw_end();
         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, T*, Args...> type;
         return *this->priv_forward_range_insert_no_capacity
            (this->back_ptr(), 1, type(::boost::forward<Args>(args)...), alloc_version());
      }
   }
# 1772 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
   }
# 1794 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   template<class ...Args>
   iterator emplace(const_iterator position, Args && ...args)
   {
      (static_cast<void> (0));

      typedef dtl::insert_emplace_proxy<Allocator, T*, Args...> type;
      return this->priv_forward_range_insert( vector_iterator_get_ptr(position), 1
                                            , type(::boost::forward<Args>(args)...));
   }
# 1867 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)); }
# 1891 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)); }
# 1903 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   iterator insert(const_iterator p, size_type n, const T& x)
   {
      (static_cast<void> (0));
      dtl::insert_n_copies_proxy<Allocator, T*> proxy(x);
      return this->priv_forward_range_insert(vector_iterator_get_ptr(p), n, proxy);
   }
# 1920 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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<void> (0));
      const size_type n_pos = 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() + n_pos);
   }


   template <class FwdIt>
   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
      )
   {
      (static_cast<void> (0));
      dtl::insert_range_proxy<Allocator, FwdIt, T*> proxy(first);
      return this->priv_forward_range_insert(vector_iterator_get_ptr(pos), boost::container::iterator_distance(first, last), proxy);
   }
# 1973 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   template <class InIt>
   iterator insert(const_iterator pos, size_type num, InIt first, InIt last)
   {
      (static_cast<void> (0));
      (static_cast<void> (0))
                                                                                                   ;
      (void)last;
      dtl::insert_range_proxy<Allocator, InIt, T*> proxy(first);
      return this->priv_forward_range_insert(vector_iterator_get_ptr(pos), num, proxy);
   }
# 1993 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   iterator insert(const_iterator position, std::initializer_list<value_type> il)
   {

      return this->insert(position, il.begin(), il.end());
   }







   void pop_back() noexcept
   {
      (static_cast<void> (0));

      this->priv_destroy_last();
   }







   iterator erase(const_iterator position)
   {
      (static_cast<void> (0));
      const pointer p = vector_iterator_get_ptr(position);
      T *const pos_ptr = boost::movelib::to_raw_pointer(p);
      T *const beg_ptr = this->priv_raw_begin();
      T *const new_end_ptr = ::boost::container::move(pos_ptr + 1, beg_ptr + this->m_holder.m_size, pos_ptr);

      this->priv_destroy_last(pos_ptr != new_end_ptr);
      return iterator(p);
   }







   iterator erase(const_iterator first, const_iterator last)
   {
      (static_cast<void> (0))
                                                                                          ;
      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 ptr = boost::movelib::to_raw_pointer(boost::container::move(last_ptr, old_end_ptr, first_ptr));
         this->priv_destroy_last_n(old_end_ptr - ptr);
      }
      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, 0>::value)))


   {
      this->priv_swap(x, dtl::bool_<dtl::is_version<Allocator, 0>::value>());
   }
# 2072 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   template<class OtherAllocator>
   inline __attribute__ ((__always_inline__)) void swap(vector<T, OtherAllocator> & x
            , typename dtl::enable_if_and
                     < void
                     , dtl::is_version<OtherAllocator, 0>
                     , dtl::is_different<OtherAllocator, allocator_type>
                     >::type * = 0
            )
   { this->m_holder.deep_swap(x.m_holder); }
# 2089 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void clear() noexcept
   { this->priv_destroy_all(); }




   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()); }




   inline __attribute__ ((__always_inline__)) friend bool operator!=(const vector& x, const vector& y)
   { return !(x == y); }




   friend bool operator<(const vector& x, const vector& y)
   {
      const_iterator first1(x.cbegin()), first2(y.cbegin());
      const const_iterator last1(x.cend()), last2(y.cend());
      for ( ; (first1 != last1) && (first2 != last2); ++first1, ++first2 ) {
         if (*first1 < *first2) return true;
         if (*first2 < *first1) return false;
      }
      return (first1 == last1) && (first2 != last2);
   }




   inline __attribute__ ((__always_inline__)) friend bool operator>(const vector& x, const vector& y)
   { return y < x; }




   inline __attribute__ ((__always_inline__)) friend bool operator<=(const vector& x, const vector& y)
   { return !(y < x); }




   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)
   { x.swap(y); }
# 2152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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(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 = static_cast<size_type>(boost::container::iterator_distance(first, last)))){
         this->priv_merge_in_new_buffer(first, n, comp, alloc_version());
      }
      else{
         iterator pos(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 s = 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 + s;
      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<void> (0));



         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.m_size += element_count;
            }
         }
         else{
            if(old_hole_size){

               past_hole_values_destroyer.release();
               this->m_holder.m_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 = first2 + (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)
   {
      throw_bad_alloc();
   }

   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<void> (0));
      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);
      this->m_holder.deallocate(old_p, old_cap);
      this->m_holder.m_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() + this->m_holder.m_size; }

   size_type priv_index_of(pointer p) const
   {
      (static_cast<void> (0));
      (static_cast<void> (0));
      return static_cast<size_type>(p - this->m_holder.start());
   }

   template<class OtherAllocator>
   void priv_move_assign( vector<T, OtherAllocator> && x
      , typename dtl::enable_if_c
         < dtl::is_version<OtherAllocator, 0>::value >::type * = 0)
   {
      if(!dtl::is_same<OtherAllocator, allocator_type>::value &&
          this->capacity() < x.size()){
         throw_bad_alloc();
      }
      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);
      this->m_holder.m_size = other_sz;
   }

   template<class OtherAllocator>
   void priv_move_assign( vector<T, OtherAllocator> && x
      , typename dtl::disable_if_or
         < void
         , dtl::is_version<OtherAllocator, 0>
         , dtl::is_different<OtherAllocator, allocator_type>
         >::type * = 0)
   {

      (static_cast<void> (0));
      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);
      const bool is_propagable_from_t = is_propagable_from(this_alloc, m_holder.start(), x_alloc, propagate_alloc);
      const bool are_both_propagable = is_propagable_from_x && is_propagable_from_t;



      if(are_both_propagable){

         this->clear();
         this->m_holder.swap_resources(x.m_holder);
      }
      else if(is_propagable_from_x){
         this->clear();
         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() ))
                     );
      }

      dtl::move_alloc(this_alloc, x_alloc, dtl::bool_<propagate_alloc>());
   }

   template<class OtherAllocator>
   void priv_copy_assign(const vector<T, OtherAllocator> &x
      , typename dtl::enable_if_c
         < dtl::is_version<OtherAllocator, 0>::value >::type * = 0)
   {
      if(!dtl::is_same<OtherAllocator, allocator_type>::value &&
         this->capacity() < x.size()){
         throw_bad_alloc();
      }
      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);
      this->m_holder.m_size = other_sz;
   }

   template<class OtherAllocator>
   typename dtl::disable_if_or
      < void
      , dtl::is_version<OtherAllocator, 0>
      , dtl::is_different<OtherAllocator, allocator_type>
      >::type
      priv_copy_assign(const vector<T, OtherAllocator> &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>
   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(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;

         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>());
   }

   void priv_reserve_no_capacity(size_type, version_0)
   { throw_bad_alloc(); }

   dtl::insert_range_proxy<Allocator, boost::move_iterator<T*>, T*> priv_dummy_empty_proxy()
   {
      return dtl::insert_range_proxy<Allocator, boost::move_iterator<T*>, T*>
         (::boost::make_move_iterator((T *)0));
   }

   void priv_reserve_no_capacity(size_type new_cap, version_1)
   {


      pointer const p = this->m_holder.allocate(new_cap);

      this->priv_forward_range_insert_new_allocation
         ( boost::movelib::to_raw_pointer(p), new_cap, this->priv_raw_end(), 0, this->priv_dummy_empty_proxy());
   }

   void priv_reserve_no_capacity(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_forward_range_insert_expand_backwards
               ( new_mem , real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
         }
         else{



            this->priv_forward_range_insert_new_allocation
               ( new_mem, real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
         }
      }
   }

   void priv_destroy_last(const bool moved = false) noexcept
   {
      (void)moved;
      const bool skip_destructor = value_traits::trivial_dctr || (value_traits::trivial_dctr_after_move && moved);
      if(!skip_destructor){
         value_type* const p = this->priv_raw_end() - 1;
         allocator_traits_type::destroy(this->get_stored_allocator(), p);
      }
      --this->m_holder.m_size;
   }

   void priv_destroy_last_n(const size_type n) noexcept
   {
      (static_cast<void> (0));
      if(!value_traits::trivial_dctr){
         T* const destroy_pos = this->priv_raw_begin() + (this->m_holder.m_size-n);
         boost::container::destroy_alloc_n(this->get_stored_allocator(), destroy_pos, n);
      }
      this->m_holder.m_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.m_size += 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>
   iterator priv_insert(const const_iterator &p, U && x)
   {
      (static_cast<void> (0));
      return this->priv_forward_range_insert
         ( vector_iterator_get_ptr(p), 1, dtl::get_insert_value_proxy<T*, Allocator>(::boost::forward<U>(x)));
   }

   dtl::insert_copy_proxy<Allocator, T*> priv_single_insert_proxy(const T &x)
   { return dtl::insert_copy_proxy<Allocator, T*> (x); }

   dtl::insert_move_proxy<Allocator, T*> priv_single_insert_proxy(T && x)
   { return dtl::insert_move_proxy<Allocator, T*> (x); }

   template <class U>
   void priv_push_back(U && u)
   {
      if (__builtin_expect(this->room_enough(), 1)){

         allocator_traits_type::construct
            ( this->m_holder.alloc(), this->priv_raw_end(), ::boost::forward<U>(u) );
         ++this->m_holder.m_size;
      }
      else{
         this->priv_forward_range_insert_no_capacity
            ( this->back_ptr(), 1
            , this->priv_single_insert_proxy(::boost::forward<U>(u)), alloc_version());
      }
   }

   inline __attribute__ ((__always_inline__)) dtl::insert_n_copies_proxy<Allocator, T*> priv_resize_proxy(const T &x)
   { return dtl::insert_n_copies_proxy<Allocator, T*>(x); }

   inline __attribute__ ((__always_inline__)) dtl::insert_default_initialized_n_proxy<Allocator, T*> priv_resize_proxy(default_init_t)
   { return dtl::insert_default_initialized_n_proxy<Allocator, T*>(); }

   inline __attribute__ ((__always_inline__)) dtl::insert_value_initialized_n_proxy<Allocator, T*> priv_resize_proxy(value_init_t)
   { return dtl::insert_value_initialized_n_proxy<Allocator, T*>(); }

   template <class U>
   void priv_resize(size_type new_size, const U& u)
   {
      const size_type sz = this->size();
      if (new_size < sz){

         this->priv_destroy_last_n(sz - new_size);
      }
      else{
         const size_type n = new_size - this->size();
         this->priv_forward_range_insert_at_end(n, this->priv_resize_proxy(u), alloc_version());
      }
   }

   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){
            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){


            pointer const p = this->m_holder.allocate(sz);





            this->priv_forward_range_insert_new_allocation
               ( boost::movelib::to_raw_pointer(p), sz
               , this->priv_raw_begin(), 0, this->priv_dummy_empty_proxy());
         }
      }
   }

   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){
            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>
   iterator priv_forward_range_insert_no_capacity
      (const pointer &pos, const size_type, const InsertionProxy , version_0)
   {
      throw_bad_alloc();
      return iterator(pos);
   }

   template <class InsertionProxy>
   iterator priv_forward_range_insert_no_capacity
      (const pointer &pos, const size_type n, const InsertionProxy insert_range_proxy, version_1)
   {

      const size_type n_pos = pos - this->m_holder.start();
      T *const raw_pos = boost::movelib::to_raw_pointer(pos);

      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_forward_range_insert_new_allocation
         ( new_buf, new_cap, raw_pos, n, insert_range_proxy);
      return iterator(this->m_holder.start() + n_pos);
   }

   template <class InsertionProxy>
   iterator priv_forward_range_insert_no_capacity
      (const pointer &pos, const size_type n, const InsertionProxy insert_range_proxy, version_2)
   {

      T *const raw_pos = boost::movelib::to_raw_pointer(pos);
      const size_type n_pos = 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, 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_forward_range_insert_expand_forward(raw_pos, n, insert_range_proxy);
         }

         else{



            this->priv_forward_range_insert_expand_backwards
               (boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
         }
      }

      else{



         this->priv_forward_range_insert_new_allocation
            ( boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
      }

      return iterator(this->m_holder.start() + n_pos);
   }

   template <class InsertionProxy>
   iterator priv_forward_range_insert
      (const pointer &pos, const size_type n, const InsertionProxy insert_range_proxy)
   {
      (static_cast<void> (0));

      const size_type remaining = this->m_holder.capacity() - this->m_holder.m_size;

      bool same_buffer_start = n <= remaining;
      if (!same_buffer_start){
         return priv_forward_range_insert_no_capacity(pos, n, insert_range_proxy, alloc_version());
      }
      else{

         T *const raw_pos = boost::movelib::to_raw_pointer(pos);
         const size_type n_pos = raw_pos - this->priv_raw_begin();
         this->priv_forward_range_insert_expand_forward(raw_pos, n, insert_range_proxy);
         return iterator(this->m_holder.start() + n_pos);
      }
   }

   template <class InsertionProxy>
   iterator priv_forward_range_insert_at_end
      (const size_type n, const InsertionProxy insert_range_proxy, version_0)
   {

      const size_type remaining = this->m_holder.capacity() - this->m_holder.m_size;

      if (n > remaining){

         throw_bad_alloc();
      }
      this->priv_forward_range_insert_at_end_expand_forward(n, insert_range_proxy);
      return this->end();
   }

   template <class InsertionProxy, class AllocVersion>
   inline __attribute__ ((__always_inline__)) iterator priv_forward_range_insert_at_end
      (const size_type n, const InsertionProxy insert_range_proxy, AllocVersion)
   {
      return this->priv_forward_range_insert(this->back_ptr(), n, insert_range_proxy);
   }
# 2867 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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<void> (0));
      (static_cast<void> (0));

      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 = 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>
   void priv_forward_range_insert_at_end_expand_forward(const size_type n, InsertionProxy insert_range_proxy)
   {
      T* const old_finish = this->priv_raw_end();
      insert_range_proxy.uninitialized_copy_n_and_update(this->m_holder.alloc(), old_finish, n);
      this->m_holder.m_size += n;
   }

   template <class InsertionProxy>
   void priv_forward_range_insert_expand_forward(T* const pos, const size_type n, InsertionProxy insert_range_proxy)
   {

      if(__builtin_expect(!n, 0)) return;

      T* const old_finish = this->priv_raw_end();
      const size_type elems_after = old_finish - pos;

      if (!elems_after){
         insert_range_proxy.uninitialized_copy_n_and_update(this->m_holder.alloc(), old_finish, n);
         this->m_holder.m_size += n;
      }
      else if (elems_after >= n){


         ::boost::container::uninitialized_move_alloc
            (this->m_holder.alloc(), old_finish - n, old_finish, old_finish);
         this->m_holder.m_size += n;

         boost::container::move_backward(pos, old_finish - n, old_finish);

         insert_range_proxy.copy_n_and_update(this->m_holder.alloc(), pos, n);
      }
      else {



         ::boost::container::uninitialized_move_alloc(this->m_holder.alloc(), pos, old_finish, pos + n);
         { try{

            insert_range_proxy.copy_n_and_update(this->m_holder.alloc(), pos, elems_after);

            insert_range_proxy.uninitialized_copy_n_and_update(this->m_holder.alloc(), old_finish, n - elems_after);
            this->m_holder.m_size += n;
         }
         catch(...){
            boost::container::destroy_alloc_n(this->get_stored_allocator(), pos + n, elems_after);
            throw;
         }
         }
      }
   }

   template <class InsertionProxy>
   void priv_forward_range_insert_new_allocation
      (T* const new_start, size_type new_cap, T* const pos, const size_type n, InsertionProxy insert_range_proxy)
   {

      T *new_finish = new_start;
      T *old_finish;

      typename value_traits::ArrayDeallocator new_buffer_deallocator(new_start, this->m_holder.alloc(), new_cap);
      typename value_traits::ArrayDestructor new_values_destroyer(new_start, this->m_holder.alloc(), 0u);



      T * const old_buffer = this->priv_raw_begin();
      if(old_buffer){
         new_finish = ::boost::container::uninitialized_move_alloc
            (this->m_holder.alloc(), this->priv_raw_begin(), pos, old_finish = new_finish);
         new_values_destroyer.increment_size(new_finish - old_finish);
      }

      old_finish = new_finish;
      insert_range_proxy.uninitialized_copy_n_and_update(this->m_holder.alloc(), old_finish, n);
      new_finish += n;
      new_values_destroyer.increment_size(new_finish - old_finish);


      if(old_buffer){
         new_finish = ::boost::container::uninitialized_move_alloc
            (this->m_holder.alloc(), pos, old_buffer + this->m_holder.m_size, new_finish);


         if(!value_traits::trivial_dctr_after_move)
            boost::container::destroy_alloc_n(this->get_stored_allocator(), 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.m_size = size_type(new_finish - new_start);
      this->m_holder.capacity(new_cap);

      new_values_destroyer.release();
      new_buffer_deallocator.release();
   }

   template <class InsertionProxy>
   void priv_forward_range_insert_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;
      T* const old_finish = old_start + old_size;


      const size_type elemsbefore = static_cast<size_type>(pos - old_start);
      const size_type s_before = static_cast<size_type>(old_start - new_start);
      const size_type before_plus_new = elemsbefore + n;


      this->m_holder.start(new_start);
      this->m_holder.capacity(new_capacity);
      this->m_holder.m_size = 0;



      typename value_traits::ArrayDestructor old_values_destroyer(old_start, this->m_holder.alloc(), old_size);

      if(s_before >= before_plus_new){

         T *const new_elem_pos =
            ::boost::container::uninitialized_move_alloc(this->m_holder.alloc(), old_start, pos, new_start);
         this->m_holder.m_size = elemsbefore;
         insert_range_proxy.uninitialized_copy_n_and_update(this->m_holder.alloc(), new_elem_pos, n);
         this->m_holder.m_size = before_plus_new;
         const size_type new_size = old_size + n;


         if(s_before >= new_size){
# 3051 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
            if(before_plus_new != new_size){
               ::boost::container::uninitialized_move_alloc
                  (this->m_holder.alloc(), pos, old_finish, new_start + before_plus_new);

               this->m_holder.m_size = new_size;
            }



            if(value_traits::trivial_dctr_after_move)
               old_values_destroyer.release();
         }

         else{
# 3077 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
            const size_type raw_gap = s_before - before_plus_new;
            if(!value_traits::trivial_dctr){


               ::boost::container::uninitialized_move_alloc_n
                  (this->m_holder.alloc(), pos, raw_gap, new_start + before_plus_new);


               old_values_destroyer.shrink_forward(new_size-s_before);
               this->m_holder.m_size = new_size;

               T * const remaining_pos = pos + raw_gap;
               if(remaining_pos != old_start){
                  ::boost::container::move(remaining_pos, old_finish, old_start);
               }

               if(value_traits::trivial_dctr_after_move){
                  old_values_destroyer.release();
               }
            }
            else{
               ::boost::container::uninitialized_move_alloc_n
                  (this->m_holder.alloc(), pos, static_cast<size_type>(old_finish - pos), new_start + before_plus_new);
               this->m_holder.m_size = new_size;
               old_values_destroyer.release();
            }
         }
      }
      else{
# 3125 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
         const bool do_after = n > s_before;



         if (s_before <= elemsbefore) {
# 3154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
            ::boost::container::uninitialized_move_alloc_n
               (this->m_holder.alloc(), old_start, s_before, new_start);



            size_type new_1st_range;
            if(do_after){
               new_1st_range = s_before;

               old_values_destroyer.release();
            }
            else{
               new_1st_range = n;
               if(value_traits::trivial_dctr_after_move)
                  old_values_destroyer.release();
               else{
                  old_values_destroyer.shrink_forward(old_size - (s_before - n));
               }
            }
            this->m_holder.m_size = old_size + new_1st_range;

            T *const next = ::boost::container::move(old_start + s_before, pos, old_start);

            insert_range_proxy.copy_n_and_update(this->m_holder.alloc(), next, new_1st_range);


            if(!do_after && (n != s_before)){

               ::boost::container::move(pos, old_finish, next + new_1st_range);
            }
         }
         else {
# 3212 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
            T * const new_pos = ::boost::container::uninitialized_move_alloc
               (this->m_holder.alloc(), old_start, pos, new_start);
            this->m_holder.m_size = elemsbefore;
            const size_type mid_n = s_before - elemsbefore;
            insert_range_proxy.uninitialized_copy_n_and_update(this->m_holder.alloc(), new_pos, mid_n);


            this->m_holder.m_size = old_size + s_before;
            old_values_destroyer.release();

            if(do_after){

               insert_range_proxy.copy_n_and_update(this->m_holder.alloc(), old_start, elemsbefore);
            }
            else{

               const size_type rest_new = n - mid_n;
               insert_range_proxy.copy_n_and_update(this->m_holder.alloc(), old_start, rest_new);
               T* const move_start = old_start + rest_new;

               T* const move_end = move_start != pos ? ::boost::container::move(pos, old_finish, move_start)
                                                     : old_finish;


               size_type n_destroy = s_before - n;
               if(!value_traits::trivial_dctr_after_move)
                  boost::container::destroy_alloc_n(this->get_stored_allocator(), move_end, n_destroy);
               this->m_holder.m_size -= n_destroy;
            }
         }


         if(do_after){
# 3262 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
            const size_type n_after = n - s_before;
            const size_type elemsafter = old_size - elemsbefore;


            if (elemsafter >= n_after){
# 3280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
               T* finish_n = old_finish - n_after;
               ::boost::container::uninitialized_move_alloc
                  (this->m_holder.alloc(), finish_n, old_finish, old_finish);
               this->m_holder.m_size += n_after;

               boost::container::move_backward(pos, finish_n, old_finish);


               insert_range_proxy.copy_n_and_update(this->m_holder.alloc(), pos, n_after);
            }
            else {
# 3304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
               const size_type mid_last_dist = n_after - elemsafter;



               ::boost::container::uninitialized_move_alloc
                  (this->m_holder.alloc(), pos, old_finish, old_finish + mid_last_dist);

               typename value_traits::ArrayDestructor old_end_destroyer
                  (old_finish + mid_last_dist, this->m_holder.alloc(), old_finish - pos);


               insert_range_proxy.copy_n_and_update(this->m_holder.alloc(), pos, elemsafter);

               insert_range_proxy.uninitialized_copy_n_and_update(this->m_holder.alloc(), old_finish, mid_last_dist);
               this->m_holder.m_size += n_after;
               old_end_destroyer.release();
            }
         }
      }
   }

   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());
   }
# 3353 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 3 4
};

}}



namespace boost {



template <class T, class Allocator>
struct has_trivial_destructor_after_move<boost::container::vector<T, Allocator> >
{
   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
                             ::boost::has_trivial_destructor_after_move<pointer>::value;
};

}



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 3376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/vector.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 2 3 4






namespace boost { namespace container {



namespace dtl {

template<class T, std::size_t N>
class static_storage_allocator
{
   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; }

   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:
   typename aligned_storage<sizeof(T)*N, alignment_of<T>::value>::type storage;
};

}
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
template <typename Value, std::size_t Capacity>
class static_vector
    : public vector<Value, dtl::static_storage_allocator<Value, Capacity> >
{

   typedef vector<Value, dtl::static_storage_allocator<Value, Capacity> > base_t;

  

   template<class U, std::size_t OtherCapacity>
   friend class static_vector;

   public:
   typedef dtl::static_storage_allocator<Value, Capacity> allocator_type;


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;
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector() noexcept
        : base_t()
    {}
# 169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) explicit static_vector(size_type count)
        : base_t(count)
    {}
# 187 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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())
    {}
# 203 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)
    {}
# 221 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)
    {}
# 239 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector(std::initializer_list<value_type> il)
        : base_t(il)
    {}
# 253 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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()
    {}
# 281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C>
    inline __attribute__ ((__always_inline__)) static_vector(static_vector<value_type, C> const& other)
        : base_t(other)
    {}
# 296 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)))
    {}
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C>
    inline __attribute__ ((__always_inline__)) static_vector( static_vector<value_type, C> && other)
        : base_t(::boost::move((typename static_vector<value_type , C>::base_t&)(other)))
    {}
# 327 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)));
    }
# 342 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)); }
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C>
    inline __attribute__ ((__always_inline__)) static_vector & operator=(static_vector<value_type, C> const& other)
    {
        return static_cast<static_vector&>(base_t::operator=
            (static_cast<typename static_vector<value_type, C>::base_t const&>(other)));
    }
# 374 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector & operator=(static_vector && other)
    {
        return static_cast<static_vector&>(base_t::operator=(::boost::move((base_t&)(other))));
    }
# 391 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C>
    inline __attribute__ ((__always_inline__)) static_vector & operator=( static_vector<value_type, C> && other)
    {
        return static_cast<static_vector&>(base_t::operator=
         (::boost::move((typename static_vector<value_type , C>::base_t&)(other))));
    }
# 1118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) friend void swap(static_vector &x, static_vector &y)
   {
      x.swap(y);
   }



};
# 1229 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 3 4
template<typename V, std::size_t C1, std::size_t C2>
inline void swap(static_vector<V, C1> & x, static_vector<V, C2> & y
      , typename dtl::enable_if_c< C1 != C2>::type * = 0)
{
   x.swap(y);
}



}}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 1241 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/static_vector.hpp" 2 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/config.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/begin.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/begin.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/config.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/begin.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/range_fwd.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/mutable_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/mutable_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/extract_optional_type.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/extract_optional_type.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/cat.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/cat.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/config/config.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/cat.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/extract_optional_type.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bool.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bool.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bool_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bool_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/adl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bool_fwd.hpp" 2 3 4

namespace mpl_ {

template< bool C_ > struct bool_;


typedef bool_<true> true_;
typedef bool_<false> false_;

}

namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bool.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/integral_c_tag.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/integral_c_tag.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;


}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/void_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/void_fwd.hpp" 3 4
namespace mpl_ {

struct void_;

}
namespace boost { namespace mpl { using ::mpl_::void_; } }
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na.hpp" 3 4
}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/lambda.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda_fwd.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/int.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/int.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/int_fwd.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/int_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/int_fwd.hpp" 2 3 4

namespace mpl_ {

template< int N > struct int_;

}
namespace boost { namespace mpl { using ::mpl_::int_; } }
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/int.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/static_cast.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/int.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/lambda_arity_param.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename F > struct template_arity;

}}}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arity.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arity.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/dtp.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arity.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/comma_if.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/comma_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/if.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/iif.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/logical/bool.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/if.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/comma_if.hpp" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repeat.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repeat.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/debug/error.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repeat.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/inc.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/inc.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/inc.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/enum.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/limits/arity.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/logical/and.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/logical/and.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/logical/bitand.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/logical/and.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/identity.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/identity.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/facilities/identity.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/identity.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/empty.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/add.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/add.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/dec.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_left.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_left.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/detail/fold_left.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/expr_iif.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/adt.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/adt.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/is_binary.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/is_binary.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/check.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/is_binary.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/logical/compl.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_right.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/detail/fold_right.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/reverse.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/detail/while.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/while.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/elem.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/facilities/expand.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/facilities/overload.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/variadic/size.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/rem.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/variadic/elem.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/sub.hpp" 1 3 4
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/eti.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/type_wrapper.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/yes_no.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/yes_no.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/arrays.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/yes_no.hpp" 2 3 4




namespace boost { namespace mpl { namespace aux {

typedef char (&no_tag)[1];
typedef char (&yes_tag)[2];

template< bool C_ > struct yes_no_tag
{
    typedef no_tag type;
};

template<> struct yes_no_tag<true>
{
    typedef yes_tag type;
};


template< long n > struct weighted_tag
{

    typedef char (&type)[n];




};
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/yes_no.hpp" 3 4
}}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/has_xxx.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/msvc_typename.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/array/elem.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/array/elem.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/array/data.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/array/size.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum_params.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/has_xxx.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/extract_optional_type.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/mutable_iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_reference.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_reference.hpp" 3 4
   template <class T> using remove_reference_t = typename remove_reference<T>::type;



}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/mutable_iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_traits.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/msvc_has_iterator_workaround.hpp" 1 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/mutable_iterator.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/const_iterator.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/const_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_const.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/const_iterator.hpp" 2 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_const.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_const.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/integral_constant.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;




      template <class U>
      static U& dereference(U* p) { return *p; }

      operator const mpl::integral_c<T, val>& ()const
      {
         static const char data[sizeof(long)] = { 0 };
         return dereference(reinterpret_cast<const mpl::integral_c<T, val>*>(&data));
      }
      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;




      template <class T>
      static T& dereference(T* p) { return *p; }

      operator const mpl::bool_<val>& ()const
      {
         static const char data = 0;
         return dereference(reinterpret_cast<const mpl::bool_<val>*>(&data));
      }
      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;

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_const.hpp" 2 3 4

namespace boost {
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};



}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/eval_if.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/eval_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/if.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/value_wknd.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/value_wknd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/integral.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/value_wknd.hpp" 3 4
}}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/if.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> { }; }

}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 2 3 4

namespace boost
{
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator.hpp" 3 4
    template< typename C, typename Enabler=void >
    struct range_iterator
      : mpl::if_c<
            is_const<typename remove_reference<C>::type>::value,
            range_const_iterator<typename remove_const<typename remove_reference<C>::type>::type>,
            range_mutable_iterator<typename remove_reference<C>::type>
        >::type
    {
    };



}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/begin.hpp" 2 3 4

namespace boost
{


namespace range_detail
{






    template< typename C >
    inline typename range_iterator<C>::type
    range_begin( C& c )
    {





        return c.begin();
    }





    template< typename Iterator >
    inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }

    template< typename Iterator >
    inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/begin.hpp" 3 4
    template< typename T, std::size_t sz >
    inline const T* range_begin( const T (&a)[sz] )
    {
        return a;
    }

    template< typename T, std::size_t sz >
    inline T* range_begin( T (&a)[sz] )
    {
        return a;
    }



}





namespace range_adl_barrier
{

template< class T >
inline typename range_iterator<T>::type begin( T& r )
{

    using namespace range_detail;

    return range_begin( r );
}

template< class T >
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;
}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/end.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/end.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/implementation_help.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/implementation_help.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/common.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/common.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/sfinae.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/sfinae.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_array.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};





}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/sfinae.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/sfinae.hpp" 2 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/common.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_void.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};

}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/common.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/or.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/or.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/use_preprocessed.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/or.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/nested_type_wknd.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
{
};
}}}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/or.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/or.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/compiler.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/stringize.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/or.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/common.hpp" 2 3 4






namespace boost
{
    namespace range_detail
    {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_ = (boost::mpl::or_<boost::mpl::bool_<is_const_char_ptr_>, boost::mpl::bool_<is_const_wchar_t_ptr_> >::value );
            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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/implementation_help.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_same.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 {};







}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 >
        inline T* array_end( T (&boost_range_array)[sz] )
        {
            return boost_range_array + sz;
        }

        template< class T, std::size_t sz >
        inline const T* array_end( const T (&boost_range_array)[sz] )
        {
            return boost_range_array + sz;
        }





        template< class Char >
        inline std::size_t str_size( const Char* const& s )
        {
            return str_end( s ) - s;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( const T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

        inline bool is_same_address(const void* l, const void* r)
        {
            return l == r;
        }

        template<class T1, class T2>
        inline bool is_same_object(const T1& l, const T2& r)
        {
            return range_detail::is_same_address(&l, &r);
        }

    }

}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/end.hpp" 2 3 4



namespace boost
{


namespace range_detail
{





        template< typename C >
        inline typename range_iterator<C>::type
        range_end( C& c )
        {





            return c.end();
        }





        template< typename Iterator >
        inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }

        template< typename Iterator >
        inline Iterator range_end( std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }





        template< typename T, std::size_t sz >
        inline const T* range_end( const T (&a)[sz] )
        {
            return range_detail::array_end<T,sz>( a );
        }

        template< typename T, std::size_t sz >
        inline T* range_end( T (&a)[sz] )
        {
            return range_detail::array_end<T,sz>( a );
        }


}


namespace range_adl_barrier
{

template< class T >
inline typename range_iterator<T>::type end( T& r )
{

    using namespace range_detail;

    return range_end( r );
}

template< class T >
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 >
        inline typename range_iterator<const T>::type
        const_end( const T& r )
        {
            return boost::range_adl_barrier::end( r );
        }
    }
    using namespace range_adl_barrier;
}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/as_literal.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/as_literal.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/interoperable.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/interoperable.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/intrinsics.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/intrinsics.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/config.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/version.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/config.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/intrinsics.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_complete.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_complete.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_function.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_function.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_reference.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_reference.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_lvalue_reference.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_reference.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_rvalue_reference.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>
{};

}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_function.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
namespace boost {
namespace type_traits {

template <class R>
struct is_function_ptr_helper
{
    static const bool value = false;
};




template <class R >
struct is_function_ptr_helper<R(*)()> { static const bool value = true; };

template <class R >
struct is_function_ptr_helper<R(*)(...)> { static const bool value = true; };


template <class R >
struct is_function_ptr_helper<R(*)()noexcept> { static const bool value = true; };

template <class R >
struct is_function_ptr_helper<R(*)(...)noexcept> { static const bool value = true; };


template <class R, class T0>
struct is_function_ptr_helper<R(*)(T0)> { static const bool value = true; };

template <class R, class T0>
struct is_function_ptr_helper<R(*)(T0 ...)> { static const bool value = true; };


template <class R, class T0>
struct is_function_ptr_helper<R(*)(T0)noexcept> { static const bool value = true; };

template <class R, class T0>
struct is_function_ptr_helper<R(*)(T0 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1>
struct is_function_ptr_helper<R(*)(T0, T1)> { static const bool value = true; };

template <class R, class T0, class T1>
struct is_function_ptr_helper<R(*)(T0, T1 ...)> { static const bool value = true; };


template <class R, class T0, class T1>
struct is_function_ptr_helper<R(*)(T0, T1)noexcept> { static const bool value = true; };

template <class R, class T0, class T1>
struct is_function_ptr_helper<R(*)(T0, T1 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2>
struct is_function_ptr_helper<R(*)(T0, T1, T2)> { static const bool value = true; };

template <class R, class T0, class T1, class T2>
struct is_function_ptr_helper<R(*)(T0, T1, T2 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2>
struct is_function_ptr_helper<R(*)(T0, T1, T2)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2>
struct is_function_ptr_helper<R(*)(T0, T1, T2 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...)noexcept> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...)> { static const bool value = true; };


template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)noexcept> { static const bool value = true; };

template <class R, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_function_ptr_helper<R(*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...)noexcept> { static const bool value = true; };
# 419 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
}
}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_function.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_function.hpp" 3 4
namespace boost {



namespace detail {


template<bool is_ref = true>
struct is_function_chooser
{
   template< typename T > struct result_
      : public false_type {};
};

template <>
struct is_function_chooser<false>
{
    template< typename T > struct result_
        : public ::boost::type_traits::is_function_ptr_helper<T*> {};
};

template <typename T>
struct is_function_impl
    : public is_function_chooser< ::boost::is_reference<T>::value >
        ::template result_<T>
{
};
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_function.hpp" 3 4
}






template <class T> struct is_function : integral_constant<bool, ::boost::detail::is_function_impl<T>::value> {};

template <class T> struct is_function<T&&> : public false_type {};


}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_complete.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_complete.hpp" 3 4
namespace boost {
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_complete.hpp" 3 4
   namespace detail{

      template <unsigned N>
      struct ok_tag { double d; char c[N]; };

      template <class T>
      ok_tag<sizeof(T)> check_is_complete(int);
      template <class T>
      char check_is_complete(...);
   }

   template <class T> struct is_complete
      : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(detail::check_is_complete<T>(0)) != sizeof(char))> {};
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_complete.hpp" 3 4
}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_arithmetic.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_arithmetic.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_integral.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_integral.hpp" 3 4
template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
template<> struct is_integral< ::boost::long_long_type> : public true_type{};






template<> struct is_integral<boost::int128_type> : public true_type{};
template<> struct is_integral<boost::uint128_type> : public true_type{};


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


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




}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_floating_point.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};





}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_arithmetic.hpp" 2 3 4

namespace boost {

template <class T>
struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_abstract.hpp" 1 3 4
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_abstract.hpp" 3 4
}


template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};




}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_lvalue_reference.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_lvalue_reference.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_reference.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;




}
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4

namespace boost{

template <class T> struct add_lvalue_reference
{
   typedef typename boost::add_reference<T>::type type;
};


template <class T> struct add_lvalue_reference<T&&>
{
   typedef T& type;
};




   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;



}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_rvalue_reference.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/declval.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/declval.hpp" 3 4
namespace boost {

    template <typename T>
    typename add_rvalue_reference<T>::type declval() noexcept;

}
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 2 3 4






namespace boost {
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 3 4
namespace detail {







   template <class A, class B, class C>
   struct or_helper
   {
      static const bool value = (A::value || B::value || C::value);
   };

   template<typename From, typename To, bool b = or_helper<boost::is_void<From>, boost::is_function<To>, boost::is_array<To> >::value>
   struct is_convertible_basic_impl
   {

      static const bool value = is_void<To>::value;
   };

   template<typename From, typename To>
   class is_convertible_basic_impl<From, To, false>
   {
      typedef char one;
      typedef int two;

      template<typename To1>
      static void test_aux(To1);

      template<typename From1, typename To1>
      static decltype(test_aux<To1>(boost::declval<From1>()), one()) test(int);

      template<typename, typename>
      static two test(...);

   public:
      static const bool value = sizeof(test<From, To>(0)) == 1;
   };
# 362 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 3 4
template <typename From, typename To>
struct is_convertible_impl
{
   static const bool value = ( ::boost::detail::is_convertible_basic_impl<From, To>::value && !::boost::is_array<To>::value && !::boost::is_function<To>::value);
};


template <bool trivial1, bool trivial2, bool abstract_target>
struct is_convertible_impl_select
{
   template <class From, class To>
   struct rebind
   {
      typedef is_convertible_impl<From, To> type;
   };
};

template <>
struct is_convertible_impl_select<true, true, false>
{
   template <class From, class To>
   struct rebind
   {
      typedef true_type type;
   };
};

template <>
struct is_convertible_impl_select<false, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <>
struct is_convertible_impl_select<true, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <typename From, typename To>
struct is_convertible_impl_dispatch_base
{

   typedef is_convertible_impl_select<
      ::boost::is_arithmetic<From>::value,
      ::boost::is_arithmetic<To>::value,




      false

   > selector;



   typedef typename selector::template rebind<From, To> isc_binder;
   typedef typename isc_binder::type type;
};

template <typename From, typename To>
struct is_convertible_impl_dispatch
   : public is_convertible_impl_dispatch_base<From, To>::type
{};
# 442 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 3 4
template <> struct is_convertible_impl_dispatch<void, void> : public true_type{};
template <> struct is_convertible_impl_dispatch<void, void const> : public true_type{};
template <> struct is_convertible_impl_dispatch<void, void const volatile> : public true_type{};
template <> struct is_convertible_impl_dispatch<void, void volatile> : public true_type{};

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

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

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





template <class To> struct is_convertible_impl_dispatch<void, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void> : public false_type{};


template <class To> struct is_convertible_impl_dispatch<void const, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void const> : public false_type{};
template <class To> struct is_convertible_impl_dispatch<void const volatile, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void const volatile> : public false_type{};
template <class To> struct is_convertible_impl_dispatch<void volatile, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void volatile> : public false_type{};


}

template <class From, class To>
struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value>
{
   static_assert(boost::is_complete<To>::value || boost::is_void<To>::value || boost::is_array<To>::value, "Destination argument type to is_convertible must be a complete type");
   static_assert(boost::is_complete<From>::value || boost::is_void<From>::value || boost::is_array<From>::value, "From argument type to is_convertible must be a complete type");
};
# 504 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_convertible.hpp" 3 4
}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/interoperable.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/interoperable.hpp" 2 3 4

namespace boost {
namespace iterators {
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/interoperable.hpp" 2 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_categories.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_categories.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_categories.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/identity.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg_fwd.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg_fwd.hpp" 3 4
namespace mpl_ {

template< int N > struct arg;

}
namespace boost { namespace mpl { using ::mpl_::arg; } }
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_assert.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_assert.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/not.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/not.hpp" 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/gpu.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/pp_counter.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 2 3 4
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 3 4
namespace mpl_ {

struct failed {};
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 );
# 246 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/assert.hpp" 3 4
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/na_assert.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arity_spec.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arg_typedef.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 3 4
namespace mpl_ {
template<> struct arg< -1 >
{
    static const int value = -1;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<1>
{
    static const int value = 1;
    typedef arg<2> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<2>
{
    static const int value = 2;
    typedef arg<3> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U2 type;
        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<3>
{
    static const int value = 3;
    typedef arg<4> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U3 type;
        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<4>
{
    static const int value = 4;
    typedef arg<5> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U4 type;
        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<5>
{
    static const int value = 5;
    typedef arg<6> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U5 type;
        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};



}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_categories.hpp" 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/and.hpp" 1 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/and.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/and.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_pointer.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_pointer.hpp" 3 4
}
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_class.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_class.hpp" 3 4
namespace boost {

namespace detail {
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> {};






}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_volatile.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_volatile.hpp" 3 4
namespace boost {
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};



}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_function_pointer.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
namespace boost {
namespace type_traits {

template <typename T>
struct is_mem_fun_pointer_impl
{
    static const bool value = false;
};





template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)()> { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...)> { static const bool value = true; };


template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)() const> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)() volatile> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)() const volatile> { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...) const> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...) volatile> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...) const volatile> { static const bool value = true; };



template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)()noexcept> { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...)noexcept> { static const bool value = true; };


template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)() const noexcept> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)() volatile noexcept> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)() const volatile noexcept> { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...) const noexcept> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...) volatile noexcept> { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R(T::*)(...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0)> { static const bool value = true; };

template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...)> { static const bool value = true; };


template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0) const> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0) volatile> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0) const volatile> { static const bool value = true; };

template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) const> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0)noexcept> { static const bool value = true; };

template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0) const noexcept> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0>
struct is_mem_fun_pointer_impl<R(T::*)(T0 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1)> { static const bool value = true; };

template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1) const> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23 ...) const volatile noexcept> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...)> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) volatile> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const volatile> { static const bool value = true; };



template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...)noexcept> { static const bool value = true; };


template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) const volatile noexcept> { static const bool value = true; };

template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) volatile noexcept> { static const bool value = true; };
template <class R, class T, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16, class T17, class T18, class T19, class T20, class T21, class T22, class T23, class T24>
struct is_mem_fun_pointer_impl<R(T::*)(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24 ...) const volatile noexcept> { static const bool value = true; };
# 1254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
}
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_cv.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
namespace boost {





template <class T> struct is_member_function_pointer
   : public ::boost::integral_constant<bool, ::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value>{};
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_pointer.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_member_pointer.hpp" 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{};




}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_pointer.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_pointer.hpp" 3 4
namespace boost {
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 3 4
namespace boost { namespace detail {

namespace indirect_traits {

template <class T>
struct is_reference_to_const : mpl::false_
{
};

template <class T>
struct is_reference_to_const<T const&> : mpl::true_
{
};
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 3 4
template <class T>
struct is_reference_to_function : mpl::false_
{
};

template <class T>
struct is_reference_to_function<T&> : is_function<T>
{
};

template <class T>
struct is_pointer_to_function : mpl::false_
{
};



template <class T>
struct is_pointer_to_function<T*> : is_function<T>
{
};

template <class T>
struct is_reference_to_member_function_pointer_impl : mpl::false_
{
};

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
    : mpl::and_<
          is_reference<T>
        , is_pointer_to_function<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >
      >
{

};

template <class T>
struct is_reference_to_function_pointer
    : mpl::if_<
          is_reference_to_function<T>
        , mpl::false_
        , is_reference_to_function_pointer_aux<T>
     >::type
{
};

template <class T>
struct is_reference_to_non_const
    : mpl::and_<
          is_reference<T>
        , mpl::not_<
             is_reference_to_const<T>
          >
      >
{
};

template <class T>
struct is_reference_to_volatile : mpl::false_
{
};

template <class T>
struct is_reference_to_volatile<T volatile&> : mpl::true_
{
};
# 144 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/indirect_traits.hpp" 3 4
template <class T>
struct is_reference_to_pointer : mpl::false_
{
};

template <class T>
struct is_reference_to_pointer<T*&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* const&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* volatile&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* const volatile&> : mpl::true_
{
};

template <class T>
struct is_reference_to_class
    : mpl::and_<
          is_reference<T>
        , is_class<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >
      >
{
   
};

template <class T>
struct is_pointer_to_class
    : mpl::and_<
          is_pointer<T>
        , is_class<
              typename remove_cv<
                  typename remove_pointer<T>::type
              >::type
          >
      >
{
   
};


}

using namespace indirect_traits;

}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4






namespace boost {
namespace iterators {


struct 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
template <class Traversal, class ValueParam, class Reference>
struct iterator_facade_default_category
  : mpl::eval_if<
        mpl::and_<
            is_reference<Reference>
          , is_convertible<Traversal,forward_traversal_tag>
        >
      , mpl::eval_if<
            is_convertible<Traversal,random_access_traversal_tag>
          , mpl::identity<std::random_access_iterator_tag>
          , mpl::if_<
                is_convertible<Traversal,bidirectional_traversal_tag>
              , std::bidirectional_iterator_tag
              , std::forward_iterator_tag
            >
        >
      , typename mpl::eval_if<
            mpl::and_<
                is_convertible<Traversal, single_pass_traversal_tag>


              , is_convertible<Reference, ValueParam>
            >
          , mpl::identity<std::input_iterator_tag>
          , mpl::identity<Traversal>
        >
    >
{
};


template <class T>
struct is_iterator_category
  : mpl::or_<
        is_convertible<T,std::input_iterator_tag>
      , is_convertible<T,std::output_iterator_tag>
    >
{
};

template <class T>
struct is_iterator_traversal
  : is_convertible<T,incrementable_traversal_tag>
{};







template <class Category, class Traversal>
struct iterator_category_with_traversal
  : Category, Traversal
{



    enum { mpl_assertion_in_line_141 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) ( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >))0, 1 ) ) ) }



             ;

    enum { mpl_assertion_in_line_147 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
    enum { mpl_assertion_in_line_148 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
    enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };

    enum { mpl_assertion_in_line_151 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_traversal<Traversal>))0, 1 ) ) ) };

};



template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl
{
    enum { mpl_assertion_in_line_160 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };

    typedef typename iterator_facade_default_category<
        Traversal,ValueParam,Reference
    >::type category;

    typedef typename mpl::if_<
        is_same<
            Traversal
          , typename iterator_category_to_traversal<category>::type
        >
      , category
      , iterator_category_with_traversal<category,Traversal>
    >::type type;
};




template <class CategoryOrTraversal, class ValueParam, class Reference>
struct facade_iterator_category
  : mpl::eval_if<
        is_iterator_category<CategoryOrTraversal>
      , mpl::identity<CategoryOrTraversal>
      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
    >
{
};

}}}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/enable_if.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/enable_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/enable_if.hpp" 2 3 4







namespace boost
{

  namespace iterators
  {



    template<bool>
    struct enabled
    {
      template<typename T>
      struct base
      {
        typedef T type;
      };
    };






    template<>
    struct enabled<false>
    {
      template<typename T>
      struct base
      {
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/enable_if.hpp" 3 4
      };
    };


    template <class Cond,
              class Return>
    struct enable_if

      : enabled<(Cond::value)>::template base<Return>



    {
    };

  }

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/enable_if.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/addressof.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/addressof.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/addressof.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/addressof.hpp" 3 4
namespace boost {

template<class T>
constexpr inline T*
addressof(T& o) noexcept
{
    return __builtin_addressof(o);
}

}
# 266 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/addressof.hpp" 3 4
namespace boost {

template<class T>
const T* addressof(const T&&) = delete;

}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/addressof.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_const.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_const.hpp" 3 4
namespace boost {
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_const.hpp" 3 4
   template <class T> struct add_const
   {
      typedef T const type;
   };





   template <class T> struct add_const<T&>
   {
      typedef T& type;
   };



   template <class T> using add_const_t = typename add_const<T>::type;



}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_pointer.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_pointer.hpp" 3 4
namespace boost {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_pod.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_pod.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_scalar.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_scalar.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_enum.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_enum.hpp" 3 4
namespace boost {
# 160 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_enum.hpp" 3 4
template <class T> struct is_enum : public integral_constant<bool, __is_enum(T)> {};



}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_pod.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>{};

}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/always.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/always.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/default_params.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_fwd.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_fwd.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/has_apply.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/has_apply.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/has_apply.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/msvc_never_true.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/bind.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind_fwd.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind_fwd.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/next.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/next.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/next_prior.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/next_prior.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/common_name_wknd.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/next.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/protect.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/void.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/has_type.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/bcc.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/template_arity.hpp" 1 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/template_arity.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< int N > struct arity_tag
{
    typedef char (&type)[N + 1];
};

template<
      int C1, int C2, int C3, int C4, int C5, int C6
    >
struct max_arity
{
    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) )

         ;
};

arity_tag<0>::type arity_helper(...);

template<
      template< typename P1 > class F
    , typename T1
    >
typename arity_tag<1>::type
arity_helper(type_wrapper< F<T1> >, arity_tag<1>);

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    >
typename arity_tag<2>::type
arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    >
typename arity_tag<3>::type
arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    >
typename arity_tag<4>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    >
typename arity_tag<5>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5, typename P6
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename T6
    >
typename arity_tag<6>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
template< typename F, int N >
struct template_arity_impl
{
    static const int value = sizeof(::boost::mpl::aux::arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1

         ;
};

template< typename F >
struct template_arity
{
    static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value )

          ;
    typedef mpl::int_<value> type;
};

}}}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/template_arity.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/lambda.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 3 4
    };







    template <class Iterator>
    class postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;
     public:
        explicit postfix_increment_proxy(Iterator const& x)
          : stored_value(*x)
        {}





        value_type&
        operator*() const
        {
            return this->stored_value;
        }
     private:
        mutable value_type stored_value;
    };





    template <class Iterator>
    class writable_postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;
     public:
        explicit writable_postfix_increment_proxy(Iterator const& x)
          : stored_value(*x)
          , stored_iterator(x)
        {}





        writable_postfix_increment_proxy const&
        operator*() const
        {
            return *this;
        }


        operator value_type&() const
        {
            return stored_value;
        }


        template <class T>
        T const& operator=(T const& x) const
        {
            *this->stored_iterator = x;
            return x;
        }


        template <class T>
        T& operator=(T& x) const
        {
            *this->stored_iterator = x;
            return x;
        }


        operator Iterator const&() const
        {
            return stored_iterator;
        }

     private:
        mutable value_type stored_value;
        Iterator stored_iterator;
    };
# 259 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 3 4
    template <class Reference, class Value>
    struct is_non_proxy_reference
      : is_convertible<
            typename remove_reference<Reference>::type
            const volatile*
          , Value const volatile*
        >
    {};
# 284 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

  }
# 497 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
  }
# 900 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>() ); }
# 930 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>() ); }
# 955 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; }
# 972 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 3 4
}

using iterators::iterator_core_access;
using iterators::iterator_facade;

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 980 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_base_and_derived.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_base_and_derived.hpp" 3 4
namespace boost {

namespace detail {
# 220 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};





}
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/functions.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/functions.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size_type.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size_type.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/difference_type.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/difference_type.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/has_range_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/has_range_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/enable_if.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/enable_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/enable_if.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/enable_if.hpp" 3 4
namespace boost
{
  template<typename T, typename R=void>
  struct enable_if_has_type
  {
    typedef R type;
  };

  template <bool B, class T = void>
  struct enable_if_c {
    typedef T type;
  };

  template <class T>
  struct enable_if_c<false, T> {};

  template <class Cond, class T = void>
  struct enable_if : public enable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_enable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_enable_if_c<false, T> {};

  template <class Cond, class T>
  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};


  template <bool B, class T = void>
  struct disable_if_c {
    typedef T type;
  };

  template <class T>
  struct disable_if_c<true, T> {};

  template <class Cond, class T = void>
  struct disable_if : public disable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_disable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_disable_if_c<true, T> {};

  template <class Cond, class T>
  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};

}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/enable_if.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/has_range_iterator.hpp" 2 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<range_const_iterator<
                                typename remove_const<T>::type> >,
                    has_type<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<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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size_type.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/concepts.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/concepts.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept_check.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept_check.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/assert.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/assert.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/general.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/general.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/backward_compatibility.hpp" 1 3 4






namespace boost
{
  namespace concepts {}




}
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/general.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/has_constraints.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 mpl::bool_<value> type;
};

}}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)>
  : mpl::if_<
        concepts::not_satisfied<Model>
      , constraint<Model>
      , requirement<failed ************ Model::************>
    >::type
{};
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/general.hpp" 3 4
}}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/assert.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept_check.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/conversion_traits.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept_check.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/usage.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/usage.hpp" 3 4
namespace boost { namespace concepts {

template <class Model>
struct usage_requirements
{
    ~usage_requirements() { ((Model*)0)->~Model(); }
};
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/usage.hpp" 3 4
}}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept_check.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/concept_def.hpp" 1 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/for_each_i.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/for.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/detail/for.hpp" 1 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/seq.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/seq.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/elem.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/seq.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/size.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/detail/is_empty.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
# 7 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/concept_def.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/enum.hpp" 1 3 4
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/concept_def.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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::mpl::false_)
      {

          const Return& r = f();
          ignore_unused_variable_warning(r);
      }

      void test(boost::mpl::true_)
      {
          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::mpl::false_)
      {
          f(arg);
          Return r = f(arg);
          ignore_unused_variable_warning(r);
      }

      void test(boost::mpl::true_)
      {
          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::mpl::false_)
      {
          f(first,second);
          Return r = f(first, second);
          (void)r;
      }

      void test(boost::mpl::true_)
      {
          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_check545 __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_check573 __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_check603 __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_check677 __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_check697 __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_check710 __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_check726 __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_check770 __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;
          enum { mpl_assertion_in_line_969 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_same<key_type,value_type>))0, 1 ) ) ) };
      }
  };

  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;
          enum { mpl_assertion_in_line_982 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_same<value_type,required_value_type>))0, 1 ) ) ) };
      }
  };

  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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/concept_undef.hpp" 1 3 4
# 1080 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept_check.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/concepts.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_concepts.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_concepts.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/limits.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_concepts.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/concept_def.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_check114 __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_check134 __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;

      enum { mpl_assertion_in_line_147 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_integral<difference_type>))0, 1 ) ) ) };
      enum { mpl_assert_rel_value148 = (std::numeric_limits<difference_type>::is_signed == true) }; enum { mpl_assertion_in_line_148 = sizeof( boost::mpl::assertion_failed<mpl_assert_rel_value148>( (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(*)( boost::Convertible< typename ForwardTraversal::traversal_category , boost::forward_traversal_tag > )>::failed> boost_concept_check150 __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_check160 __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_check178 __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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/concept/detail/concept_undef.hpp" 1 3 4
# 272 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_concepts.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/concepts.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/value_type.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/value_type.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_value : iterator_value< typename range_iterator<T>::type >
    { };
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/concepts.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/misc_concept.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/concepts.hpp" 2 3 4
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/concepts.hpp" 3 4
namespace boost {

    namespace range_detail {
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_check130 __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_check152 __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>))0, 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_check191 __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_check218 __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_check239 __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 RandomAccessIteratorConcept::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_check278 __attribute__((__unused__))
                                                                   ;

        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( range_detail::SinglePassIteratorConcept<const_iterator>)>::failed> boost_concept_check281 __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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size_type.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/make_unsigned.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/make_unsigned.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/conditional.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/make_unsigned.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_signed.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_signed.hpp" 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 34 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 195 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 3 4
# 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
# 183 "/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
# 184 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 188 "/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
# 192 "/usr/include/limits.h" 2 3 4
# 196 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-redhat-linux/10/include/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 2 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};







}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/make_unsigned.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_unsigned.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_unsigned.hpp" 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};


}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/make_unsigned.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_volatile.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_volatile.hpp" 3 4
namespace boost {
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/has_member_size.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/has_member_size.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/size.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/base_from_member.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/base_from_member.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/base_from_member.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/base_from_member.hpp" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/base_from_member.hpp" 3 4
namespace boost
{

namespace detail
{
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 >
{};
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> >
{};


}
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/base_from_member.hpp" 3 4
template < typename MemberType, int UniqueID = 0 >
class base_from_member
{
protected:
    MemberType member;





    template <typename ...T, typename EnableIf = typename
     ::boost::detail::enable_if_unrelated<base_from_member, T...>::type>
    explicit constexpr base_from_member( T&& ...x )
        noexcept((noexcept((::new ((void*) 0) MemberType( static_cast<T&&>(x)... )))))

        : member( static_cast<T&&>(x)... )
        {}
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/base_from_member.hpp" 3 4
};

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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/binary.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/binary.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/deduce_d.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/deduce_d.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/control/deduce_d.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/binary.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/cat.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/cat.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/fold_left.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/fold_left.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/cat.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/binary.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/seq/transform.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/binary.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/mod.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/mod.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/comparison/less_equal.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/comparison/less_equal.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/logical/not.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/comparison/less_equal.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/arithmetic/mod.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/binary.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/identity_type.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/identity_type.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/function_traits.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/identity_type.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/checked_delete.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/checked_delete.hpp" 3 4
namespace boost
{



template<class T> inline void checked_delete(T * x)
{

    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}

template<class T> inline void checked_array_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {

        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
};

}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/noncopyable.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/noncopyable.hpp" 3 4
namespace boost {






namespace noncopyable_
{
  class noncopyable
  {
  protected:

      constexpr noncopyable() = default;
      ~noncopyable() = default;





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





  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/functions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/distance.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/distance.hpp" 3 4
namespace boost
{

    template< class T >
    inline typename range_difference<T>::type
    distance( const T& r )
    {
        return std::distance( boost::begin( r ), boost::end( r ) );
    }

}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/functions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/empty.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/functions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/rbegin.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/rbegin.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/reverse_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/reverse_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/reverse_iterator.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/reverse_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_adaptor.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_adaptor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_adaptor.hpp" 2 3 4



namespace boost {
namespace iterators {




  struct use_default;

}

using iterators::use_default;




template<class To>
struct is_convertible<use_default,To>
  : mpl::false_ {};

namespace iterators {

  namespace detail
  {
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_adaptor.hpp" 3 4
    struct enable_type;
  }
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/reverse_iterator.hpp" 2 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/rbegin.hpp" 2 3 4

namespace boost
{
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/rbegin.hpp" 3 4
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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/functions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/rend.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/rend.hpp" 3 4
namespace boost
{
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/rend.hpp" 3 4
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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/functions.hpp" 2 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/algorithm/equal.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/safe_bool.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_plus.hpp" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_plus.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
          
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/make_void.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/make_void.hpp" 3 4
}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 = boost::void_t<>>
      struct has_plus_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_plus_ret_imp<T, U, Ret, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::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 = boost::void_t<> >
      struct has_plus_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_void_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::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 = boost::void_t<>>
      struct has_plus_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_dc_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_plus.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_plus_assign.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_plus_assign.hpp" 3 4
          
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_plus_assign.hpp" 3
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_plus_assign.hpp" 3
namespace boost
{

   namespace binary_op_detail {

      struct dont_care;

      template <class T, class U, class Ret, class = boost::void_t<>>
      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, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::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 = boost::void_t<> >
      struct has_plus_assign_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_assign_void_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::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 = boost::void_t<>>
      struct has_plus_assign_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_assign_dc_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::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> {};

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_minus.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_minus.hpp" 3 4
          
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_minus.hpp" 3
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 = boost::void_t<>>
      struct has_minus_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_minus_ret_imp<T, U, Ret, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::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 = boost::void_t<> >
      struct has_minus_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_void_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::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 = boost::void_t<>>
      struct has_minus_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_dc_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::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> {};


}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_minus_assign.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_minus_assign.hpp" 3 4
          
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_minus_assign.hpp" 3
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 = boost::void_t<>>
      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, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::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 = boost::void_t<> >
      struct has_minus_assign_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_assign_void_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::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 = boost::void_t<>>
      struct has_minus_assign_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_assign_dc_imp<T, U, boost::void_t<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::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)> {};


}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/advance.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/advance.hpp" 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 iterators::advance;

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 2 3 4


namespace boost {
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/next_prior.hpp" 3 4
namespace next_prior_detail {







template< typename T, typename Void = void >
struct is_iterator_class
{
    static constexpr bool value = false;
};

template< typename T >
struct is_iterator_class<
    T,
    typename enable_if_has_type<

        typename std::iterator_traits< T >::iterator_category



    >::type
>
{
    static constexpr bool value = true;
};

template< typename T >
struct is_iterator :
    public is_iterator_class< T >
{
};

template< typename T >
struct is_iterator< T* >
{
    static constexpr bool value = true;
};


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 = 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 = 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);
}

}
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 2 3 4
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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<void> (0));
       return *m_Begin;
   }

   void drop_front()
   {
       (static_cast<void> (0));
       ++m_Begin;
   }

   void drop_front(difference_type n)
   {
       (static_cast<void> (0));
       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<void> (0));
        return *boost::prior(this->m_End);
    }

    void drop_back()
    {
        (static_cast<void> (0));
        --this->m_End;
    }

    void drop_back(difference_type n)
    {
        (static_cast<void> (0));
        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<void> (0));
        (static_cast<void> (0));
        return this->m_Begin[at];
    }






    abstract_value_type operator()(difference_type at) const
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
        return this->m_Begin[at];
    }

    typename base_type::size_type size() const
    {
        return this->m_End - this->m_Begin;
    }
};

    }
# 433 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 );
        }
# 758 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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));
        }
# 788 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 3 4
        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 );
            }
        }
# 843 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_core.hpp" 3 4
        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 );
        }
# 871 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_io.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_io.hpp" 3 4
# 1 "/usr/include/c++/10/ostream" 1 3 4
# 36 "/usr/include/c++/10/ostream" 3 4
       
# 37 "/usr/include/c++/10/ostream" 3

# 1 "/usr/include/c++/10/ios" 1 3
# 36 "/usr/include/c++/10/ios" 3
       
# 37 "/usr/include/c++/10/ios" 3







# 1 "/usr/include/c++/10/bits/basic_ios.h" 1 3
# 33 "/usr/include/c++/10/bits/basic_ios.h" 3
       
# 34 "/usr/include/c++/10/bits/basic_ios.h" 3



# 1 "/usr/include/c++/10/bits/locale_facets.h" 1 3
# 37 "/usr/include/c++/10/bits/locale_facets.h" 3
       
# 38 "/usr/include/c++/10/bits/locale_facets.h" 3

# 1 "/usr/include/c++/10/cwctype" 1 3
# 39 "/usr/include/c++/10/cwctype" 3
       
# 40 "/usr/include/c++/10/cwctype" 3
# 50 "/usr/include/c++/10/cwctype" 3
# 1 "/usr/include/wctype.h" 1 3 4
# 38 "/usr/include/wctype.h" 3 4
# 1 "/usr/include/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) throw ();





extern int iswalpha (wint_t __wc) throw ();


extern int iswcntrl (wint_t __wc) throw ();



extern int iswdigit (wint_t __wc) throw ();



extern int iswgraph (wint_t __wc) throw ();




extern int iswlower (wint_t __wc) throw ();


extern int iswprint (wint_t __wc) throw ();




extern int iswpunct (wint_t __wc) throw ();




extern int iswspace (wint_t __wc) throw ();




extern int iswupper (wint_t __wc) throw ();




extern int iswxdigit (wint_t __wc) throw ();





extern int iswblank (wint_t __wc) throw ();
# 155 "/usr/include/bits/wctype-wchar.h" 3 4
extern wctype_t wctype (const char *__property) throw ();



extern int iswctype (wint_t __wc, wctype_t __desc) throw ();






extern wint_t towlower (wint_t __wc) throw ();


extern wint_t towupper (wint_t __wc) throw ();

}
# 39 "/usr/include/wctype.h" 2 3 4





extern "C" {



typedef const __int32_t *wctrans_t;



extern wctrans_t wctrans (const char *__property) throw ();


extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();







extern int iswalnum_l (wint_t __wc, locale_t __locale) throw ();





extern int iswalpha_l (wint_t __wc, locale_t __locale) throw ();


extern int iswcntrl_l (wint_t __wc, locale_t __locale) throw ();



extern int iswdigit_l (wint_t __wc, locale_t __locale) throw ();



extern int iswgraph_l (wint_t __wc, locale_t __locale) throw ();




extern int iswlower_l (wint_t __wc, locale_t __locale) throw ();


extern int iswprint_l (wint_t __wc, locale_t __locale) throw ();




extern int iswpunct_l (wint_t __wc, locale_t __locale) throw ();




extern int iswspace_l (wint_t __wc, locale_t __locale) throw ();




extern int iswupper_l (wint_t __wc, locale_t __locale) throw ();




extern int iswxdigit_l (wint_t __wc, locale_t __locale) throw ();




extern int iswblank_l (wint_t __wc, locale_t __locale) throw ();



extern wctype_t wctype_l (const char *__property, locale_t __locale)
     throw ();



extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
     throw ();






extern wint_t towlower_l (wint_t __wc, locale_t __locale) throw ();


extern wint_t towupper_l (wint_t __wc, locale_t __locale) throw ();



extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
     throw ();


extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
      locale_t __locale) throw ();



}
# 51 "/usr/include/c++/10/cwctype" 2 3
# 80 "/usr/include/c++/10/cwctype" 3
namespace std
{
  using ::wctrans_t;
  using ::wctype_t;
  using ::wint_t;

  using ::iswalnum;
  using ::iswalpha;

  using ::iswblank;

  using ::iswcntrl;
  using ::iswctype;
  using ::iswdigit;
  using ::iswgraph;
  using ::iswlower;
  using ::iswprint;
  using ::iswpunct;
  using ::iswspace;
  using ::iswupper;
  using ::iswxdigit;
  using ::towctrans;
  using ::towlower;
  using ::towupper;
  using ::wctrans;
  using ::wctype;
}
# 40 "/usr/include/c++/10/bits/locale_facets.h" 2 3
# 1 "/usr/include/c++/10/cctype" 1 3
# 39 "/usr/include/c++/10/cctype" 3
       
# 40 "/usr/include/c++/10/cctype" 3
# 41 "/usr/include/c++/10/bits/locale_facets.h" 2 3
# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/ctype_base.h" 1 3
# 36 "/usr/include/c++/10/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/include/c++/10/bits/locale_facets.h" 2 3
# 50 "/usr/include/c++/10/bits/locale_facets.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 71 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<typename _Tp>
    void
    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
     const __c_locale&) throw();


  template<>
    void
    __convert_to_v(const char*, float&, ios_base::iostate&,
     const __c_locale&) throw();

  template<>
    void
    __convert_to_v(const char*, double&, ios_base::iostate&,
     const __c_locale&) throw();

  template<>
    void
    __convert_to_v(const char*, long double&, ios_base::iostate&,
     const __c_locale&) throw();



  template<typename _CharT, typename _Traits>
    struct __pad
    {
      static void
      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
    };






  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last);




  template<typename _CharT>
    inline
    ostreambuf_iterator<_CharT>
    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
    {
      __s._M_put(__ws, __len);
      return __s;
    }


  template<typename _CharT, typename _OutIter>
    inline
    _OutIter
    __write(_OutIter __s, const _CharT* __ws, int __len)
    {
      for (int __j = 0; __j < __len; __j++, ++__s)
 *__s = __ws[__j];
      return __s;
    }
# 149 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 168 "/usr/include/c++/10/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 185 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }
# 201 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }
# 217 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }
# 231 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 246 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 260 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 275 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 292 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 311 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }
# 330 "/usr/include/c++/10/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 352 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
       char __dfault, char* __to) const
      { return this->do_narrow(__lo, __hi, __dfault, __to); }

    protected:
      explicit
      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }

      virtual
      ~__ctype_abstract_base() { }
# 377 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 396 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 415 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 434 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 452 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const = 0;
# 469 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 485 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const = 0;
# 502 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 521 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const = 0;
# 542 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
# 563 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const = 0;
# 588 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const = 0;
    };
# 611 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename __ctype_abstract_base<_CharT>::mask mask;


      static locale::id id;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

   protected:
      virtual
      ~ctype();

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type __c) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type __c) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char __c) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;
# 680 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<>
    class ctype<char> : public locale::facet, public ctype_base
    {
    public:


      typedef char char_type;

    protected:

      __c_locale _M_c_locale_ctype;
      bool _M_del;
      __to_type _M_toupper;
      __to_type _M_tolower;
      const mask* _M_table;
      mutable char _M_widen_ok;
      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow_ok;


    public:

      static locale::id id;

      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
# 717 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 730 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 743 "/usr/include/c++/10/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 758 "/usr/include/c++/10/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 772 "/usr/include/c++/10/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 786 "/usr/include/c++/10/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 801 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 818 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 834 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 851 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 871 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      {
 if (_M_widen_ok)
   return _M_widen[static_cast<unsigned char>(__c)];
 this->_M_widen_init();
 return this->do_widen(__c);
      }
# 898 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (_M_widen_ok == 1)
   {
     if (__builtin_expect(__hi != __lo, true))
       __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_widen_ok)
   _M_widen_init();
 return this->do_widen(__lo, __hi, __to);
      }
# 930 "/usr/include/c++/10/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      {
 if (_M_narrow[static_cast<unsigned char>(__c)])
   return _M_narrow[static_cast<unsigned char>(__c)];
 const char __t = do_narrow(__c, __dfault);
 if (__t != __dfault)
   _M_narrow[static_cast<unsigned char>(__c)] = __t;
 return __t;
      }
# 963 "/usr/include/c++/10/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
      char __dfault, char* __to) const
      {
 if (__builtin_expect(_M_narrow_ok == 1, true))
   {
     if (__builtin_expect(__hi != __lo, true))
       __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_narrow_ok)
   _M_narrow_init();
 return this->do_narrow(__lo, __hi, __dfault, __to);
      }





      const mask*
      table() const throw()
      { return _M_table; }


      static const mask*
      classic_table() throw();
    protected:







      virtual
      ~ctype();
# 1013 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1030 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1046 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1063 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1083 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1106 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (__builtin_expect(__hi != __lo, true))
   __builtin_memcpy(__to, __lo, __hi - __lo);
 return __hi;
      }
# 1133 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
      { return __c; }
# 1159 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault __attribute__((__unused__)), char* __to) const
      {
 if (__builtin_expect(__hi != __lo, true))
   __builtin_memcpy(__to, __lo, __hi - __lo);
 return __hi;
      }

    private:
      void _M_narrow_init() const;
      void _M_widen_init() const;
    };
# 1185 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<>
    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
    {
    public:


      typedef wchar_t char_type;
      typedef wctype_t __wmask_type;

    protected:
      __c_locale _M_c_locale_ctype;


      bool _M_narrow_ok;
      char _M_narrow[128];
      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];


      mask _M_bit[16];
      __wmask_type _M_wmask[16];

    public:


      static locale::id id;
# 1218 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1229 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, size_t __refs = 0);

    protected:
      __wmask_type
      _M_convert_to_wmask(const mask __m) const throw();


      virtual
      ~ctype();
# 1253 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1272 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1290 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1308 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1325 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1342 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1358 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1375 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1395 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const;
# 1417 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
# 1440 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const;
# 1466 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const;


      void
      _M_initialize_ctype() throw();
    };



  template<typename _CharT>
    class ctype_byname : public ctype<_CharT>
    {
    public:
      typedef typename ctype<_CharT>::mask mask;

      explicit
      ctype_byname(const char* __s, size_t __refs = 0);


      explicit
      ctype_byname(const string& __s, size_t __refs = 0)
      : ctype_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~ctype_byname() { }
    };


  template<>
    class ctype_byname<char> : public ctype<char>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);


      explicit
      ctype_byname(const string& __s, size_t __refs = 0);


    protected:
      virtual
      ~ctype_byname();
    };


  template<>
    class ctype_byname<wchar_t> : public ctype<wchar_t>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);


      explicit
      ctype_byname(const string& __s, size_t __refs = 0);


    protected:
      virtual
      ~ctype_byname();
    };



}


# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
# 37 "/usr/include/c++/10/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;
  }


}
# 1539 "/usr/include/c++/10/bits/locale_facets.h" 2 3

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



  class __num_base
  {
  public:


    enum
      {
 _S_ominus,
 _S_oplus,
 _S_ox,
 _S_oX,
 _S_odigits,
 _S_odigits_end = _S_odigits + 16,
 _S_oudigits = _S_odigits_end,
 _S_oudigits_end = _S_oudigits + 16,
 _S_oe = _S_odigits + 14,
 _S_oE = _S_oudigits + 14,
 _S_oend = _S_oudigits_end
      };






    static const char* _S_atoms_out;



    static const char* _S_atoms_in;

    enum
    {
      _S_iminus,
      _S_iplus,
      _S_ix,
      _S_iX,
      _S_izero,
      _S_ie = _S_izero + 14,
      _S_iE = _S_izero + 20,
      _S_iend = 26
    };



    static void
    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
  };

  template<typename _CharT>
    struct __numpunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      const _CharT* _M_truename;
      size_t _M_truename_size;
      const _CharT* _M_falsename;
      size_t _M_falsename_size;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;





      _CharT _M_atoms_out[__num_base::_S_oend];





      _CharT _M_atoms_in[__num_base::_S_iend];

      bool _M_allocated;

      __numpunct_cache(size_t __refs = 0)
      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
 _M_use_grouping(false),
 _M_truename(0), _M_truename_size(0), _M_falsename(0),
 _M_falsename_size(0), _M_decimal_point(_CharT()),
 _M_thousands_sep(_CharT()), _M_allocated(false)
 { }

      ~__numpunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __numpunct_cache&
      operator=(const __numpunct_cache&);

      explicit
      __numpunct_cache(const __numpunct_cache&);
    };

  template<typename _CharT>
    __numpunct_cache<_CharT>::~__numpunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_truename;
   delete [] _M_falsename;
 }
    }

namespace __cxx11 {
# 1669 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<typename _CharT>
    class numpunct : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __numpunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;

    public:

      static locale::id id;






      explicit
      numpunct(size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_numpunct(); }
# 1707 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1721 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_numpunct(__cloc); }
# 1735 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1748 "/usr/include/c++/10/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1779 "/usr/include/c++/10/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1792 "/usr/include/c++/10/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1805 "/usr/include/c++/10/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1822 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1834 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1847 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1860 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1873 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual string_type
      do_falsename() const
      { return _M_data->_M_falsename; }


      void
      _M_initialize_numpunct(__c_locale __cloc = 0);
    };

  template<typename _CharT>
    locale::id numpunct<_CharT>::id;

  template<>
    numpunct<char>::~numpunct();

  template<>
    void
    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);


  template<>
    numpunct<wchar_t>::~numpunct();

  template<>
    void
    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);



  template<typename _CharT>
    class numpunct_byname : public numpunct<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      numpunct_byname(const char* __s, size_t __refs = 0)
      : numpunct<_CharT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_numpunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }


      explicit
      numpunct_byname(const string& __s, size_t __refs = 0)
      : numpunct_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~numpunct_byname() { }
    };

}


# 1951 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;



      static locale::id id;
# 1972 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 1998 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, bool& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2035 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned short& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned int& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2095 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, float& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2138 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, void*& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

    protected:

      virtual ~num_get() { }

      __attribute ((__abi_tag__ ("cxx11")))
      iter_type
      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
         string&) const;

      template<typename _ValueT>
 __attribute ((__abi_tag__ ("cxx11")))
 iter_type
 _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
         _ValueT&) const;

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
 _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
 {
   int __ret = -1;
   if (__len <= 10)
     {
       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
  __ret = __c - _CharT2('0');
     }
   else
     {
       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
  __ret = __c - _CharT2('0');
       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
  __ret = 10 + (__c - _CharT2('a'));
       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
  __ret = 10 + (__c - _CharT2('A'));
     }
   return __ret;
 }

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
          int>::__type
 _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
 {
   int __ret = -1;
   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
   if (__q)
     {
       __ret = __q - __zero;
       if (__ret > 15)
  __ret -= 6;
     }
   return __ret;
 }
# 2211 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned short& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned int& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
      double&) const;







      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
      long double&) const;


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
# 2274 "/usr/include/c++/10/bits/locale_facets.h" 3
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2292 "/usr/include/c++/10/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 2313 "/usr/include/c++/10/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2331 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2373 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   unsigned long __v) const
      { return this->do_put(__s, __io, __fill, __v); }


      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   unsigned long long __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2436 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   long double __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2461 "/usr/include/c++/10/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const void* __v) const
      { return this->do_put(__s, __io, __fill, __v); }

    protected:
      template<typename _ValueT>
 iter_type
 _M_insert_float(iter_type, ios_base& __io, char_type __fill,
   char __mod, _ValueT __v) const;

      void
      _M_group_float(const char* __grouping, size_t __grouping_size,
       char_type __sep, const char_type* __p, char_type* __new,
       char_type* __cs, int& __len) const;

      template<typename _ValueT>
 iter_type
 _M_insert_int(iter_type, ios_base& __io, char_type __fill,
        _ValueT __v) const;

      void
      _M_group_int(const char* __grouping, size_t __grouping_size,
     char_type __sep, ios_base& __io, char_type* __new,
     char_type* __cs, int& __len) const;

      void
      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
      char_type* __new, const char_type* __cs, int& __len) const;


      virtual
      ~num_put() { }
# 2509 "/usr/include/c++/10/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


      virtual iter_type
      do_put(iter_type, ios_base&, char_type, double) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type, long double) const;


      virtual iter_type
      do_put(iter_type, ios_base&, char_type, const void*) const;







    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;









  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }


  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }


  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }


  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }


  template<typename _CharT>
    inline bool
    islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }


  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }


  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }


  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }


  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }


  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }


  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }



  template<typename _CharT>
    inline bool
    isblank(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }



  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }


  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }


}

# 1 "/usr/include/c++/10/bits/locale_facets.tcc" 1 3
# 33 "/usr/include/c++/10/bits/locale_facets.tcc" 3
       
# 34 "/usr/include/c++/10/bits/locale_facets.tcc" 3

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




  template<typename _Facet>
    struct __use_cache
    {
      const _Facet*
      operator() (const locale& __loc) const;
    };


  template<typename _CharT>
    struct __use_cache<__numpunct_cache<_CharT> >
    {
      const __numpunct_cache<_CharT>*
      operator() (const locale& __loc) const
      {
 const size_t __i = numpunct<_CharT>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __numpunct_cache<_CharT>* __tmp = 0;
     try
       {
  __tmp = new __numpunct_cache<_CharT>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
      }
    };

  template<typename _CharT>
    void
    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
    {
      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);

      char* __grouping = 0;
      _CharT* __truename = 0;
      _CharT* __falsename = 0;
      try
 {
   const string& __g = __np.grouping();
   _M_grouping_size = __g.size();
   __grouping = new char[_M_grouping_size];
   __g.copy(__grouping, _M_grouping_size);
   _M_use_grouping = (_M_grouping_size
        && static_cast<signed char>(__grouping[0]) > 0
        && (__grouping[0]
     != __gnu_cxx::__numeric_traits<char>::__max));

   const basic_string<_CharT>& __tn = __np.truename();
   _M_truename_size = __tn.size();
   __truename = new _CharT[_M_truename_size];
   __tn.copy(__truename, _M_truename_size);

   const basic_string<_CharT>& __fn = __np.falsename();
   _M_falsename_size = __fn.size();
   __falsename = new _CharT[_M_falsename_size];
   __fn.copy(__falsename, _M_falsename_size);

   _M_decimal_point = __np.decimal_point();
   _M_thousands_sep = __np.thousands_sep();

   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
   __ct.widen(__num_base::_S_atoms_out,
       __num_base::_S_atoms_out
       + __num_base::_S_oend, _M_atoms_out);
   __ct.widen(__num_base::_S_atoms_in,
       __num_base::_S_atoms_in
       + __num_base::_S_iend, _M_atoms_in);

   _M_grouping = __grouping;
   _M_truename = __truename;
   _M_falsename = __falsename;
   _M_allocated = true;
 }
      catch(...)
 {
   delete [] __grouping;
   delete [] __truename;
   delete [] __falsename;
   throw;
 }
    }
# 139 "/usr/include/c++/10/bits/locale_facets.tcc" 3
  __attribute__ ((__pure__)) bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp) throw ();



  template<typename _CharT, typename _InIter>
    __attribute ((__abi_tag__ ("cxx11")))
    _InIter
    num_get<_CharT, _InIter>::
    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, string& __xtrc) const
    {
      typedef char_traits<_CharT> __traits_type;
      typedef __numpunct_cache<_CharT> __cache_type;
      __use_cache<__cache_type> __uc;
      const locale& __loc = __io._M_getloc();
      const __cache_type* __lc = __uc(__loc);
      const _CharT* __lit = __lc->_M_atoms_in;
      char_type __c = char_type();


      bool __testeof = __beg == __end;


      if (!__testeof)
 {
   __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
     {
       __xtrc += __plus ? '+' : '-';
       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
 }


      bool __found_mantissa = false;
      int __sep_pos = 0;
      while (!__testeof)
 {
   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       || __c == __lc->_M_decimal_point)
     break;
   else if (__c == __lit[__num_base::_S_izero])
     {
       if (!__found_mantissa)
  {
    __xtrc += '0';
    __found_mantissa = true;
  }
       ++__sep_pos;

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
   else
     break;
 }


      bool __found_dec = false;
      bool __found_sci = false;
      string __found_grouping;
      if (__lc->_M_use_grouping)
 __found_grouping.reserve(32);
      const char_type* __lit_zero = __lit + __num_base::_S_izero;

      if (!__lc->_M_allocated)

 while (!__testeof)
   {
     const int __digit = _M_find(__lit_zero, 10, __c);
     if (__digit != -1)
       {
  __xtrc += '0' + __digit;
  __found_mantissa = true;
       }
     else if (__c == __lc->_M_decimal_point
       && !__found_dec && !__found_sci)
       {
  __xtrc += '.';
  __found_dec = true;
       }
     else if ((__c == __lit[__num_base::_S_ie]
        || __c == __lit[__num_base::_S_iE])
       && !__found_sci && __found_mantissa)
       {

  __xtrc += 'e';
  __found_sci = true;


  if (++__beg != __end)
    {
      __c = *__beg;
      const bool __plus = __c == __lit[__num_base::_S_iplus];
      if (__plus || __c == __lit[__num_base::_S_iminus])
        __xtrc += __plus ? '+' : '-';
      else
        continue;
    }
  else
    {
      __testeof = true;
      break;
    }
       }
     else
       break;

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }
      else
 while (!__testeof)
   {


     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       {
  if (!__found_dec && !__found_sci)
    {


      if (__sep_pos)
        {
   __found_grouping += static_cast<char>(__sep_pos);
   __sep_pos = 0;
        }
      else
        {


   __xtrc.clear();
   break;
        }
    }
  else
    break;
       }
     else if (__c == __lc->_M_decimal_point)
       {
  if (!__found_dec && !__found_sci)
    {



      if (__found_grouping.size())
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += '.';
      __found_dec = true;
    }
  else
    break;
       }
     else
       {
  const char_type* __q =
    __traits_type::find(__lit_zero, 10, __c);
  if (__q)
    {
      __xtrc += '0' + (__q - __lit_zero);
      __found_mantissa = true;
      ++__sep_pos;
    }
  else if ((__c == __lit[__num_base::_S_ie]
     || __c == __lit[__num_base::_S_iE])
    && !__found_sci && __found_mantissa)
    {

      if (__found_grouping.size() && !__found_dec)
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += 'e';
      __found_sci = true;


      if (++__beg != __end)
        {
   __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping
     && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
        __xtrc += __plus ? '+' : '-';
   else
     continue;
        }
      else
        {
   __testeof = true;
   break;
        }
    }
  else
    break;
       }

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }



      if (__found_grouping.size())
        {

   if (!__found_dec && !__found_sci)
     __found_grouping += static_cast<char>(__sep_pos);

          if (!std::__verify_grouping(__lc->_M_grouping,
          __lc->_M_grouping_size,
          __found_grouping))
     __err = ios_base::failbit;
        }

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    template<typename _ValueT>
      __attribute ((__abi_tag__ ("cxx11")))
      _InIter
      num_get<_CharT, _InIter>::
      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, _ValueT& __v) const
      {
        typedef char_traits<_CharT> __traits_type;
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_in;
 char_type __c = char_type();


 const ios_base::fmtflags __basefield = __io.flags()
                                        & ios_base::basefield;
 const bool __oct = __basefield == ios_base::oct;
 int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);


 bool __testeof = __beg == __end;


 bool __negative = false;
 if (!__testeof)
   {
     __c = *__beg;
     __negative = __c == __lit[__num_base::_S_iminus];
     if ((__negative || __c == __lit[__num_base::_S_iplus])
  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  && !(__c == __lc->_M_decimal_point))
       {
  if (++__beg != __end)
    __c = *__beg;
  else
    __testeof = true;
       }
   }



 bool __found_zero = false;
 int __sep_pos = 0;
 while (!__testeof)
   {
     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  || __c == __lc->_M_decimal_point)
       break;
     else if (__c == __lit[__num_base::_S_izero]
       && (!__found_zero || __base == 10))
       {
  __found_zero = true;
  ++__sep_pos;
  if (__basefield == 0)
    __base = 8;
  if (__base == 8)
    __sep_pos = 0;
       }
     else if (__found_zero
       && (__c == __lit[__num_base::_S_ix]
    || __c == __lit[__num_base::_S_iX]))
       {
  if (__basefield == 0)
    __base = 16;
  if (__base == 16)
    {
      __found_zero = false;
      __sep_pos = 0;
    }
  else
    break;
       }
     else
       break;

     if (++__beg != __end)
       {
  __c = *__beg;
  if (!__found_zero)
    break;
       }
     else
       __testeof = true;
   }



 const size_t __len = (__base == 16 ? __num_base::_S_iend
         - __num_base::_S_izero : __base);


 typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits;
 string __found_grouping;
 if (__lc->_M_use_grouping)
   __found_grouping.reserve(32);
 bool __testfail = false;
 bool __testoverflow = false;
 const __unsigned_type __max =
   (__negative && __num_traits::__is_signed)
   ? -static_cast<__unsigned_type>(__num_traits::__min)
   : __num_traits::__max;
 const __unsigned_type __smax = __max / __base;
 __unsigned_type __result = 0;
 int __digit = 0;
 const char_type* __lit_zero = __lit + __num_base::_S_izero;

 if (!__lc->_M_allocated)

   while (!__testeof)
     {
       __digit = _M_find(__lit_zero, __len, __c);
       if (__digit == -1)
  break;

       if (__result > __smax)
  __testoverflow = true;
       else
  {
    __result *= __base;
    __testoverflow |= __result > __max - __digit;
    __result += __digit;
    ++__sep_pos;
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
 else
   while (!__testeof)
     {


       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  {


    if (__sep_pos)
      {
        __found_grouping += static_cast<char>(__sep_pos);
        __sep_pos = 0;
      }
    else
      {
        __testfail = true;
        break;
      }
  }
       else if (__c == __lc->_M_decimal_point)
  break;
       else
  {
    const char_type* __q =
      __traits_type::find(__lit_zero, __len, __c);
    if (!__q)
      break;

    __digit = __q - __lit_zero;
    if (__digit > 15)
      __digit -= 6;
    if (__result > __smax)
      __testoverflow = true;
    else
      {
        __result *= __base;
        __testoverflow |= __result > __max - __digit;
        __result += __digit;
        ++__sep_pos;
      }
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }



 if (__found_grouping.size())
   {

     __found_grouping += static_cast<char>(__sep_pos);

     if (!std::__verify_grouping(__lc->_M_grouping,
     __lc->_M_grouping_size,
     __found_grouping))
       __err = ios_base::failbit;
   }



 if ((!__sep_pos && !__found_zero && !__found_grouping.size())
     || __testfail)
   {
     __v = 0;
     __err = ios_base::failbit;
   }
 else if (__testoverflow)
   {
     if (__negative && __num_traits::__is_signed)
       __v = __num_traits::__min;
     else
       __v = __num_traits::__max;
     __err = ios_base::failbit;
   }
 else
   __v = __negative ? -__result : __result;

 if (__testeof)
   __err |= ios_base::eofbit;
 return __beg;
      }



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, bool& __v) const
    {
      if (!(__io.flags() & ios_base::boolalpha))
        {



   long __l = -1;
          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
   if (__l == 0 || __l == 1)
     __v = bool(__l);
   else
     {


       __v = true;
       __err = ios_base::failbit;
       if (__beg == __end)
  __err |= ios_base::eofbit;
     }
        }
      else
        {

   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   bool __testf = true;
   bool __testt = true;
   bool __donef = __lc->_M_falsename_size == 0;
   bool __donet = __lc->_M_truename_size == 0;
   bool __testeof = false;
   size_t __n = 0;
   while (!__donef || !__donet)
     {
       if (__beg == __end)
  {
    __testeof = true;
    break;
  }

       const char_type __c = *__beg;

       if (!__donef)
  __testf = __c == __lc->_M_falsename[__n];

       if (!__testf && __donet)
  break;

       if (!__donet)
  __testt = __c == __lc->_M_truename[__n];

       if (!__testt && __donef)
  break;

       if (!__testt && !__testf)
  break;

       ++__n;
       ++__beg;

       __donef = !__testf || __n >= __lc->_M_falsename_size;
       __donet = !__testt || __n >= __lc->_M_truename_size;
     }
   if (__testf && __n == __lc->_M_falsename_size && __n)
     {
       __v = false;
       if (__testt && __n == __lc->_M_truename_size)
  __err = ios_base::failbit;
       else
  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else if (__testt && __n == __lc->_M_truename_size && __n)
     {
       __v = true;
       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else
     {


       __v = false;
       __err = ios_base::failbit;
       if (__testeof)
  __err |= ios_base::eofbit;
     }
 }
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, float& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }
# 735 "/usr/include/c++/10/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      const fmtflags __fmt = __io.flags();
      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);

      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      _UIntPtrType __ul;
      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


      __io.flags(__fmt);

      __v = reinterpret_cast<void*>(__ul);
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
    _CharT* __new, const _CharT* __cs, int& __len) const
    {


      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
        __cs, __w, __len);
      __len = static_cast<int>(__w);
    }



  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
    ios_base::fmtflags __flags, bool __dec)
    {
      _CharT* __buf = __bufend;
      if (__builtin_expect(__dec, true))
 {

   do
     {
       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
       __v /= 10;
     }
   while (__v != 0);
 }
      else if ((__flags & ios_base::basefield) == ios_base::oct)
 {

   do
     {
       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
       __v >>= 3;
     }
   while (__v != 0);
 }
      else
 {

   const bool __uppercase = __flags & ios_base::uppercase;
   const int __case_offset = __uppercase ? __num_base::_S_oudigits
                                         : __num_base::_S_odigits;
   do
     {
       *--__buf = __lit[(__v & 0xf) + __case_offset];
       __v >>= 4;
     }
   while (__v != 0);
 }
      return __bufend - __buf;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
    {
      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
     __grouping_size, __cs, __cs + __len);
      __len = __p - __new;
    }

  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
      _ValueT __v) const
      {
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_out;
 const ios_base::fmtflags __flags = __io.flags();


 const int __ilen = 5 * sizeof(_ValueT);
 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __ilen));



 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
 const bool __dec = (__basefield != ios_base::oct
       && __basefield != ios_base::hex);
 const __unsigned_type __u = ((__v > 0 || !__dec)
         ? __unsigned_type(__v)
         : -__unsigned_type(__v));
  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
 __cs += __ilen - __len;


 if (__lc->_M_use_grouping)
   {


     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * (__len + 1)
          * 2));
     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
     __cs = __cs2 + 2;
   }


 if (__builtin_expect(__dec, true))
   {

     if (__v >= 0)
       {
  if (bool(__flags & ios_base::showpos)
      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
    *--__cs = __lit[__num_base::_S_oplus], ++__len;
       }
     else
       *--__cs = __lit[__num_base::_S_ominus], ++__len;
   }
 else if (bool(__flags & ios_base::showbase) && __v)
   {
     if (__basefield == ios_base::oct)
       *--__cs = __lit[__num_base::_S_odigits], ++__len;
     else
       {

  const bool __uppercase = __flags & ios_base::uppercase;
  *--__cs = __lit[__num_base::_S_ox + __uppercase];

  *--__cs = __lit[__num_base::_S_odigits];
  __len += 2;
       }
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
     __cs = __cs3;
   }
 __io.width(0);



 return std::__write(__s, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_float(const char* __grouping, size_t __grouping_size,
     _CharT __sep, const _CharT* __p, _CharT* __new,
     _CharT* __cs, int& __len) const
    {



      const int __declen = __p ? __p - __cs : __len;
      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
      __grouping_size,
      __cs, __cs + __declen);


      int __newlen = __p2 - __new;
      if (__p)
 {
   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
   __newlen += __len - __declen;
 }
      __len = __newlen;
    }
# 971 "/usr/include/c++/10/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
         _ValueT __v) const
      {
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);


 const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();

 const int __max_digits =
   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;


 int __len;

 char __fbuf[16];
 __num_base::_S_format_float(__io, __fbuf, __mod);



 const bool __use_prec =
   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;



 int __cs_size = __max_digits * 3;
 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
 if (__use_prec)
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     __fbuf, __prec, __v);
 else
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     __fbuf, __v);


 if (__len >= __cs_size)
   {
     __cs_size = __len + 1;
     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
     if (__use_prec)
       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
         __fbuf, __prec, __v);
     else
       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
         __fbuf, __v);
   }
# 1044 "/usr/include/c++/10/bits/locale_facets.tcc" 3
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __len));
 __ctype.widen(__cs, __cs + __len, __ws);


 _CharT* __wp = 0;
 const char* __p = char_traits<char>::find(__cs, __len, '.');
 if (__p)
   {
     __wp = __ws + (__p - __cs);
     *__wp = __lc->_M_decimal_point;
   }




 if (__lc->_M_use_grouping
     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
          && __cs[1] >= '0' && __cs[2] >= '0')))
   {


     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __len * 2));

     streamsize __off = 0;
     if (__cs[0] == '-' || __cs[0] == '+')
       {
  __off = 1;
  __ws2[0] = __ws[0];
  __len -= 1;
       }

     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
      __lc->_M_thousands_sep, __wp, __ws2 + __off,
      __ws + __off, __len);
     __len += __off;

     __ws = __ws2;
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
     __ws = __ws3;
   }
 __io.width(0);



 return std::__write(__s, __ws, __len);
      }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      if ((__flags & ios_base::boolalpha) == 0)
        {
          const long __l = __v;
          __s = _M_insert_int(__s, __io, __fill, __l);
        }
      else
        {
   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   const _CharT* __name = __v ? __lc->_M_truename
                              : __lc->_M_falsename;
   int __len = __v ? __lc->_M_truename_size
                   : __lc->_M_falsename_size;

   const streamsize __w = __io.width();
   if (__w > static_cast<streamsize>(__len))
     {
       const streamsize __plen = __w - __len;
       _CharT* __ps
  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
       * __plen));

       char_traits<_CharT>::assign(__ps, __plen, __fill);
       __io.width(0);

       if ((__flags & ios_base::adjustfield) == ios_base::left)
  {
    __s = std::__write(__s, __name, __len);
    __s = std::__write(__s, __ps, __plen);
  }
       else
  {
    __s = std::__write(__s, __ps, __plen);
    __s = std::__write(__s, __name, __len);
  }
       return __s;
     }
   __io.width(0);
   __s = std::__write(__s, __name, __len);
 }
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    { return _M_insert_float(__s, __io, __fill, char(), __v); }
# 1169 "/usr/include/c++/10/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
    long double __v) const
    { return _M_insert_float(__s, __io, __fill, 'L', __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           const void* __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      const ios_base::fmtflags __fmt = ~(ios_base::basefield
      | ios_base::uppercase);
      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));

      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      __s = _M_insert_int(__s, __io, __fill,
     reinterpret_cast<_UIntPtrType>(__v));
      __io.flags(__flags);
      return __s;
    }


# 1206 "/usr/include/c++/10/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
       _CharT* __news, const _CharT* __olds,
       streamsize __newlen, streamsize __oldlen)
    {
      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;


      if (__adjust == ios_base::left)
 {
   _Traits::copy(__news, __olds, __oldlen);
   _Traits::assign(__news + __oldlen, __plen, __fill);
   return;
 }

      size_t __mod = 0;
      if (__adjust == ios_base::internal)
 {



          const locale& __loc = __io._M_getloc();
   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

   if (__ctype.widen('-') == __olds[0]
       || __ctype.widen('+') == __olds[0])
     {
       __news[0] = __olds[0];
       __mod = 1;
       ++__news;
     }
   else if (__ctype.widen('0') == __olds[0]
     && __oldlen > 1
     && (__ctype.widen('x') == __olds[1]
         || __ctype.widen('X') == __olds[1]))
     {
       __news[0] = __olds[0];
       __news[1] = __olds[1];
       __mod = 2;
       __news += 2;
     }

 }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
    }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last)
    {
      size_t __idx = 0;
      size_t __ctr = 0;

      while (__last - __first > __gbeg[__idx]
      && static_cast<signed char>(__gbeg[__idx]) > 0
      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
 {
   __last -= __gbeg[__idx];
   __idx < __gsize - 1 ? ++__idx : ++__ctr;
 }

      while (__first != __last)
 *__s++ = *__first++;

      while (__ctr--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      while (__idx--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      return __s;
    }




  extern template class __cxx11:: numpunct<char>;
  extern template class __cxx11:: numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class ctype_byname<char>;

  extern template
    const ctype<char>&
    use_facet<ctype<char> >(const locale&);

  extern template
    const numpunct<char>&
    use_facet<numpunct<char> >(const locale&);

  extern template
    const num_put<char>&
    use_facet<num_put<char> >(const locale&);

  extern template
    const num_get<char>&
    use_facet<num_get<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<numpunct<char> >(const locale&);

  extern template
    bool
    has_facet<num_put<char> >(const locale&);

  extern template
    bool
    has_facet<num_get<char> >(const locale&);


  extern template class __cxx11:: numpunct<wchar_t>;
  extern template class __cxx11:: numpunct_byname<wchar_t>;
  extern template class num_get<wchar_t>;
  extern template class num_put<wchar_t>;
  extern template class ctype_byname<wchar_t>;

  extern template
    const ctype<wchar_t>&
    use_facet<ctype<wchar_t> >(const locale&);

  extern template
    const numpunct<wchar_t>&
    use_facet<numpunct<wchar_t> >(const locale&);

  extern template
    const num_put<wchar_t>&
    use_facet<num_put<wchar_t> >(const locale&);

  extern template
    const num_get<wchar_t>&
    use_facet<num_get<wchar_t> >(const locale&);

 extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<numpunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_get<wchar_t> >(const locale&);




}
# 2656 "/usr/include/c++/10/bits/locale_facets.h" 2 3
# 38 "/usr/include/c++/10/bits/basic_ios.h" 2 3



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


  template<typename _Facet>
    inline const _Facet&
    __check_facet(const _Facet* __f)
    {
      if (!__f)
 __throw_bad_cast();
      return *__f;
    }
# 66 "/usr/include/c++/10/bits/basic_ios.h" 3
  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {
    public:






      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;






      typedef ctype<_CharT> __ctype_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
           __num_put_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
           __num_get_type;



    protected:
      basic_ostream<_CharT, _Traits>* _M_tie;
      mutable char_type _M_fill;
      mutable bool _M_fill_init;
      basic_streambuf<_CharT, _Traits>* _M_streambuf;


      const __ctype_type* _M_ctype;

      const __num_put_type* _M_num_put;

      const __num_get_type* _M_num_get;

    public:
# 117 "/usr/include/c++/10/bits/basic_ios.h" 3
      explicit operator bool() const
      { return !this->fail(); }





      bool
      operator!() const
      { return this->fail(); }
# 136 "/usr/include/c++/10/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 147 "/usr/include/c++/10/bits/basic_ios.h" 3
      void
      clear(iostate __state = goodbit);







      void
      setstate(iostate __state)
      { this->clear(this->rdstate() | __state); }




      void
      _M_setstate(iostate __state)
      {


 _M_streambuf_state |= __state;
 if (this->exceptions() & __state)
   throw;
      }







      bool
      good() const
      { return this->rdstate() == 0; }







      bool
      eof() const
      { return (this->rdstate() & eofbit) != 0; }
# 200 "/usr/include/c++/10/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 221 "/usr/include/c++/10/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 256 "/usr/include/c++/10/bits/basic_ios.h" 3
      void
      exceptions(iostate __except)
      {
        _M_exception = __except;
        this->clear(_M_streambuf_state);
      }







      explicit
      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
 _M_ctype(0), _M_num_put(0), _M_num_get(0)
      { this->init(__sb); }







      virtual
      ~basic_ios() { }
# 294 "/usr/include/c++/10/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 306 "/usr/include/c++/10/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie(basic_ostream<_CharT, _Traits>* __tiestr)
      {
        basic_ostream<_CharT, _Traits>* __old = _M_tie;
        _M_tie = __tiestr;
        return __old;
      }







      basic_streambuf<_CharT, _Traits>*
      rdbuf() const
      { return _M_streambuf; }
# 346 "/usr/include/c++/10/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 360 "/usr/include/c++/10/bits/basic_ios.h" 3
      basic_ios&
      copyfmt(const basic_ios& __rhs);







      char_type
      fill() const
      {
 if (!_M_fill_init)
   {
     _M_fill = this->widen(' ');
     _M_fill_init = true;
   }
 return _M_fill;
      }
# 389 "/usr/include/c++/10/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = this->fill();
 _M_fill = __ch;
 return __old;
      }
# 409 "/usr/include/c++/10/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 429 "/usr/include/c++/10/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
# 448 "/usr/include/c++/10/bits/basic_ios.h" 3
      char_type
      widen(char __c) const
      { return __check_facet(_M_ctype).widen(__c); }

    protected:







      basic_ios()
      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
 _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
      { }







      void
      init(basic_streambuf<_CharT, _Traits>* __sb);


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

      void
      move(basic_ios& __rhs)
      {
 ios_base::_M_move(__rhs);
 _M_cache_locale(_M_ios_locale);
 this->tie(__rhs.tie(nullptr));
 _M_fill = __rhs._M_fill;
 _M_fill_init = __rhs._M_fill_init;
 _M_streambuf = nullptr;
      }

      void
      move(basic_ios&& __rhs)
      { this->move(__rhs); }

      void
      swap(basic_ios& __rhs) noexcept
      {
 ios_base::_M_swap(__rhs);
 _M_cache_locale(_M_ios_locale);
 __rhs._M_cache_locale(__rhs._M_ios_locale);
 std::swap(_M_tie, __rhs._M_tie);
 std::swap(_M_fill, __rhs._M_fill);
 std::swap(_M_fill_init, __rhs._M_fill_init);
      }

      void
      set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
      { _M_streambuf = __sb; }


      void
      _M_cache_locale(const locale& __loc);
    };


}

# 1 "/usr/include/c++/10/bits/basic_ios.tcc" 1 3
# 33 "/usr/include/c++/10/bits/basic_ios.tcc" 3
       
# 34 "/usr/include/c++/10/bits/basic_ios.tcc" 3

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


  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::clear(iostate __state)
    {
      if (this->rdbuf())
 _M_streambuf_state = __state;
      else
   _M_streambuf_state = __state | badbit;
      if (this->exceptions() & this->rdstate())
 __throw_ios_failure(("basic_ios::clear"));
    }

  template<typename _CharT, typename _Traits>
    basic_streambuf<_CharT, _Traits>*
    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
    {
      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
      _M_streambuf = __sb;
      this->clear();
      return __old;
    }

  template<typename _CharT, typename _Traits>
    basic_ios<_CharT, _Traits>&
    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
    {


      if (this != &__rhs)
 {




   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
                      _M_local_word : new _Words[__rhs._M_word_size];


   _Callback_list* __cb = __rhs._M_callbacks;
   if (__cb)
     __cb->_M_add_reference();
   _M_call_callbacks(erase_event);
   if (_M_word != _M_local_word)
     {
       delete [] _M_word;
       _M_word = 0;
     }
   _M_dispose_callbacks();


   _M_callbacks = __cb;
   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
     __words[__i] = __rhs._M_word[__i];
   _M_word = __words;
   _M_word_size = __rhs._M_word_size;

   this->flags(__rhs.flags());
   this->width(__rhs.width());
   this->precision(__rhs.precision());
   this->tie(__rhs.tie());
   this->fill(__rhs.fill());
   _M_ios_locale = __rhs.getloc();
   _M_cache_locale(_M_ios_locale);

   _M_call_callbacks(copyfmt_event);


   this->exceptions(__rhs.exceptions());
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_locale(__loc);
      if (this->rdbuf() != 0)
 this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();


      _M_cache_locale(_M_ios_locale);
# 146 "/usr/include/c++/10/bits/basic_ios.tcc" 3
      _M_fill = _CharT();
      _M_fill_init = false;

      _M_tie = 0;
      _M_exception = goodbit;
      _M_streambuf = __sb;
      _M_streambuf_state = __sb ? goodbit : badbit;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
    {
      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
 _M_ctype = std::__addressof(use_facet<__ctype_type>(__loc));
      else
 _M_ctype = 0;

      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
 _M_num_put = std::__addressof(use_facet<__num_put_type>(__loc));
      else
 _M_num_put = 0;

      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
 _M_num_get = std::__addressof(use_facet<__num_get_type>(__loc));
      else
 _M_num_get = 0;
    }




  extern template class basic_ios<char>;


  extern template class basic_ios<wchar_t>;




}
# 517 "/usr/include/c++/10/bits/basic_ios.h" 2 3
# 45 "/usr/include/c++/10/ios" 2 3
# 39 "/usr/include/c++/10/ostream" 2 3


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

# 57 "/usr/include/c++/10/ostream" 3
  template<typename _CharT, typename _Traits>
    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
             __num_put_type;
      typedef ctype<_CharT> __ctype_type;
# 83 "/usr/include/c++/10/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 107 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&))
      {



 return __pf(*this);
      }

      __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&))
      {



 __pf(*this);
 return *this;
      }

      __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&))
      {



 __pf(*this);
 return *this;
      }
# 165 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      operator<<(long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(bool __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(short __n);

      __ostream_type&
      operator<<(unsigned short __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }

      __ostream_type&
      operator<<(int __n);

      __ostream_type&
      operator<<(unsigned int __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }


      __ostream_type&
      operator<<(long long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long long __n)
      { return _M_insert(__n); }
# 219 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      operator<<(double __f)
      { return _M_insert(__f); }

      __ostream_type&
      operator<<(float __f)
      {


 return _M_insert(static_cast<double>(__f));
      }

      __ostream_type&
      operator<<(long double __f)
      { return _M_insert(__f); }
# 244 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      operator<<(const void* __p)
      { return _M_insert(__p); }


      __ostream_type&
      operator<<(nullptr_t)
      { return *this << "nullptr"; }
# 275 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 308 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      put(char_type __c);






      void
      _M_write(const char_type* __s, streamsize __n)
      {
 const streamsize __put = this->rdbuf()->sputn(__s, __n);
 if (__put != __n)
   this->setstate(ios_base::badbit);
      }
# 340 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 353 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      flush();
# 363 "/usr/include/c++/10/ostream" 3
      pos_type
      tellp();
# 374 "/usr/include/c++/10/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 386 "/usr/include/c++/10/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

    protected:
      basic_ostream()
      { this->init(0); }



      basic_ostream(basic_iostream<_CharT, _Traits>&) { }

      basic_ostream(const basic_ostream&) = delete;

      basic_ostream(basic_ostream&& __rhs)
      : __ios_type()
      { __ios_type::move(__rhs); }



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

      basic_ostream&
      operator=(basic_ostream&& __rhs)
      {
 swap(__rhs);
 return *this;
      }

      void
      swap(basic_ostream& __rhs)
      { __ios_type::swap(__rhs); }


      template<typename _ValueT>
 __ostream_type&
 _M_insert(_ValueT __v);
    };
# 431 "/usr/include/c++/10/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT, _Traits>& _M_os;

    public:
# 450 "/usr/include/c++/10/ostream" 3
      explicit
      sentry(basic_ostream<_CharT, _Traits>& __os);

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







      ~sentry()
      {

 if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
   {

     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
       _M_os.setstate(ios_base::badbit);
   }
      }
#pragma GCC diagnostic pop
# 482 "/usr/include/c++/10/ostream" 3
      explicit

      operator bool() const
      { return _M_ok; }
    };
# 504 "/usr/include/c++/10/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    { return __ostream_insert(__out, &__c, 1); }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    { return __ostream_insert(__out, &__c, 1); }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }
# 587 "/usr/include/c++/10/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<typename _Traits>
    inline basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }
# 679 "/usr/include/c++/10/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }
# 691 "/usr/include/c++/10/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_CharT()); }






  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }


  template<typename _Ch, typename _Up>
    basic_ostream<_Ch, _Up>&
    __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*);

  template<typename _Tp, typename = void>
    struct __is_convertible_to_basic_ostream_impl
    {
      using __ostream_type = void;
    };

  template<typename _Tp>
    using __do_is_convertible_to_basic_ostream_impl =
    decltype(__is_convertible_to_basic_ostream_test
      (declval<typename remove_reference<_Tp>::type*>()));

  template<typename _Tp>
    struct __is_convertible_to_basic_ostream_impl
    <_Tp,
     __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>>
    {
      using __ostream_type =
 __do_is_convertible_to_basic_ostream_impl<_Tp>;
    };

  template<typename _Tp>
    struct __is_convertible_to_basic_ostream
    : __is_convertible_to_basic_ostream_impl<_Tp>
    {
    public:
      using type = __not_<is_void<
        typename __is_convertible_to_basic_ostream_impl<_Tp>::__ostream_type>>;
      constexpr static bool value = type::value;
    };

  template<typename _Ostream, typename _Tp, typename = void>
    struct __is_insertable : false_type {};

  template<typename _Ostream, typename _Tp>
    struct __is_insertable<_Ostream, _Tp,
      __void_t<decltype(declval<_Ostream&>()
          << declval<const _Tp&>())>>
        : true_type {};

  template<typename _Ostream>
    using __rvalue_ostream_type =
      typename __is_convertible_to_basic_ostream<
 _Ostream>::__ostream_type;
# 765 "/usr/include/c++/10/ostream" 3
  template<typename _Ostream, typename _Tp>
    inline
    typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,
         __is_convertible_to_basic_ostream<_Ostream>,
         __is_insertable<
    __rvalue_ostream_type<_Ostream>,
    const _Tp&>>::value,
         __rvalue_ostream_type<_Ostream>>::type
    operator<<(_Ostream&& __os, const _Tp& __x)
    {
      __rvalue_ostream_type<_Ostream> __ret_os = __os;
      __ret_os << __x;
      return __ret_os;
    }



}

# 1 "/usr/include/c++/10/bits/ostream.tcc" 1 3
# 37 "/usr/include/c++/10/bits/ostream.tcc" 3
       
# 38 "/usr/include/c++/10/bits/ostream.tcc" 3



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


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT, _Traits>& __os)
    : _M_ok(false), _M_os(__os)
    {

      if (__os.tie() && __os.good())
 __os.tie()->flush();

      if (__os.good())
 _M_ok = true;
      else
 __os.setstate(ios_base::failbit);
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_ostream<_CharT, _Traits>&
      basic_ostream<_CharT, _Traits>::
      _M_insert(_ValueT __v)
      {
 sentry __cerb(*this);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::goodbit;
     try
       {
  const __num_put_type& __np = __check_facet(this->_M_num_put);
  if (__np.put(*this, *this, this->fill(), __v).failed())
    __err |= ios_base::badbit;
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(short __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(int __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this);
      if (__cerb && __sbin)
 {
   try
     {
       if (!__copy_streambufs(__sbin, this->rdbuf()))
  __err |= ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbin)
 __err |= ios_base::badbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    put(char_type __c)
    {






      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __put = this->rdbuf()->sputc(__c);
       if (traits_type::eq_int_type(__put, traits_type::eof()))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    write(const _CharT* __s, streamsize __n)
    {







      sentry __cerb(*this);
      if (__cerb)
 {
   try
     { _M_write(__s, __n); }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    flush()
    {



      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
     __err |= ios_base::badbit;
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::
    tellp()
    {
      pos_type __ret = pos_type(-1);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(pos_type __pos)
    {
      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (!this->fail())
     {


       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
            ios_base::out);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __dir)
    {
      ios_base::iostate __err = ios_base::goodbit;
      try
 {
   if (!this->fail())
     {


       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
            ios_base::out);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(__cxxabiv1::__forced_unwind&)
 {
   this->_M_setstate(ios_base::badbit);
   throw;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 {


   const size_t __clen = char_traits<char>::length(__s);
   try
     {
       struct __ptr_guard
       {
  _CharT *__p;
  __ptr_guard (_CharT *__ip): __p(__ip) { }
  ~__ptr_guard() { delete[] __p; }
  _CharT* __get() { return __p; }
       } __pg (new _CharT[__clen]);

       _CharT *__ws = __pg.__get();
       for (size_t __i = 0; __i < __clen; ++__i)
  __ws[__i] = __out.widen(__s[__i]);
       __ostream_insert(__out, __ws, __clen);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
    }




  extern template class basic_ostream<char>;
  extern template ostream& endl(ostream&);
  extern template ostream& ends(ostream&);
  extern template ostream& flush(ostream&);
  extern template ostream& operator<<(ostream&, char);
  extern template ostream& operator<<(ostream&, unsigned char);
  extern template ostream& operator<<(ostream&, signed char);
  extern template ostream& operator<<(ostream&, const char*);
  extern template ostream& operator<<(ostream&, const unsigned char*);
  extern template ostream& operator<<(ostream&, const signed char*);

  extern template ostream& ostream::_M_insert(long);
  extern template ostream& ostream::_M_insert(unsigned long);
  extern template ostream& ostream::_M_insert(bool);

  extern template ostream& ostream::_M_insert(long long);
  extern template ostream& ostream::_M_insert(unsigned long long);

  extern template ostream& ostream::_M_insert(double);
  extern template ostream& ostream::_M_insert(long double);
  extern template ostream& ostream::_M_insert(const void*);


  extern template class basic_ostream<wchar_t>;
  extern template wostream& endl(wostream&);
  extern template wostream& ends(wostream&);
  extern template wostream& flush(wostream&);
  extern template wostream& operator<<(wostream&, wchar_t);
  extern template wostream& operator<<(wostream&, char);
  extern template wostream& operator<<(wostream&, const wchar_t*);
  extern template wostream& operator<<(wostream&, const char*);

  extern template wostream& wostream::_M_insert(long);
  extern template wostream& wostream::_M_insert(unsigned long);
  extern template wostream& wostream::_M_insert(bool);

  extern template wostream& wostream::_M_insert(long long);
  extern template wostream& wostream::_M_insert(unsigned long long);

  extern template wostream& wostream::_M_insert(double);
  extern template wostream& wostream::_M_insert(long double);
  extern template wostream& wostream::_M_insert(const void*);




}
# 785 "/usr/include/c++/10/ostream" 2 3
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_io.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_io.hpp" 3 4
namespace boost
{
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range_io.hpp" 3 4
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/iterator_range.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/as_literal.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/str_types.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/detail/str_types.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_mutable_iterator<T*>
    {
        typedef T* type;
    };

    template< class T >
    struct range_const_iterator<T*>
    {
        typedef const T* type;
    };

    template< class T >
    struct range_size<T*>
    {
       typedef std::size_t type;
    };
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/as_literal.hpp" 2 3 4



# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/as_literal.hpp" 2 3 4

# 1 "/usr/include/c++/10/cwchar" 1 3 4
# 39 "/usr/include/c++/10/cwchar" 3 4
       
# 40 "/usr/include/c++/10/cwchar" 3
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/as_literal.hpp" 2 3 4


namespace boost
{
    namespace range_detail
    {
        inline std::size_t length( const char* s )
        {
            return strlen( s );
        }


        inline std::size_t length( const wchar_t* s )
        {
            return wcslen( s );
        }
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/as_literal.hpp" 3 4
        inline bool is_char_ptr( char* )
        {
            return true;
        }

        inline bool is_char_ptr( const char* )
        {
            return true;
        }


        inline bool is_char_ptr( wchar_t* )
        {
            return true;
        }

        inline bool is_char_ptr( const wchar_t* )
        {
            return true;
        }


        template< class T >
        inline long is_char_ptr( const T& )
        {
            return 0L;
        }

        template< class T >
        inline iterator_range<T*>
        make_range( T* const r, bool )
        {
            return iterator_range<T*>( r, r + length(r) );
        }

        template< class T >
        inline iterator_range<typename range_iterator<T>::type>
        make_range( T& r, long )
        {
            return boost::make_iterator_range( r );
        }

    }

    template< class Range >
    inline iterator_range<typename range_iterator<Range>::type>
    as_literal( Range& r )
    {
        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
    }

    template< class Range >
    inline iterator_range<typename range_iterator<const Range>::type>
    as_literal( const Range& r )
    {
        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
    }

    template< class Char, std::size_t sz >
    inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
    {
        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
    }

    template< class Char, std::size_t sz >
    inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
    {
        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
    }
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/compare.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/compare.hpp" 3 4
# 1 "/usr/include/c++/10/locale" 1 3 4
# 36 "/usr/include/c++/10/locale" 3 4
       
# 37 "/usr/include/c++/10/locale" 3




# 1 "/usr/include/c++/10/bits/locale_facets_nonio.h" 1 3
# 37 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
       
# 38 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3

# 1 "/usr/include/c++/10/ctime" 1 3
# 39 "/usr/include/c++/10/ctime" 3
       
# 40 "/usr/include/c++/10/ctime" 3
# 58 "/usr/include/c++/10/ctime" 3
namespace std
{
  using ::clock_t;
  using ::time_t;
  using ::tm;

  using ::clock;
  using ::difftime;
  using ::mktime;
  using ::time;
  using ::asctime;
  using ::ctime;
  using ::gmtime;
  using ::localtime;
  using ::strftime;
}



namespace std
{
  using ::timespec;
  using ::timespec_get;
}
# 40 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3

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

# 52 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT>
    struct __timepunct_cache : public locale::facet
    {

      static const _CharT* _S_timezones[14];

      const _CharT* _M_date_format;
      const _CharT* _M_date_era_format;
      const _CharT* _M_time_format;
      const _CharT* _M_time_era_format;
      const _CharT* _M_date_time_format;
      const _CharT* _M_date_time_era_format;
      const _CharT* _M_am;
      const _CharT* _M_pm;
      const _CharT* _M_am_pm_format;


      const _CharT* _M_day1;
      const _CharT* _M_day2;
      const _CharT* _M_day3;
      const _CharT* _M_day4;
      const _CharT* _M_day5;
      const _CharT* _M_day6;
      const _CharT* _M_day7;


      const _CharT* _M_aday1;
      const _CharT* _M_aday2;
      const _CharT* _M_aday3;
      const _CharT* _M_aday4;
      const _CharT* _M_aday5;
      const _CharT* _M_aday6;
      const _CharT* _M_aday7;


      const _CharT* _M_month01;
      const _CharT* _M_month02;
      const _CharT* _M_month03;
      const _CharT* _M_month04;
      const _CharT* _M_month05;
      const _CharT* _M_month06;
      const _CharT* _M_month07;
      const _CharT* _M_month08;
      const _CharT* _M_month09;
      const _CharT* _M_month10;
      const _CharT* _M_month11;
      const _CharT* _M_month12;


      const _CharT* _M_amonth01;
      const _CharT* _M_amonth02;
      const _CharT* _M_amonth03;
      const _CharT* _M_amonth04;
      const _CharT* _M_amonth05;
      const _CharT* _M_amonth06;
      const _CharT* _M_amonth07;
      const _CharT* _M_amonth08;
      const _CharT* _M_amonth09;
      const _CharT* _M_amonth10;
      const _CharT* _M_amonth11;
      const _CharT* _M_amonth12;

      bool _M_allocated;

      __timepunct_cache(size_t __refs = 0) : facet(__refs),
      _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
      _M_time_era_format(0), _M_date_time_format(0),
      _M_date_time_era_format(0), _M_am(0), _M_pm(0),
      _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
      _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
      _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
      _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
      _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
      _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
      _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
      _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
      _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
      _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
      _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
      { }

      ~__timepunct_cache();

    private:
      __timepunct_cache&
      operator=(const __timepunct_cache&);

      explicit
      __timepunct_cache(const __timepunct_cache&);
    };

  template<typename _CharT>
    __timepunct_cache<_CharT>::~__timepunct_cache()
    {
      if (_M_allocated)
 {

 }
    }


  template<>
    const char*
    __timepunct_cache<char>::_S_timezones[14];


  template<>
    const wchar_t*
    __timepunct_cache<wchar_t>::_S_timezones[14];



  template<typename _CharT>
    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];

  template<typename _CharT>
    class __timepunct : public locale::facet
    {
    public:

      typedef _CharT __char_type;
      typedef __timepunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;
      __c_locale _M_c_locale_timepunct;
      const char* _M_name_timepunct;

    public:

      static locale::id id;

      explicit
      __timepunct(size_t __refs = 0);

      explicit
      __timepunct(__cache_type* __cache, size_t __refs = 0);
# 206 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);



      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
      const tm* __tm) const throw ();

      void
      _M_date_formats(const _CharT** __date) const
      {

 __date[0] = _M_data->_M_date_format;
 __date[1] = _M_data->_M_date_era_format;
      }

      void
      _M_time_formats(const _CharT** __time) const
      {

 __time[0] = _M_data->_M_time_format;
 __time[1] = _M_data->_M_time_era_format;
      }

      void
      _M_date_time_formats(const _CharT** __dt) const
      {

 __dt[0] = _M_data->_M_date_time_format;
 __dt[1] = _M_data->_M_date_time_era_format;
      }


      void
      _M_am_pm_format(const _CharT*) const
      { }


      void
      _M_am_pm(const _CharT** __ampm) const
      {
 __ampm[0] = _M_data->_M_am;
 __ampm[1] = _M_data->_M_pm;
      }

      void
      _M_days(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_day1;
 __days[1] = _M_data->_M_day2;
 __days[2] = _M_data->_M_day3;
 __days[3] = _M_data->_M_day4;
 __days[4] = _M_data->_M_day5;
 __days[5] = _M_data->_M_day6;
 __days[6] = _M_data->_M_day7;
      }

      void
      _M_days_abbreviated(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_aday1;
 __days[1] = _M_data->_M_aday2;
 __days[2] = _M_data->_M_aday3;
 __days[3] = _M_data->_M_aday4;
 __days[4] = _M_data->_M_aday5;
 __days[5] = _M_data->_M_aday6;
 __days[6] = _M_data->_M_aday7;
      }

      void
      _M_months(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_month01;
 __months[1] = _M_data->_M_month02;
 __months[2] = _M_data->_M_month03;
 __months[3] = _M_data->_M_month04;
 __months[4] = _M_data->_M_month05;
 __months[5] = _M_data->_M_month06;
 __months[6] = _M_data->_M_month07;
 __months[7] = _M_data->_M_month08;
 __months[8] = _M_data->_M_month09;
 __months[9] = _M_data->_M_month10;
 __months[10] = _M_data->_M_month11;
 __months[11] = _M_data->_M_month12;
      }

      void
      _M_months_abbreviated(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_amonth01;
 __months[1] = _M_data->_M_amonth02;
 __months[2] = _M_data->_M_amonth03;
 __months[3] = _M_data->_M_amonth04;
 __months[4] = _M_data->_M_amonth05;
 __months[5] = _M_data->_M_amonth06;
 __months[6] = _M_data->_M_amonth07;
 __months[7] = _M_data->_M_amonth08;
 __months[8] = _M_data->_M_amonth09;
 __months[9] = _M_data->_M_amonth10;
 __months[10] = _M_data->_M_amonth11;
 __months[11] = _M_data->_M_amonth12;
      }

    protected:
      virtual
      ~__timepunct();


      void
      _M_initialize_timepunct(__c_locale __cloc = 0);
    };

  template<typename _CharT>
    locale::id __timepunct<_CharT>::id;


  template<>
    void
    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();


  template<>
    void
    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
     const tm*) const throw ();



}


# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/time_members.h" 1 3
# 37 "/usr/include/c++/10/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);
    }


}
# 347 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3

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


namespace __cxx11 {
# 367 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;



      static locale::id id;
# 388 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 405 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 429 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      get_time(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 454 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      get_date(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 482 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 511 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 537 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      get_year(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_year(__beg, __end, __io, __err, __tm); }
# 558 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      inline
      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
                    ios_base::iostate& __err, tm* __tm, char __format,
                    char __modifier = 0) const
      {
        return this->do_get(__s, __end, __io, __err, __tm, __format,
                            __modifier);
      }
# 585 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
                    ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
                    const char_type* __fmtend) const;


    protected:

      virtual
      ~time_get() { }
# 605 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual dateorder
      do_date_order() const;
# 623 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 642 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 661 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
       ios_base::iostate& __err, tm* __tm) const;
# 680 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
         ios_base::iostate& __err, tm* __tm) const;
# 699 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 722 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual

      iter_type
      do_get(iter_type __s, iter_type __end, ios_base& __f,
             ios_base::iostate& __err, tm* __tm,
             char __format, char __modifier) const;



      iter_type
      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
       int __min, int __max, size_t __len,
       ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
          const _CharT** __names, size_t __indexlen,
          ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
       ios_base::iostate& __err, tm* __tm,
       const _CharT* __format) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;


  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }


      explicit
      time_get_byname(const string& __s, size_t __refs = 0)
      : time_get_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~time_get_byname() { }
    };

}
# 796 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 817 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 836 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
   const _CharT* __beg, const _CharT* __end) const;
# 856 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const tm* __tm, char __format, char __mod = 0) const
      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }

    protected:

      virtual
      ~time_put()
      { }
# 883 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
      char __format, char __mod) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;


  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char*, size_t __refs = 0)
      : time_put<_CharT, _OutIter>(__refs)
      { }


      explicit
      time_put_byname(const string& __s, size_t __refs = 0)
      : time_put_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~time_put_byname() { }
    };
# 928 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  class money_base
  {
  public:
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;

    enum
    {
      _S_minus,
      _S_zero,
      _S_end = 11
    };



    static const char* _S_atoms;



    __attribute__ ((__const__)) static pattern
    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
  };

  template<typename _CharT, bool _Intl>
    struct __moneypunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;
      const _CharT* _M_curr_symbol;
      size_t _M_curr_symbol_size;
      const _CharT* _M_positive_sign;
      size_t _M_positive_sign_size;
      const _CharT* _M_negative_sign;
      size_t _M_negative_sign_size;
      int _M_frac_digits;
      money_base::pattern _M_pos_format;
      money_base::pattern _M_neg_format;




      _CharT _M_atoms[money_base::_S_end];

      bool _M_allocated;

      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
      _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
      _M_curr_symbol(0), _M_curr_symbol_size(0),
      _M_positive_sign(0), _M_positive_sign_size(0),
      _M_negative_sign(0), _M_negative_sign_size(0),
      _M_frac_digits(0),
      _M_pos_format(money_base::pattern()),
      _M_neg_format(money_base::pattern()), _M_allocated(false)
      { }

      ~__moneypunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __moneypunct_cache&
      operator=(const __moneypunct_cache&);

      explicit
      __moneypunct_cache(const __moneypunct_cache&);
    };

  template<typename _CharT, bool _Intl>
    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_curr_symbol;
   delete [] _M_positive_sign;
   delete [] _M_negative_sign;
 }
    }

namespace __cxx11 {
# 1023 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  template<typename _CharT, bool _Intl>
    class moneypunct : public locale::facet, public money_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

    private:
      __cache_type* _M_data;

    public:


      static const bool intl = _Intl;

      static locale::id id;
# 1052 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_moneypunct(); }
# 1065 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 1080 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_moneypunct(__cloc, __s); }
# 1094 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1107 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1137 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1150 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 1167 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 1184 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 1200 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 1236 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }


    protected:

      virtual
      ~moneypunct();
# 1258 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1270 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1283 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1296 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 1309 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 1322 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 1336 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 1350 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 1364 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_neg_format() const
      { return _M_data->_M_neg_format; }


       void
       _M_initialize_moneypunct(__c_locale __cloc = 0,
    const char* __name = 0);
    };

  template<typename _CharT, bool _Intl>
    locale::id moneypunct<_CharT, _Intl>::id;

  template<typename _CharT, bool _Intl>
    const bool moneypunct<_CharT, _Intl>::intl;

  template<>
    moneypunct<char, true>::~moneypunct();

  template<>
    moneypunct<char, false>::~moneypunct();

  template<>
    void
    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);

  template<>
    void
    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);


  template<>
    moneypunct<wchar_t, true>::~moneypunct();

  template<>
    moneypunct<wchar_t, false>::~moneypunct();

  template<>
    void
    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
       const char*);

  template<>
    void
    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
        const char*);



  template<typename _CharT, bool _Intl>
    class moneypunct_byname : public moneypunct<_CharT, _Intl>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;

      explicit
      moneypunct_byname(const char* __s, size_t __refs = 0)
      : moneypunct<_CharT, _Intl>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_moneypunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }


      explicit
      moneypunct_byname(const string& __s, size_t __refs = 0)
      : moneypunct_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~moneypunct_byname() { }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;

}

namespace __cxx11 {
# 1467 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class money_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1489 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 1519 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, long double& __units) const
      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 1550 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, string_type& __digits) const
      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }

    protected:

      virtual
      ~money_get() { }
# 1574 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, long double& __units) const;
# 1586 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, string_type& __digits) const;
# 1598 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, string& __digits) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;
# 1620 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:


      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1641 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 1661 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, long double __units) const
      { return this->do_put(__s, __intl, __io, __fill, __units); }
# 1684 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, const string_type& __digits) const
      { return this->do_put(__s, __intl, __io, __fill, __digits); }

    protected:

      virtual
      ~money_put() { }
# 1719 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      long double __units) const;
# 1743 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      const string_type& __digits) const;
# 1755 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
    const string_type& __digits) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;

}





  struct messages_base
  {
    typedef int catalog;
  };

namespace __cxx11 {
# 1798 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_messages;
      const char* _M_name_messages;

    public:

      static locale::id id;
# 1826 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      messages(size_t __refs = 0);
# 1840 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1853 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 1871 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 1889 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }
# 1900 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 1920 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 1939 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_get(catalog, int, int, const string_type& __dfault) const;






      virtual void
      do_close(catalog) const;


      char*
      _M_convert_to_char(const string_type& __msg) const
      {

 return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
      }


      string_type
      _M_convert_from_char(char*) const
      {

 return string_type();
      }
     };

  template<typename _CharT>
    locale::id messages<_CharT>::id;


  template<>
    string
    messages<char>::do_get(catalog, int, int, const string&) const;


  template<>
    wstring
    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;



   template<typename _CharT>
    class messages_byname : public messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      messages_byname(const char* __s, size_t __refs = 0);


      explicit
      messages_byname(const string& __s, size_t __refs = 0)
      : messages_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~messages_byname()
      { }
    };

}


}


# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/messages_members.h" 1 3
# 36 "/usr/include/c++/10/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)
     throw () __attribute__ ((__format_arg__ (1)));



extern char *dgettext (const char *__domainname, const char *__msgid)
     throw () __attribute__ ((__format_arg__ (2)));
extern char *__dgettext (const char *__domainname, const char *__msgid)
     throw () __attribute__ ((__format_arg__ (2)));



extern char *dcgettext (const char *__domainname,
   const char *__msgid, int __category)
     throw () __attribute__ ((__format_arg__ (2)));
extern char *__dcgettext (const char *__domainname,
     const char *__msgid, int __category)
     throw () __attribute__ ((__format_arg__ (2)));




extern char *ngettext (const char *__msgid1, const char *__msgid2,
         unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));



extern char *dngettext (const char *__domainname, const char *__msgid1,
   const char *__msgid2, unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));



extern char *dcngettext (const char *__domainname, const char *__msgid1,
    const char *__msgid2, unsigned long int __n,
    int __category)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));





extern char *textdomain (const char *__domainname) throw ();



extern char *bindtextdomain (const char *__domainname,
        const char *__dirname) throw ();



extern char *bind_textdomain_codeset (const char *__domainname,
          const char *__codeset) throw ();
# 121 "/usr/include/libintl.h" 3 4
}
# 37 "/usr/include/c++/10/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;



}
# 2011 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3


# 1 "/usr/include/c++/10/bits/codecvt.h" 1 3
# 39 "/usr/include/c++/10/bits/codecvt.h" 3
       
# 40 "/usr/include/c++/10/bits/codecvt.h" 3

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



  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 67 "/usr/include/c++/10/bits/codecvt.h" 3
  template<typename _InternT, typename _ExternT, typename _StateT>
    class __codecvt_abstract_base
    : public locale::facet, public codecvt_base
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;
# 115 "/usr/include/c++/10/bits/codecvt.h" 3
      result
      out(state_type& __state, const intern_type* __from,
   const intern_type* __from_end, const intern_type*& __from_next,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const
      {
 return this->do_out(__state, __from, __from_end, __from_next,
       __to, __to_end, __to_next);
      }
# 154 "/usr/include/c++/10/bits/codecvt.h" 3
      result
      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
       extern_type*& __to_next) const
      { return this->do_unshift(__state, __to,__to_end,__to_next); }
# 195 "/usr/include/c++/10/bits/codecvt.h" 3
      result
      in(state_type& __state, const extern_type* __from,
  const extern_type* __from_end, const extern_type*& __from_next,
  intern_type* __to, intern_type* __to_end,
  intern_type*& __to_next) const
      {
 return this->do_in(__state, __from, __from_end, __from_next,
      __to, __to_end, __to_next);
      }

      int
      encoding() const throw()
      { return this->do_encoding(); }

      bool
      always_noconv() const throw()
      { return this->do_always_noconv(); }

      int
      length(state_type& __state, const extern_type* __from,
      const extern_type* __end, size_t __max) const
      { return this->do_length(__state, __from, __end, __max); }

      int
      max_length() const throw()
      { return this->do_max_length(); }

    protected:
      explicit
      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~__codecvt_abstract_base() { }
# 236 "/usr/include/c++/10/bits/codecvt.h" 3
      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const = 0;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const = 0;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const = 0;

      virtual int
      do_encoding() const throw() = 0;

      virtual bool
      do_always_noconv() const throw() = 0;

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const = 0;

      virtual int
      do_max_length() const throw() = 0;
    };
# 273 "/usr/include/c++/10/bits/codecvt.h" 3
   template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt
    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
 _M_c_locale_codecvt(0)
      { }

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;


  template<>
    class codecvt<char, char, mbstate_t>
    : public __codecvt_abstract_base<char, char, mbstate_t>
    {
      friend class messages<char>;

    public:

      typedef char intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };






  template<>
    class codecvt<wchar_t, char, mbstate_t>
    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
    {
      friend class messages<wchar_t>;

    public:

      typedef wchar_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };







  template<>
    class codecvt<char16_t, char, mbstate_t>
    : public __codecvt_abstract_base<char16_t, char, mbstate_t>
    {
    public:

      typedef char16_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };





  template<>
    class codecvt<char32_t, char, mbstate_t>
    : public __codecvt_abstract_base<char32_t, char, mbstate_t>
    {
    public:

      typedef char32_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };
# 695 "/usr/include/c++/10/bits/codecvt.h" 3
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char* __s, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
   }
      }


      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~codecvt_byname() { }
    };


  template<>
    class codecvt_byname<char16_t, char, mbstate_t>
    : public codecvt<char16_t, char, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char16_t, char, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };

  template<>
    class codecvt_byname<char32_t, char, mbstate_t>
    : public codecvt<char32_t, char, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char32_t, char, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };
# 802 "/usr/include/c++/10/bits/codecvt.h" 3
  extern template class codecvt_byname<char, char, mbstate_t>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);


  extern template class codecvt_byname<wchar_t, char, mbstate_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);



  extern template class codecvt_byname<char16_t, char, mbstate_t>;
  extern template class codecvt_byname<char32_t, char, mbstate_t>;
# 837 "/usr/include/c++/10/bits/codecvt.h" 3

}
# 2014 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3

# 1 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 1 3
# 33 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3
       
# 34 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3

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


  template<typename _CharT, bool _Intl>
    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
    {
      const __moneypunct_cache<_CharT, _Intl>*
      operator() (const locale& __loc) const
      {
 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
     try
       {
  __tmp = new __moneypunct_cache<_CharT, _Intl>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<
   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
      }
    };

  template<typename _CharT, bool _Intl>
    void
    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
    {
      const moneypunct<_CharT, _Intl>& __mp =
 use_facet<moneypunct<_CharT, _Intl> >(__loc);

      _M_decimal_point = __mp.decimal_point();
      _M_thousands_sep = __mp.thousands_sep();
      _M_frac_digits = __mp.frac_digits();

      char* __grouping = 0;
      _CharT* __curr_symbol = 0;
      _CharT* __positive_sign = 0;
      _CharT* __negative_sign = 0;
      try
 {
   const string& __g = __mp.grouping();
   _M_grouping_size = __g.size();
   __grouping = new char[_M_grouping_size];
   __g.copy(__grouping, _M_grouping_size);
   _M_use_grouping = (_M_grouping_size
        && static_cast<signed char>(__grouping[0]) > 0
        && (__grouping[0]
     != __gnu_cxx::__numeric_traits<char>::__max));

   const basic_string<_CharT>& __cs = __mp.curr_symbol();
   _M_curr_symbol_size = __cs.size();
   __curr_symbol = new _CharT[_M_curr_symbol_size];
   __cs.copy(__curr_symbol, _M_curr_symbol_size);

   const basic_string<_CharT>& __ps = __mp.positive_sign();
   _M_positive_sign_size = __ps.size();
   __positive_sign = new _CharT[_M_positive_sign_size];
   __ps.copy(__positive_sign, _M_positive_sign_size);

   const basic_string<_CharT>& __ns = __mp.negative_sign();
   _M_negative_sign_size = __ns.size();
   __negative_sign = new _CharT[_M_negative_sign_size];
   __ns.copy(__negative_sign, _M_negative_sign_size);

   _M_pos_format = __mp.pos_format();
   _M_neg_format = __mp.neg_format();

   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
   __ct.widen(money_base::_S_atoms,
       money_base::_S_atoms + money_base::_S_end, _M_atoms);

   _M_grouping = __grouping;
   _M_curr_symbol = __curr_symbol;
   _M_positive_sign = __positive_sign;
   _M_negative_sign = __negative_sign;
   _M_allocated = true;
 }
      catch(...)
 {
   delete [] __grouping;
   delete [] __curr_symbol;
   delete [] __positive_sign;
   delete [] __negative_sign;
   throw;
 }
    }

namespace __cxx11 {

  template<typename _CharT, typename _InIter>
    template<bool _Intl>
      _InIter
      money_get<_CharT, _InIter>::
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, string& __units) const
      {
 typedef char_traits<_CharT> __traits_type;
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;


 bool __negative = false;

 size_type __sign_size = 0;

 const bool __mandatory_sign = (__lc->_M_positive_sign_size
           && __lc->_M_negative_sign_size);

 string __grouping_tmp;
 if (__lc->_M_use_grouping)
   __grouping_tmp.reserve(32);

 int __last_pos = 0;

 int __n = 0;

 bool __testvalid = true;

 bool __testdecfound = false;


 string __res;
 __res.reserve(32);

 const char_type* __lit_zero = __lit + money_base::_S_zero;
 const money_base::pattern __p = __lc->_M_neg_format;
 for (int __i = 0; __i < 4 && __testvalid; ++__i)
   {
     const part __which = static_cast<part>(__p.field[__i]);
     switch (__which)
       {
       case money_base::symbol:




  if (__io.flags() & ios_base::showbase || __sign_size > 1
      || __i == 0
      || (__i == 1 && (__mandatory_sign
         || (static_cast<part>(__p.field[0])
      == money_base::sign)
         || (static_cast<part>(__p.field[2])
      == money_base::space)))
      || (__i == 2 && ((static_cast<part>(__p.field[3])
          == money_base::value)
         || (__mandatory_sign
      && (static_cast<part>(__p.field[3])
          == money_base::sign)))))
    {
      const size_type __len = __lc->_M_curr_symbol_size;
      size_type __j = 0;
      for (; __beg != __end && __j < __len
      && *__beg == __lc->_M_curr_symbol[__j];
    ++__beg, (void)++__j);
      if (__j != __len
   && (__j || __io.flags() & ios_base::showbase))
        __testvalid = false;
    }
  break;
       case money_base::sign:

  if (__lc->_M_positive_sign_size && __beg != __end
      && *__beg == __lc->_M_positive_sign[0])
    {
      __sign_size = __lc->_M_positive_sign_size;
      ++__beg;
    }
  else if (__lc->_M_negative_sign_size && __beg != __end
    && *__beg == __lc->_M_negative_sign[0])
    {
      __negative = true;
      __sign_size = __lc->_M_negative_sign_size;
      ++__beg;
    }
  else if (__lc->_M_positive_sign_size
    && !__lc->_M_negative_sign_size)


    __negative = true;
  else if (__mandatory_sign)
    __testvalid = false;
  break;
       case money_base::value:


  for (; __beg != __end; ++__beg)
    {
      const char_type __c = *__beg;
      const char_type* __q = __traits_type::find(__lit_zero,
              10, __c);
      if (__q != 0)
        {
   __res += money_base::_S_atoms[__q - __lit];
   ++__n;
        }
      else if (__c == __lc->_M_decimal_point
        && !__testdecfound)
        {
   if (__lc->_M_frac_digits <= 0)
     break;

   __last_pos = __n;
   __n = 0;
   __testdecfound = true;
        }
      else if (__lc->_M_use_grouping
        && __c == __lc->_M_thousands_sep
        && !__testdecfound)
        {
   if (__n)
     {

       __grouping_tmp += static_cast<char>(__n);
       __n = 0;
     }
   else
     {
       __testvalid = false;
       break;
     }
        }
      else
        break;
    }
  if (__res.empty())
    __testvalid = false;
  break;
       case money_base::space:

  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
    ++__beg;
  else
    __testvalid = false;

       case money_base::none:

  if (__i != 3)
    for (; __beg != __end
    && __ctype.is(ctype_base::space, *__beg); ++__beg);
  break;
       }
   }


 if (__sign_size > 1 && __testvalid)
   {
     const char_type* __sign = __negative ? __lc->_M_negative_sign
                                          : __lc->_M_positive_sign;
     size_type __i = 1;
     for (; __beg != __end && __i < __sign_size
     && *__beg == __sign[__i]; ++__beg, (void)++__i);

     if (__i != __sign_size)
       __testvalid = false;
   }

 if (__testvalid)
   {

     if (__res.size() > 1)
       {
  const size_type __first = __res.find_first_not_of('0');
  const bool __only_zeros = __first == string::npos;
  if (__first)
    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
       }


     if (__negative && __res[0] != '0')
       __res.insert(__res.begin(), '-');


     if (__grouping_tmp.size())
       {

  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                         : __n);
  if (!std::__verify_grouping(__lc->_M_grouping,
         __lc->_M_grouping_size,
         __grouping_tmp))
    __err |= ios_base::failbit;
       }


     if (__testdecfound && __n != __lc->_M_frac_digits)
       __testvalid = false;
   }


 if (!__testvalid)
   __err |= ios_base::failbit;
 else
   __units.swap(__res);


 if (__beg == __end)
   __err |= ios_base::eofbit;
 return __beg;
      }
# 368 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, long double& __units) const
    {
      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, string_type& __digits) const
    {
      typedef typename string::size_type size_type;

      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      const size_type __len = __str.size();
      if (__len)
 {
   __digits.resize(__len);
   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
 }
      return __beg;
    }

  template<typename _CharT, typename _OutIter>
    template<bool _Intl>
      _OutIter
      money_put<_CharT, _OutIter>::
      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
  const string_type& __digits) const
      {
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;



 const char_type* __beg = __digits.data();

 money_base::pattern __p;
 const char_type* __sign;
 size_type __sign_size;
 if (!(*__beg == __lit[money_base::_S_minus]))
   {
     __p = __lc->_M_pos_format;
     __sign = __lc->_M_positive_sign;
     __sign_size = __lc->_M_positive_sign_size;
   }
 else
   {
     __p = __lc->_M_neg_format;
     __sign = __lc->_M_negative_sign;
     __sign_size = __lc->_M_negative_sign_size;
     if (__digits.size())
       ++__beg;
   }


 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
        __beg + __digits.size()) - __beg;
 if (__len)
   {



     string_type __value;
     __value.reserve(2 * __len);



     long __paddec = __len - __lc->_M_frac_digits;
     if (__paddec > 0)
         {
  if (__lc->_M_frac_digits < 0)
    __paddec = __len;
    if (__lc->_M_grouping_size)
      {
      __value.assign(2 * __paddec, char_type());
       _CharT* __vend =
        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
       __lc->_M_grouping,
       __lc->_M_grouping_size,
       __beg, __beg + __paddec);
      __value.erase(__vend - &__value[0]);
      }
    else
    __value.assign(__beg, __paddec);
       }


     if (__lc->_M_frac_digits > 0)
       {
  __value += __lc->_M_decimal_point;
  if (__paddec >= 0)
    __value.append(__beg + __paddec, __lc->_M_frac_digits);
  else
    {

      __value.append(-__paddec, __lit[money_base::_S_zero]);
      __value.append(__beg, __len);
    }
         }


     const ios_base::fmtflags __f = __io.flags()
                                    & ios_base::adjustfield;
     __len = __value.size() + __sign_size;
     __len += ((__io.flags() & ios_base::showbase)
        ? __lc->_M_curr_symbol_size : 0);

     string_type __res;
     __res.reserve(2 * __len);

     const size_type __width = static_cast<size_type>(__io.width());
     const bool __testipad = (__f == ios_base::internal
         && __len < __width);

     for (int __i = 0; __i < 4; ++__i)
       {
  const part __which = static_cast<part>(__p.field[__i]);
  switch (__which)
    {
    case money_base::symbol:
      if (__io.flags() & ios_base::showbase)
        __res.append(__lc->_M_curr_symbol,
       __lc->_M_curr_symbol_size);
      break;
    case money_base::sign:



      if (__sign_size)
        __res += __sign[0];
      break;
    case money_base::value:
      __res += __value;
      break;
    case money_base::space:



      if (__testipad)
        __res.append(__width - __len, __fill);
      else
        __res += __fill;
      break;
    case money_base::none:
      if (__testipad)
        __res.append(__width - __len, __fill);
      break;
    }
       }


     if (__sign_size > 1)
       __res.append(__sign + 1, __sign_size - 1);


     __len = __res.size();
     if (__width > __len)
       {
  if (__f == ios_base::left)

    __res.append(__width - __len, __fill);
  else

    __res.insert(0, __width - __len, __fill);
  __len = __width;
       }


     __s = std::__write(__s, __res.data(), __len);
   }
 __io.width(0);
 return __s;
      }
# 574 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    long double __units) const
    {
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __cs_size = 64;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));


      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);

      if (__len >= __cs_size)
 {
   __cs_size = __len + 1;
   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);
 }
# 606 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3
      string_type __digits(__len, char_type());
      __ctype.widen(__cs, __cs + __len, &__digits[0]);
      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits);
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    const string_type& __digits) const
    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits); }

}




  template<typename _CharT, typename _InIter>
    time_base::dateorder
    time_get<_CharT, _InIter>::do_date_order() const
    { return time_base::no_order; }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const size_t __len = char_traits<_CharT>::length(__format);

      ios_base::iostate __tmperr = ios_base::goodbit;
      size_t __i = 0;
      for (; __beg != __end && __i < __len && !__tmperr; ++__i)
 {
   if (__ctype.narrow(__format[__i], 0) == '%')
     {

       char __c = __ctype.narrow(__format[++__i], 0);
       int __mem = 0;
       if (__c == 'E' || __c == 'O')
  __c = __ctype.narrow(__format[++__i], 0);
       switch (__c)
  {
    const char* __cs;
    _CharT __wcs[10];
  case 'a':

    const char_type* __days1[7];
    __tp._M_days_abbreviated(__days1);
    __beg = _M_extract_name(__beg, __end, __mem, __days1,
       7, __io, __tmperr);
    if (!__tmperr)
      __tm->tm_wday = __mem;
    break;
  case 'A':

    const char_type* __days2[7];
    __tp._M_days(__days2);
    __beg = _M_extract_name(__beg, __end, __mem, __days2,
       7, __io, __tmperr);
    if (!__tmperr)
      __tm->tm_wday = __mem;
    break;
  case 'h':
  case 'b':

    const char_type* __months1[12];
    __tp._M_months_abbreviated(__months1);
    __beg = _M_extract_name(__beg, __end, __mem,
       __months1, 12, __io, __tmperr);
    if (!__tmperr)
      __tm->tm_mon = __mem;
    break;
  case 'B':

    const char_type* __months2[12];
    __tp._M_months(__months2);
    __beg = _M_extract_name(__beg, __end, __mem,
       __months2, 12, __io, __tmperr);
    if (!__tmperr)
      __tm->tm_mon = __mem;
    break;
  case 'c':

    const char_type* __dt[2];
    __tp._M_date_time_formats(__dt);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dt[0]);
    break;
  case 'd':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_mday = __mem;
    break;
  case 'e':


    if (__ctype.is(ctype_base::space, *__beg))
      __beg = _M_extract_num(++__beg, __end, __mem, 1, 9,
        1, __io, __tmperr);
    else
      __beg = _M_extract_num(__beg, __end, __mem, 10, 31,
        2, __io, __tmperr);
    if (!__tmperr)
      __tm->tm_mday = __mem;
    break;
  case 'D':

    __cs = "%m/%d/%y";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'H':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 23, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_hour = __mem;
    break;
  case 'I':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_hour = __mem;
    break;
  case 'm':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_mon = __mem - 1;
    break;
  case 'M':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 59, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_min = __mem;
    break;
  case 'n':
    if (__ctype.narrow(*__beg, 0) == '\n')
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  case 'R':

    __cs = "%H:%M";
    __ctype.widen(__cs, __cs + 6, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'S':



    __beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2,



      __io, __tmperr);
    if (!__tmperr)
    __tm->tm_sec = __mem;
    break;
  case 't':
    if (__ctype.narrow(*__beg, 0) == '\t')
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  case 'T':

    __cs = "%H:%M:%S";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs);
    break;
  case 'x':

    const char_type* __dates[2];
    __tp._M_date_formats(__dates);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dates[0]);
    break;
  case 'X':

    const char_type* __times[2];
    __tp._M_time_formats(__times);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __times[0]);
    break;
  case 'y':
  case 'C':

  case 'Y':




    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
    break;
  case 'Z':

    if (__ctype.is(ctype_base::upper, *__beg))
      {
        int __tmp;
        __beg = _M_extract_name(__beg, __end, __tmp,
           __timepunct_cache<_CharT>::_S_timezones,
           14, __io, __tmperr);


        if (__beg != __end && !__tmperr && __tmp == 0
     && (*__beg == __ctype.widen('-')
         || *__beg == __ctype.widen('+')))
   {
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
       __io, __tmperr);
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
       __io, __tmperr);
   }
      }
    else
      __tmperr |= ios_base::failbit;
    break;
  default:

    __tmperr |= ios_base::failbit;
  }
     }
   else
     {

       if (__format[__i] == *__beg)
  ++__beg;
       else
  __tmperr |= ios_base::failbit;
     }
 }

      if (__tmperr || __i != __len)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
     int __min, int __max, size_t __len,
     ios_base& __io, ios_base::iostate& __err) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);

      ++__min;
      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     {
       __value = __value * 10 + (__c - '0');
       const int __valuec = __value * __mult;
       if (__valuec > __max || __valuec + __mult < __min)
  break;
       __mult /= 10;
     }
   else
     break;
 }
      if (__i == __len)
 __member = __value;

      else if (__len == 4 && __i == 2)
 __member = __value - 100;
      else
 __err |= ios_base::failbit;

      return __beg;
    }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
      const _CharT** __names, size_t __indexlen,
      ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t __pos = 0;
      bool __testvalid = true;
      const char_type* __name;





      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
     if (__c == __names[__i1][0]
  || __c == __ctype.toupper(__names[__i1][0]))
       __matches[__nmatches++] = __i1;
 }

      while (__nmatches > 1)
 {

   size_t __minlen = __traits_type::length(__names[__matches[0]]);
   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
     __minlen = std::min(__minlen,
         __traits_type::length(__names[__matches[__i2]]));
   ++__beg;
   ++__pos;
   if (__pos < __minlen && __beg != __end)
     for (size_t __i3 = 0; __i3 < __nmatches;)
       {
  __name = __names[__matches[__i3]];
  if (!(__name[__pos] == *__beg))
    __matches[__i3] = __matches[--__nmatches];
  else
    ++__i3;
       }
   else
     break;
 }

      if (__nmatches == 1)
 {

   ++__beg;
   ++__pos;
   __name = __names[__matches[0]];
   const size_t __len = __traits_type::length(__name);
   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
     ++__beg, (void)++__pos;

   if (__len == __pos)
     __member = __matches[0];
   else
     __testvalid = false;
 }
      else
 __testvalid = false;
      if (!__testvalid)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t* __matches_lengths = 0;
      size_t __pos = 0;

      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
     if (__c == __names[__i][0]
  || __c == __ctype.toupper(__names[__i][0]))
       __matches[__nmatches++] = __i;
 }

      if (__nmatches)
 {
   ++__beg;
   ++__pos;

   __matches_lengths
     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
          * __nmatches));
   for (size_t __i = 0; __i < __nmatches; ++__i)
     __matches_lengths[__i]
       = __traits_type::length(__names[__matches[__i]]);
 }

      for (; __beg != __end; ++__beg, (void)++__pos)
 {
   size_t __nskipped = 0;
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < __nmatches;)
     {
       const char_type* __name = __names[__matches[__i]];
       if (__pos >= __matches_lengths[__i])
  ++__nskipped, ++__i;
       else if (!(__name[__pos] == __c))
  {
    --__nmatches;
    __matches[__i] = __matches[__nmatches];
    __matches_lengths[__i] = __matches_lengths[__nmatches];
  }
       else
  ++__i;
     }
   if (__nskipped == __nmatches)
     break;
 }

      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
   || (__nmatches == 2 && (__matches_lengths[0] == __pos
      || __matches_lengths[1] == __pos)))
 __member = (__matches[0] >= __indexlen
      ? __matches[0] - __indexlen : __matches[0]);
      else
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __times[2];
      __tp._M_time_formats(__times);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __times[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __dates[2];
      __tp._M_date_formats(__dates);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __dates[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __days[14];
      __tp._M_days_abbreviated(__days);
      __tp._M_days(__days + 7);
      int __tmpwday;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_wday = __tmpwday;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __months[24];
      __tp._M_months_abbreviated(__months);
      __tp._M_months(__months + 12);
      int __tmpmon;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_mon = __tmpmon;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      int __tmpyear;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
        __io, __tmperr);
      if (!__tmperr)
 __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }


  template<typename _CharT, typename _InIter>
    inline
    _InIter
    time_get<_CharT, _InIter>::
    get(iter_type __s, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
        const char_type* __fmtend) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __err = ios_base::goodbit;
      while (__fmt != __fmtend &&
             __err == ios_base::goodbit)
        {
          if (__s == __end)
            {
              __err = ios_base::eofbit | ios_base::failbit;
              break;
            }
          else if (__ctype.narrow(*__fmt, 0) == '%')
            {
              char __format;
              char __mod = 0;
              if (++__fmt == __fmtend)
                {
                  __err = ios_base::failbit;
                  break;
                }
              const char __c = __ctype.narrow(*__fmt, 0);
              if (__c != 'E' && __c != 'O')
                __format = __c;
              else if (++__fmt != __fmtend)
                {
                  __mod = __c;
                  __format = __ctype.narrow(*__fmt, 0);
                }
              else
                {
                  __err = ios_base::failbit;
                  break;
                }
              __s = this->do_get(__s, __end, __io, __err, __tm, __format,
     __mod);
              ++__fmt;
            }
          else if (__ctype.is(ctype_base::space, *__fmt))
            {
              ++__fmt;
              while (__fmt != __fmtend &&
                     __ctype.is(ctype_base::space, *__fmt))
                ++__fmt;

              while (__s != __end &&
                     __ctype.is(ctype_base::space, *__s))
                ++__s;
            }

          else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
                   __ctype.toupper(*__s) == __ctype.toupper(*__fmt))
            {
              ++__s;
              ++__fmt;
            }
          else
            {
              __err = ios_base::failbit;
              break;
            }
        }
      return __s;
    }

  template<typename _CharT, typename _InIter>
    inline
    _InIter
    time_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, tm* __tm,
           char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __err = ios_base::goodbit;

      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
        {
          __fmt[1] = __format;
          __fmt[2] = char_type();
        }
      else
        {
          __fmt[1] = __mod;
          __fmt[2] = __format;
          __fmt[3] = char_type();
        }

      __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
 const _CharT* __beg, const _CharT* __end) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      for (; __beg != __end; ++__beg)
 if (__ctype.narrow(*__beg, 0) != '%')
   {
     *__s = *__beg;
     ++__s;
   }
 else if (++__beg != __end)
   {
     char __format;
     char __mod = 0;
     const char __c = __ctype.narrow(*__beg, 0);
     if (__c != 'E' && __c != 'O')
       __format = __c;
     else if (++__beg != __end)
       {
  __mod = __c;
  __format = __ctype.narrow(*__beg, 0);
       }
     else
       break;
     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
   }
 else
   break;
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
    char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);



      const size_t __maxlen = 128;
      char_type __res[__maxlen];






      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
 {
   __fmt[1] = __format;
   __fmt[2] = char_type();
 }
      else
 {
   __fmt[1] = __mod;
   __fmt[2] = __format;
   __fmt[3] = char_type();
 }

      __tp._M_put(__res, __maxlen, __fmt, __tm);


      return std::__write(__s, __res, char_traits<char_type>::length(__res));
    }





  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class __cxx11:: money_get<char>;
  extern template class __cxx11:: money_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;

  extern template
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class __cxx11:: money_get<wchar_t>;
  extern template class __cxx11:: money_put<wchar_t>;
  extern template class __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;

  extern template
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);




}
# 2016 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3
# 42 "/usr/include/c++/10/locale" 2 3

# 1 "/usr/include/c++/10/bits/locale_conv.h" 1 3
# 41 "/usr/include/c++/10/bits/locale_conv.h" 3
# 1 "/usr/include/c++/10/bits/unique_ptr.h" 1 3
# 41 "/usr/include/c++/10/bits/unique_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{








#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename> class auto_ptr;
#pragma GCC diagnostic pop



  template<typename _Tp>
    struct default_delete
    {

      constexpr default_delete() noexcept = default;






      template<typename _Up,
        typename = _Require<is_convertible<_Up*, _Tp*>>>
        default_delete(const default_delete<_Up>&) noexcept { }


      void
      operator()(_Tp* __ptr) const
      {
 static_assert(!is_void<_Tp>::value,
        "can't delete pointer to incomplete type");
 static_assert(sizeof(_Tp)>0,
        "can't delete pointer to incomplete type");
 delete __ptr;
      }
    };





  template<typename _Tp>
    struct default_delete<_Tp[]>
    {
    public:

      constexpr default_delete() noexcept = default;
# 105 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Up,
        typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
        default_delete(const default_delete<_Up[]>&) noexcept { }


      template<typename _Up>
 typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
 operator()(_Up* __ptr) const
 {
   static_assert(sizeof(_Tp)>0,
   "can't delete pointer to incomplete type");
   delete [] __ptr;
 }
    };




  template <typename _Tp, typename _Dp>
    class __uniq_ptr_impl
    {
      template <typename _Up, typename _Ep, typename = void>
 struct _Ptr
 {
   using type = _Up*;
 };

      template <typename _Up, typename _Ep>
 struct
 _Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
 {
   using type = typename remove_reference<_Ep>::type::pointer;
 };

    public:
      using _DeleterConstraint = enable_if<
        __and_<__not_<is_pointer<_Dp>>,
        is_default_constructible<_Dp>>::value>;

      using pointer = typename _Ptr<_Tp, _Dp>::type;

      static_assert( !is_rvalue_reference<_Dp>::value,
       "unique_ptr's deleter type must be a function object type"
       " or an lvalue reference type" );

      __uniq_ptr_impl() = default;
      __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

      template<typename _Del>
      __uniq_ptr_impl(pointer __p, _Del&& __d)
 : _M_t(__p, std::forward<_Del>(__d)) { }

      __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
      : _M_t(std::move(__u._M_t))
      { __u._M_ptr() = nullptr; }

      __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
      {
 reset(__u.release());
 _M_deleter() = std::forward<_Dp>(__u._M_deleter());
 return *this;
      }

      pointer& _M_ptr() { return std::get<0>(_M_t); }
      pointer _M_ptr() const { return std::get<0>(_M_t); }
      _Dp& _M_deleter() { return std::get<1>(_M_t); }
      const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

      void reset(pointer __p) noexcept
      {
 const pointer __old_p = _M_ptr();
 _M_ptr() = __p;
 if (__old_p)
   _M_deleter()(__old_p);
      }

      pointer release() noexcept
      {
 pointer __p = _M_ptr();
 _M_ptr() = nullptr;
 return __p;
      }

    private:
      tuple<pointer, _Dp> _M_t;
    };


  template <typename _Tp, typename _Dp,
     bool = is_move_constructible<_Dp>::value,
     bool = is_move_assignable<_Dp>::value>
    struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = default;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
    };

  template <typename _Tp, typename _Dp>
    struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = default;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
    };

  template <typename _Tp, typename _Dp>
    struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
    };

  template <typename _Tp, typename _Dp>
    struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
    };



  template <typename _Tp, typename _Dp = default_delete<_Tp>>
    class unique_ptr
    {
      template <typename _Up>
 using _DeleterConstraint =
   typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

      __uniq_ptr_data<_Tp, _Dp> _M_t;

    public:
      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
      using element_type = _Tp;
      using deleter_type = _Dp;

    private:


      template<typename _Up, typename _Ep>
 using __safe_conversion_up = __and_<
   is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
   __not_<is_array<_Up>>
        >;

    public:



      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr() noexcept
 : _M_t()
 { }







      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 explicit
 unique_ptr(pointer __p) noexcept
 : _M_t(__p)
        { }
# 280 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Del = deleter_type,
        typename = _Require<is_copy_constructible<_Del>>>
 unique_ptr(pointer __p, const deleter_type& __d) noexcept
 : _M_t(__p, __d) { }
# 292 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Del = deleter_type,
        typename = _Require<is_move_constructible<_Del>>>
 unique_ptr(pointer __p,
     __enable_if_t<!is_lvalue_reference<_Del>::value,
     _Del&&> __d) noexcept
 : _M_t(__p, std::move(__d))
 { }

      template<typename _Del = deleter_type,
        typename _DelUnref = typename remove_reference<_Del>::type>
 unique_ptr(pointer,
     __enable_if_t<is_lvalue_reference<_Del>::value,
     _DelUnref&&>) = delete;


      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr(nullptr_t) noexcept
 : _M_t()
 { }




      unique_ptr(unique_ptr&&) = default;







      template<typename _Up, typename _Ep, typename = _Require<
               __safe_conversion_up<_Up, _Ep>,
        typename conditional<is_reference<_Dp>::value,
        is_same<_Ep, _Dp>,
        is_convertible<_Ep, _Dp>>::type>>
 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
 { }


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

      template<typename _Up, typename = _Require<
        is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
 unique_ptr(auto_ptr<_Up>&& __u) noexcept;
#pragma GCC diagnostic pop



      ~unique_ptr() noexcept
      {
 static_assert(__is_invocable<deleter_type&, pointer>::value,
        "unique_ptr's deleter must be invocable with a pointer");
 auto& __ptr = _M_t._M_ptr();
 if (__ptr != nullptr)
   get_deleter()(std::move(__ptr));
 __ptr = pointer();
      }







      unique_ptr& operator=(unique_ptr&&) = default;
# 368 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Up, typename _Ep>
        typename enable_if< __and_<
          __safe_conversion_up<_Up, _Ep>,
          is_assignable<deleter_type&, _Ep&&>
          >::value,
          unique_ptr&>::type
 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
 {
   reset(__u.release());
   get_deleter() = std::forward<_Ep>(__u.get_deleter());
   return *this;
 }


      unique_ptr&
      operator=(nullptr_t) noexcept
      {
 reset();
 return *this;
      }




      typename add_lvalue_reference<element_type>::type
      operator*() const
      {
 do { if (! (get() != pointer())) std::__replacement_assert("/usr/include/c++/10/bits/unique_ptr.h", 395, __PRETTY_FUNCTION__, "get() != pointer()"); } while (false);
 return *get();
      }


      pointer
      operator->() const noexcept
      {
 ;
 return get();
      }


      pointer
      get() const noexcept
      { return _M_t._M_ptr(); }


      deleter_type&
      get_deleter() noexcept
      { return _M_t._M_deleter(); }


      const deleter_type&
      get_deleter() const noexcept
      { return _M_t._M_deleter(); }


      explicit operator bool() const noexcept
      { return get() == pointer() ? false : true; }




      pointer
      release() noexcept
      { return _M_t.release(); }







      void
      reset(pointer __p = pointer()) noexcept
      {
 static_assert(__is_invocable<deleter_type&, pointer>::value,
        "unique_ptr's deleter must be invocable with a pointer");
 _M_t.reset(std::move(__p));
      }


      void
      swap(unique_ptr& __u) noexcept
      {
 using std::swap;
 swap(_M_t, __u._M_t);
      }


      unique_ptr(const unique_ptr&) = delete;
      unique_ptr& operator=(const unique_ptr&) = delete;
  };





  template<typename _Tp, typename _Dp>
    class unique_ptr<_Tp[], _Dp>
    {
      template <typename _Up>
      using _DeleterConstraint =
 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

      __uniq_ptr_data<_Tp, _Dp> _M_t;

      template<typename _Up>
 using __remove_cv = typename remove_cv<_Up>::type;


      template<typename _Up>
 using __is_derived_Tp
   = __and_< is_base_of<_Tp, _Up>,
      __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

    public:
      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
      using element_type = _Tp;
      using deleter_type = _Dp;



      template<typename _Up, typename _Ep,
               typename _UPtr = unique_ptr<_Up, _Ep>,
        typename _UP_pointer = typename _UPtr::pointer,
        typename _UP_element_type = typename _UPtr::element_type>
 using __safe_conversion_up = __and_<
          is_array<_Up>,
          is_same<pointer, element_type*>,
          is_same<_UP_pointer, _UP_element_type*>,
          is_convertible<_UP_element_type(*)[], element_type(*)[]>
        >;


      template<typename _Up>
        using __safe_conversion_raw = __and_<
          __or_<__or_<is_same<_Up, pointer>,
                      is_same<_Up, nullptr_t>>,
                __and_<is_pointer<_Up>,
                       is_same<pointer, element_type*>,
                       is_convertible<
                         typename remove_pointer<_Up>::type(*)[],
                         element_type(*)[]>
                >
          >
        >;




      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr() noexcept
 : _M_t()
 { }
# 529 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Up,
        typename _Vp = _Dp,
        typename = _DeleterConstraint<_Vp>,
        typename = typename enable_if<
                 __safe_conversion_raw<_Up>::value, bool>::type>
 explicit
 unique_ptr(_Up __p) noexcept
 : _M_t(__p)
        { }
# 547 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Up, typename _Del = deleter_type,
        typename = _Require<__safe_conversion_raw<_Up>,
       is_copy_constructible<_Del>>>
      unique_ptr(_Up __p, const deleter_type& __d) noexcept
      : _M_t(__p, __d) { }
# 561 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Up, typename _Del = deleter_type,
        typename = _Require<__safe_conversion_raw<_Up>,
       is_move_constructible<_Del>>>
 unique_ptr(_Up __p,
     __enable_if_t<!is_lvalue_reference<_Del>::value,
     _Del&&> __d) noexcept
 : _M_t(std::move(__p), std::move(__d))
 { }

      template<typename _Up, typename _Del = deleter_type,
        typename _DelUnref = typename remove_reference<_Del>::type,
        typename = _Require<__safe_conversion_raw<_Up>>>
 unique_ptr(_Up,
     __enable_if_t<is_lvalue_reference<_Del>::value,
     _DelUnref&&>) = delete;


      unique_ptr(unique_ptr&&) = default;


      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr(nullptr_t) noexcept
 : _M_t()
        { }

      template<typename _Up, typename _Ep, typename = _Require<
        __safe_conversion_up<_Up, _Ep>,
        typename conditional<is_reference<_Dp>::value,
        is_same<_Ep, _Dp>,
        is_convertible<_Ep, _Dp>>::type>>
 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
 { }


      ~unique_ptr()
      {
 auto& __ptr = _M_t._M_ptr();
 if (__ptr != nullptr)
   get_deleter()(__ptr);
 __ptr = pointer();
      }







      unique_ptr&
      operator=(unique_ptr&&) = default;
# 620 "/usr/include/c++/10/bits/unique_ptr.h" 3
      template<typename _Up, typename _Ep>
 typename
 enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                         is_assignable<deleter_type&, _Ep&&>
                  >::value,
                  unique_ptr&>::type
 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
 {
   reset(__u.release());
   get_deleter() = std::forward<_Ep>(__u.get_deleter());
   return *this;
 }


      unique_ptr&
      operator=(nullptr_t) noexcept
      {
 reset();
 return *this;
      }




      typename std::add_lvalue_reference<element_type>::type
      operator[](size_t __i) const
      {
 do { if (! (get() != pointer())) std::__replacement_assert("/usr/include/c++/10/bits/unique_ptr.h", 647, __PRETTY_FUNCTION__, "get() != pointer()"); } while (false);
 return get()[__i];
      }


      pointer
      get() const noexcept
      { return _M_t._M_ptr(); }


      deleter_type&
      get_deleter() noexcept
      { return _M_t._M_deleter(); }


      const deleter_type&
      get_deleter() const noexcept
      { return _M_t._M_deleter(); }


      explicit operator bool() const noexcept
      { return get() == pointer() ? false : true; }




      pointer
      release() noexcept
      { return _M_t.release(); }







      template <typename _Up,
                typename = _Require<
                  __or_<is_same<_Up, pointer>,
                        __and_<is_same<pointer, element_type*>,
                               is_pointer<_Up>,
                               is_convertible<
                                 typename remove_pointer<_Up>::type(*)[],
                                 element_type(*)[]
                               >
                        >
                  >
               >>
      void
      reset(_Up __p) noexcept
      { _M_t.reset(std::move(__p)); }

      void reset(nullptr_t = nullptr) noexcept
      { reset(pointer()); }


      void
      swap(unique_ptr& __u) noexcept
      {
 using std::swap;
 swap(_M_t, __u._M_t);
      }


      unique_ptr(const unique_ptr&) = delete;
      unique_ptr& operator=(const unique_ptr&) = delete;
    };




  template<typename _Tp, typename _Dp>
    inline


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



    swap(unique_ptr<_Tp, _Dp>& __x,
  unique_ptr<_Tp, _Dp>& __y) noexcept
    { __x.swap(__y); }


  template<typename _Tp, typename _Dp>
    typename enable_if<!__is_swappable<_Dp>::value>::type
    swap(unique_ptr<_Tp, _Dp>&,
  unique_ptr<_Tp, _Dp>&) = delete;



  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] inline bool
    operator==(const unique_ptr<_Tp, _Dp>& __x,
        const unique_ptr<_Up, _Ep>& __y)
    { return __x.get() == __y.get(); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
    { return !__x; }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
    { return !__x; }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] inline bool
    operator!=(const unique_ptr<_Tp, _Dp>& __x,
        const unique_ptr<_Up, _Ep>& __y)
    { return __x.get() != __y.get(); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
    { return (bool)__x; }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
    { return (bool)__x; }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] inline bool
    operator<(const unique_ptr<_Tp, _Dp>& __x,
       const unique_ptr<_Up, _Ep>& __y)
    {
      typedef typename
 std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                  typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
      return std::less<_CT>()(__x.get(), __y.get());
    }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
         nullptr);
    }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
         __x.get());
    }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] inline bool
    operator<=(const unique_ptr<_Tp, _Dp>& __x,
        const unique_ptr<_Up, _Ep>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    { return !(nullptr < __x); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    { return !(__x < nullptr); }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] inline bool
    operator>(const unique_ptr<_Tp, _Dp>& __x,
       const unique_ptr<_Up, _Ep>& __y)
    { return (__y < __x); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
         __x.get());
    }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
         nullptr);
    }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] inline bool
    operator>=(const unique_ptr<_Tp, _Dp>& __x,
        const unique_ptr<_Up, _Ep>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    { return !(__x < nullptr); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    { return !(nullptr < __x); }



  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>>
    { };







  template<typename _Tp>
    struct _MakeUniq
    { typedef unique_ptr<_Tp> __single_object; };

  template<typename _Tp>
    struct _MakeUniq<_Tp[]>
    { typedef unique_ptr<_Tp[]> __array; };

  template<typename _Tp, size_t _Bound>
    struct _MakeUniq<_Tp[_Bound]>
    { struct __invalid_type { }; };




  template<typename _Tp, typename... _Args>
    inline typename _MakeUniq<_Tp>::__single_object
    make_unique(_Args&&... __args)
    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }


  template<typename _Tp>
    inline typename _MakeUniq<_Tp>::__array
    make_unique(size_t __num)
    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }


  template<typename _Tp, typename... _Args>
    inline typename _MakeUniq<_Tp>::__invalid_type
    make_unique(_Args&&...) = delete;






  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
      { };
  }



}
# 42 "/usr/include/c++/10/bits/locale_conv.h" 2 3

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







  template<typename _OutStr, typename _InChar, typename _Codecvt,
    typename _State, typename _Fn>
    bool
    __do_str_codecvt(const _InChar* __first, const _InChar* __last,
       _OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
       size_t& __count, _Fn __fn)
    {
      if (__first == __last)
 {
   __outstr.clear();
   __count = 0;
   return true;
 }

      size_t __outchars = 0;
      auto __next = __first;
      const auto __maxlen = __cvt.max_length() + 1;

      codecvt_base::result __result;
      do
 {
   __outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
   auto __outnext = &__outstr.front() + __outchars;
   auto const __outlast = &__outstr.back() + 1;
   __result = (__cvt.*__fn)(__state, __next, __last, __next,
     __outnext, __outlast, __outnext);
   __outchars = __outnext - &__outstr.front();
 }
      while (__result == codecvt_base::partial && __next != __last
      && (__outstr.size() - __outchars) < __maxlen);

      if (__result == codecvt_base::error)
 {
   __count = __next - __first;
   return false;
 }



      if constexpr (is_same<typename _Codecvt::intern_type,
           typename _Codecvt::extern_type>())
 if (__result == codecvt_base::noconv)
   {
     __outstr.assign(__first, __last);
     __count = __last - __first;
     return true;
   }

      __outstr.resize(__outchars);
      __count = __next - __first;
      return true;
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
       basic_string<_CharT, _Traits, _Alloc>& __outstr,
       const codecvt<_CharT, char, _State>& __cvt,
       _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const char*, const char*, const char*&,
   _CharT*, _CharT*, _CharT*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::in;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
       basic_string<_CharT, _Traits, _Alloc>& __outstr,
       const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in_all(const char* __first, const char* __last,
    basic_string<_CharT, _Traits, _Alloc>& __outstr,
    const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
 && (__n == (__last - __first));
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char, _State>& __cvt,
        _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
   char*, char*, char*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::out;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
     basic_string<char, _Traits, _Alloc>& __outstr,
     const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
 && (__n == (__last - __first));
    }
# 226 "/usr/include/c++/10/bits/locale_conv.h" 3
namespace __cxx11 {


  template<typename _Codecvt, typename _Elem = wchar_t,
    typename _Wide_alloc = allocator<_Elem>,
    typename _Byte_alloc = allocator<char>>
    class wstring_convert
    {
    public:
      typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
      typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
      typedef typename _Codecvt::state_type state_type;
      typedef typename wide_string::traits_type::int_type int_type;


      wstring_convert() : _M_cvt(new _Codecvt()) { }







      explicit
      wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt)
      {
 if (!_M_cvt)
   __throw_logic_error("wstring_convert");
      }
# 264 "/usr/include/c++/10/bits/locale_conv.h" 3
      wstring_convert(_Codecvt* __pcvt, state_type __state)
      : _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
      {
 if (!_M_cvt)
   __throw_logic_error("wstring_convert");
      }






      explicit
      wstring_convert(const byte_string& __byte_err,
        const wide_string& __wide_err = wide_string())
      : _M_cvt(new _Codecvt),
 _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
 _M_with_strings(true)
      {
 if (!_M_cvt)
   __throw_logic_error("wstring_convert");
      }

      ~wstring_convert() = default;



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


      wide_string
      from_bytes(char __byte)
      {
 char __bytes[2] = { __byte };
 return from_bytes(__bytes, __bytes+1);
      }

      wide_string
      from_bytes(const char* __ptr)
      { return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }

      wide_string
      from_bytes(const byte_string& __str)
      {
 auto __ptr = __str.data();
 return from_bytes(__ptr, __ptr + __str.size());
      }

      wide_string
      from_bytes(const char* __first, const char* __last)
      {
 if (!_M_with_cvtstate)
   _M_state = state_type();
 wide_string __out{ _M_wide_err_string.get_allocator() };
 if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
        _M_count))
   return __out;
 if (_M_with_strings)
   return _M_wide_err_string;
 __throw_range_error("wstring_convert::from_bytes");
      }



      byte_string
      to_bytes(_Elem __wchar)
      {
 _Elem __wchars[2] = { __wchar };
 return to_bytes(__wchars, __wchars+1);
      }

      byte_string
      to_bytes(const _Elem* __ptr)
      {
 return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
      }

      byte_string
      to_bytes(const wide_string& __wstr)
      {
 auto __ptr = __wstr.data();
 return to_bytes(__ptr, __ptr + __wstr.size());
      }

      byte_string
      to_bytes(const _Elem* __first, const _Elem* __last)
      {
 if (!_M_with_cvtstate)
   _M_state = state_type();
 byte_string __out{ _M_byte_err_string.get_allocator() };
 if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
         _M_count))
   return __out;
 if (_M_with_strings)
   return _M_byte_err_string;
 __throw_range_error("wstring_convert::to_bytes");
      }





      size_t converted() const noexcept { return _M_count; }


      state_type state() const { return _M_state; }

    private:
      unique_ptr<_Codecvt> _M_cvt;
      byte_string _M_byte_err_string;
      wide_string _M_wide_err_string;
      state_type _M_state = state_type();
      size_t _M_count = 0;
      bool _M_with_cvtstate = false;
      bool _M_with_strings = false;
    };

}


  template<typename _Codecvt, typename _Elem = wchar_t,
    typename _Tr = char_traits<_Elem>>
    class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
    {
      typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;

    public:
      typedef typename _Codecvt::state_type state_type;


      wbuffer_convert() : wbuffer_convert(nullptr) { }
# 405 "/usr/include/c++/10/bits/locale_conv.h" 3
      explicit
      wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt,
        state_type __state = state_type())
      : _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
      {
 if (!_M_cvt)
   __throw_logic_error("wbuffer_convert");

 _M_always_noconv = _M_cvt->always_noconv();

 if (_M_buf)
   {
     this->setp(_M_put_area, _M_put_area + _S_buffer_length);
     this->setg(_M_get_area + _S_putback_length,
         _M_get_area + _S_putback_length,
         _M_get_area + _S_putback_length);
   }
      }

      ~wbuffer_convert() = default;



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

      streambuf* rdbuf() const noexcept { return _M_buf; }

      streambuf*
      rdbuf(streambuf *__bytebuf) noexcept
      {
 auto __prev = _M_buf;
 _M_buf = __bytebuf;
 return __prev;
      }


      state_type state() const noexcept { return _M_state; }

    protected:
      int
      sync()
      { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }

      typename _Wide_streambuf::int_type
      overflow(typename _Wide_streambuf::int_type __out)
      {
 if (!_M_buf || !_M_conv_put())
   return _Tr::eof();
 else if (!_Tr::eq_int_type(__out, _Tr::eof()))
   return this->sputc(__out);
 return _Tr::not_eof(__out);
      }

      typename _Wide_streambuf::int_type
      underflow()
      {
 if (!_M_buf)
   return _Tr::eof();

 if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
   return _Tr::to_int_type(*this->gptr());
 else
   return _Tr::eof();
      }

      streamsize
      xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
      {
 if (!_M_buf || __n == 0)
   return 0;
 streamsize __done = 0;
 do
 {
   auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
        __n - __done);
   _Tr::copy(this->pptr(), __s + __done, __nn);
   this->pbump(__nn);
   __done += __nn;
 } while (__done < __n && _M_conv_put());
 return __done;
      }

    private:

      bool
      _M_conv_get()
      {
 const streamsize __pb1 = this->gptr() - this->eback();
 const streamsize __pb2 = _S_putback_length;
 const streamsize __npb = std::min(__pb1, __pb2);

 _Tr::move(_M_get_area + _S_putback_length - __npb,
    this->gptr() - __npb, __npb);

 streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
 __nbytes = std::min(__nbytes, _M_buf->in_avail());
 if (__nbytes < 1)
   __nbytes = 1;
 __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
 if (__nbytes < 1)
   return false;
 __nbytes += _M_unconv;



 _Elem* __outbuf = _M_get_area + _S_putback_length;
 _Elem* __outnext = __outbuf;
 const char* __bnext = _M_get_buf;

 codecvt_base::result __result;
 if (_M_always_noconv)
   __result = codecvt_base::noconv;
 else
   {
     _Elem* __outend = _M_get_area + _S_buffer_length;

     __result = _M_cvt->in(_M_state,
      __bnext, __bnext + __nbytes, __bnext,
      __outbuf, __outend, __outnext);
   }

 if (__result == codecvt_base::noconv)
   {

     auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
     _Tr::copy(__outbuf, __get_buf, __nbytes);
     _M_unconv = 0;
     return true;
   }

 if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
   char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);

 this->setg(__outbuf, __outbuf, __outnext);

 return __result != codecvt_base::error;
      }


      bool
      _M_put(...)
      { return false; }

      bool
      _M_put(const char* __p, streamsize __n)
      {
 if (_M_buf->sputn(__p, __n) < __n)
   return false;
 return true;
      }


      bool
      _M_conv_put()
      {
 _Elem* const __first = this->pbase();
 const _Elem* const __last = this->pptr();
 const streamsize __pending = __last - __first;

 if (_M_always_noconv)
   return _M_put(__first, __pending);

 char __outbuf[2 * _S_buffer_length];

 const _Elem* __next = __first;
 const _Elem* __start;
 do
   {
     __start = __next;
     char* __outnext = __outbuf;
     char* const __outlast = __outbuf + sizeof(__outbuf);
     auto __result = _M_cvt->out(_M_state, __next, __last, __next,
     __outnext, __outlast, __outnext);
     if (__result == codecvt_base::error)
       return false;
     else if (__result == codecvt_base::noconv)
       return _M_put(__next, __pending);

     if (!_M_put(__outbuf, __outnext - __outbuf))
       return false;
   }
 while (__next != __last && __next != __start);

 if (__next != __last)
   _Tr::move(__first, __next, __last - __next);

 this->pbump(__first - __next);
 return __next != __first;
      }

      streambuf* _M_buf;
      unique_ptr<_Codecvt> _M_cvt;
      state_type _M_state;

      static const streamsize _S_buffer_length = 32;
      static const streamsize _S_putback_length = 3;
      _Elem _M_put_area[_S_buffer_length];
      _Elem _M_get_area[_S_buffer_length];
      streamsize _M_unconv = 0;
      char _M_get_buf[_S_buffer_length-_S_putback_length];
      bool _M_always_noconv;
    };






}
# 44 "/usr/include/c++/10/locale" 2 3
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/compare.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/compare.hpp" 3 4
namespace boost {
    namespace algorithm {
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/compare.hpp" 3 4
        struct is_equal
        {




            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1==Arg2;
            }
        };






        struct is_iequal
        {




            is_iequal( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}





            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {



                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);

            }

        private:
            std::locale m_Loc;
        };
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/compare.hpp" 3 4
        struct is_less
        {




            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1<Arg2;
            }
        };







        struct is_iless
        {




            is_iless( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}





            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {



                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);

            }

        private:
            std::locale m_Loc;
        };
# 139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/compare.hpp" 3 4
        struct is_not_greater
        {




            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1<=Arg2;
            }
        };







        struct is_not_igreater
        {




            is_not_igreater( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}





            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {



                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);

            }

        private:
            std::locale m_Loc;
        };


    }


    using algorithm::is_equal;
    using algorithm::is_iequal;
    using algorithm::is_less;
    using algorithm::is_iless;
    using algorithm::is_not_greater;
    using algorithm::is_not_igreater;

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/constants.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/constants.hpp" 3 4
namespace boost {
    namespace algorithm {





    enum token_compress_mode_type
    {
        token_compress_on,
        token_compress_off
    };

    }


    using algorithm::token_compress_on;
    using algorithm::token_compress_off;

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/iterator.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/iterator.hpp" 3 4
namespace boost
{

namespace detail
{

using std::iterator_traits;
using std::distance;
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/iterator.hpp" 3 4
}

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 2 3 4







namespace boost {
    namespace algorithm {
        namespace detail {
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename SearchIteratorT,typename PredicateT>
            struct first_finderF
            {
                typedef SearchIteratorT search_iterator_type;


                template< typename SearchT >
                first_finderF( const SearchT& Search, PredicateT Comp ) :
                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                first_finderF(
                        search_iterator_type SearchBegin,
                        search_iterator_type SearchEnd,
                        PredicateT Comp ) :
                    m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;
                    typedef ForwardIteratorT input_iterator_type;


                    for(input_iterator_type OuterIt=Begin;
                        OuterIt!=End;
                        ++OuterIt)
                    {

                        if( boost::empty(m_Search) )
                            return result_type( End, End );

                        input_iterator_type InnerIt=OuterIt;
                        search_iterator_type SubstrIt=m_Search.begin();
                        for(;
                            InnerIt!=End && SubstrIt!=m_Search.end();
                            ++InnerIt,++SubstrIt)
                        {
                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
                                break;
                        }


                        if ( SubstrIt==m_Search.end() )
                            return result_type( OuterIt, InnerIt );
                    }

                    return result_type( End, End );
                }

            private:
                iterator_range<search_iterator_type> m_Search;
                PredicateT m_Comp;
            };
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename SearchIteratorT, typename PredicateT>
            struct last_finderF
            {
                typedef SearchIteratorT search_iterator_type;
                typedef first_finderF<
                    search_iterator_type,
                    PredicateT> first_finder_type;


                template< typename SearchT >
                last_finderF( const SearchT& Search, PredicateT Comp ) :
                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                last_finderF(
                        search_iterator_type SearchBegin,
                        search_iterator_type SearchEnd,
                        PredicateT Comp ) :
                    m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;

                    if( boost::empty(m_Search) )
                        return result_type( End, End );

                    typedef typename boost::detail::
                        iterator_traits<ForwardIteratorT>::iterator_category category;

                    return findit( Begin, End, category() );
                }

            private:

                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                findit(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    std::forward_iterator_tag ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;

                    first_finder_type first_finder(
                        m_Search.begin(), m_Search.end(), m_Comp );

                    result_type M=first_finder( Begin, End );
                    result_type Last=M;

                    while( M )
                    {
                        Last=M;
                        M=first_finder( ::boost::end(M), End );
                    }

                    return Last;
                }


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                findit(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    std::bidirectional_iterator_tag ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;
                    typedef ForwardIteratorT input_iterator_type;


                    for(input_iterator_type OuterIt=End;
                        OuterIt!=Begin; )
                    {
                        input_iterator_type OuterIt2=--OuterIt;

                        input_iterator_type InnerIt=OuterIt2;
                        search_iterator_type SubstrIt=m_Search.begin();
                        for(;
                            InnerIt!=End && SubstrIt!=m_Search.end();
                            ++InnerIt,++SubstrIt)
                        {
                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
                                break;
                        }


                        if( SubstrIt==m_Search.end() )
                            return result_type( OuterIt2, InnerIt );
                    }

                    return result_type( End, End );
                }

            private:
                iterator_range<search_iterator_type> m_Search;
                PredicateT m_Comp;
            };
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename SearchIteratorT, typename PredicateT>
            struct nth_finderF
            {
                typedef SearchIteratorT search_iterator_type;
                typedef first_finderF<
                    search_iterator_type,
                    PredicateT> first_finder_type;
                typedef last_finderF<
                    search_iterator_type,
                    PredicateT> last_finder_type;


                template< typename SearchT >
                nth_finderF(
                        const SearchT& Search,
                        int Nth,
                        PredicateT Comp) :
                    m_Search(::boost::begin(Search), ::boost::end(Search)),
                    m_Nth(Nth),
                    m_Comp(Comp) {}
                nth_finderF(
                        search_iterator_type SearchBegin,
                        search_iterator_type SearchEnd,
                        int Nth,
                        PredicateT Comp) :
                    m_Search(SearchBegin, SearchEnd),
                    m_Nth(Nth),
                    m_Comp(Comp) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    if(m_Nth>=0)
                    {
                        return find_forward(Begin, End, m_Nth);
                    }
                    else
                    {
                        return find_backward(Begin, End, -m_Nth);
                    }

                }

            private:

                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                find_forward(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    unsigned int N) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;


                    if( boost::empty(m_Search) )
                        return result_type( End, End );


                    first_finder_type first_finder(
                        m_Search.begin(), m_Search.end(), m_Comp );

                    result_type M( Begin, Begin );

                    for( unsigned int n=0; n<=N; ++n )
                    {

                        M=first_finder( ::boost::end(M), End );

                        if ( !M )
                        {

                            return M;
                        }
                    }

                    return M;
                }

                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                find_backward(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    unsigned int N) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;


                    if( boost::empty(m_Search) )
                        return result_type( End, End );


                    last_finder_type last_finder(
                        m_Search.begin(), m_Search.end(), m_Comp );

                    result_type M( End, End );

                    for( unsigned int n=1; n<=N; ++n )
                    {

                        M=last_finder( Begin, ::boost::begin(M) );

                        if ( !M )
                        {

                            return M;
                        }
                    }

                    return M;
                }


            private:
                iterator_range<search_iterator_type> m_Search;
                int m_Nth;
                PredicateT m_Comp;
            };



            template<typename ForwardIteratorT>
                iterator_range<ForwardIteratorT>
            find_head_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::forward_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                input_iterator_type It=Begin;
                for(
                    unsigned int Index=0;
                    Index<N && It!=End; ++Index,++It ) {};

                return result_type( Begin, It );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_head_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::random_access_iterator_tag )
            {
                typedef iterator_range<ForwardIteratorT> result_type;

                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
                    return result_type( Begin, End );

                return result_type(Begin,Begin+N);
            }


            template<typename ForwardIteratorT>
                iterator_range<ForwardIteratorT>
            find_head_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N )
            {
                typedef typename boost::detail::
                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::forward_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                unsigned int Index=0;
                input_iterator_type It=Begin;
                input_iterator_type It2=Begin;


                for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};


                for(; It2!=End; ++It,++It2 ) {};

                return result_type( It, It2 );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::bidirectional_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                input_iterator_type It=End;
                for(
                    unsigned int Index=0;
                    Index<N && It!=Begin; ++Index,--It ) {};

                return result_type( It, End );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::random_access_iterator_tag )
            {
                typedef iterator_range<ForwardIteratorT> result_type;

                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
                    return result_type( Begin, End );

                return result_type( End-N, End );
            }


            template< typename ForwardIteratorT >
            iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N )
            {
                typedef typename boost::detail::
                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
            }
# 468 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
            struct head_finderF
            {

                head_finderF( int N ) : m_N(N) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    if(m_N>=0)
                    {
                        return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
                    }
                    else
                    {
                        iterator_range<ForwardIteratorT> Res=
                            ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );

                        return ::boost::make_iterator_range(Begin, Res.begin());
                    }
                }

            private:
                int m_N;
            };
# 506 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
            struct tail_finderF
            {

                tail_finderF( int N ) : m_N(N) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    if(m_N>=0)
                    {
                        return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
                    }
                    else
                    {
                        iterator_range<ForwardIteratorT> Res=
                            ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );

                        return ::boost::make_iterator_range(Res.end(), End);
                    }
                }

            private:
                int m_N;
            };
# 547 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template< typename PredicateT >
            struct token_finderF
            {

                token_finderF(
                    PredicateT Pred,
                    token_compress_mode_type eCompress=token_compress_off ) :
                        m_Pred(Pred), m_eCompress(eCompress) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;

                    ForwardIteratorT It=std::find_if( Begin, End, m_Pred );

                    if( It==End )
                    {
                        return result_type( End, End );
                    }
                    else
                    {
                        ForwardIteratorT It2=It;

                        if( m_eCompress==token_compress_on )
                        {

                            while( It2!=End && m_Pred(*It2) ) ++It2;
                        }
                        else
                        {

                            ++It2;
                        }

                        return result_type( It, It2 );
                    }
                }

            private:
                PredicateT m_Pred;
                token_compress_mode_type m_eCompress;
            };
# 602 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename ForwardIterator1T>
            struct range_finderF
            {
                typedef ForwardIterator1T input_iterator_type;
                typedef iterator_range<input_iterator_type> result_type;


                range_finderF(
                    input_iterator_type Begin,
                    input_iterator_type End ) : m_Range(Begin, End) {}

                range_finderF(const iterator_range<input_iterator_type>& Range) :
                    m_Range(Range) {}


                template< typename ForwardIterator2T >
                iterator_range<ForwardIterator2T>
                operator()(
                    ForwardIterator2T,
                    ForwardIterator2T ) const
                {



                    return m_Range;

                }

            private:
                iterator_range<input_iterator_type> m_Range;
            };


        }
    }
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
        template<typename RangeT>
        inline detail::first_finderF<
            typename range_const_iterator<RangeT>::type,
            is_equal>
        first_finder( const RangeT& Search )
        {
            return
                detail::first_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                        is_equal>( ::boost::as_literal(Search), is_equal() ) ;
        }





        template<typename RangeT,typename PredicateT>
        inline detail::first_finderF<
            typename range_const_iterator<RangeT>::type,
            PredicateT>
        first_finder(
            const RangeT& Search, PredicateT Comp )
        {
            return
                detail::first_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    PredicateT>( ::boost::as_literal(Search), Comp );
        }
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
        template<typename RangeT>
        inline detail::last_finderF<
            typename range_const_iterator<RangeT>::type,
            is_equal>
        last_finder( const RangeT& Search )
        {
            return
                detail::last_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    is_equal>( ::boost::as_literal(Search), is_equal() );
        }




        template<typename RangeT, typename PredicateT>
        inline detail::last_finderF<
            typename range_const_iterator<RangeT>::type,
            PredicateT>
        last_finder( const RangeT& Search, PredicateT Comp )
        {
            return
                detail::last_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    PredicateT>( ::boost::as_literal(Search), Comp ) ;
        }
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
        template<typename RangeT>
        inline detail::nth_finderF<
            typename range_const_iterator<RangeT>::type,
            is_equal>
        nth_finder(
            const RangeT& Search,
            int Nth)
        {
            return
                detail::nth_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
        }




        template<typename RangeT, typename PredicateT>
        inline detail::nth_finderF<
            typename range_const_iterator<RangeT>::type,
            PredicateT>
        nth_finder(
            const RangeT& Search,
            int Nth,
            PredicateT Comp )
        {
            return
                detail::nth_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    PredicateT>( ::boost::as_literal(Search), Nth, Comp );
        }
# 175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
        inline detail::head_finderF
        head_finder( int N )
        {
            return detail::head_finderF(N);
        }
# 192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
        inline detail::tail_finderF
        tail_finder( int N )
        {
            return detail::tail_finderF(N);
        }
# 216 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
        template< typename PredicateT >
        inline detail::token_finderF<PredicateT>
        token_finder(
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off )
        {
            return detail::token_finderF<PredicateT>( Pred, eCompress );
        }
# 236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/finder.hpp" 3 4
        template< typename ForwardIteratorT >
        inline detail::range_finderF<ForwardIteratorT>
        range_finder(
            ForwardIteratorT Begin,
            ForwardIteratorT End )
        {
            return detail::range_finderF<ForwardIteratorT>( Begin, End );
        }





        template< typename ForwardIteratorT >
        inline detail::range_finderF<ForwardIteratorT>
        range_finder( iterator_range<ForwardIteratorT> Range )
        {
            return detail::range_finderF<ForwardIteratorT>( Range );
        }

    }


    using algorithm::first_finder;
    using algorithm::last_finder;
    using algorithm::nth_finder;
    using algorithm::head_finder;
    using algorithm::tail_finder;
    using algorithm::token_finder;
    using algorithm::range_finder;

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT, typename FinderT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find(
            RangeT& Input,
            const FinderT& Finder)
        {
            iterator_range<typename range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            return Finder(::boost::begin(lit_input),::boost::end(lit_input));
        }
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        find_first(
            Range1T& Input,
            const Range2T& Search)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
        }
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        ifind_first(
            Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
        }
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        find_last(
            Range1T& Input,
            const Range2T& Search)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
        }
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        ifind_last(
            Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
        }
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        find_nth(
            Range1T& Input,
            const Range2T& Search,
            int Nth)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
        }
# 214 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        ifind_nth(
            Range1T& Input,
            const Range2T& Search,
            int Nth,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
        }
# 246 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find_head(
            RangeT& Input,
            int N)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
        }
# 277 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find_tail(
            RangeT& Input,
            int N)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
        }
# 306 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT, typename PredicateT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find_token(
            RangeT& Input,
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
        }

    }


    using algorithm::find;
    using algorithm::find_first;
    using algorithm::ifind_first;
    using algorithm::find_last;
    using algorithm::ifind_last;
    using algorithm::find_nth;
    using algorithm::ifind_nth;
    using algorithm::find_head;
    using algorithm::find_tail;
    using algorithm::find_token;

}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/predicate.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/predicate.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



            template<
                typename ForwardIterator1T,
                typename ForwardIterator2T,
                typename PredicateT>
            inline bool ends_with_iter_select(
                ForwardIterator1T Begin,
                ForwardIterator1T End,
                ForwardIterator2T SubBegin,
                ForwardIterator2T SubEnd,
                PredicateT Comp,
                std::bidirectional_iterator_tag)
            {
                ForwardIterator1T it=End;
                ForwardIterator2T pit=SubEnd;
                for(;it!=Begin && pit!=SubBegin;)
                {
                    if( !(Comp(*(--it),*(--pit))) )
                        return false;
                }

                return pit==SubBegin;
            }

            template<
                typename ForwardIterator1T,
                typename ForwardIterator2T,
                typename PredicateT>
            inline bool ends_with_iter_select(
                ForwardIterator1T Begin,
                ForwardIterator1T End,
                ForwardIterator2T SubBegin,
                ForwardIterator2T SubEnd,
                PredicateT Comp,
                std::forward_iterator_tag)
            {
                if ( SubBegin==SubEnd )
                {

                    return true;
                }

                iterator_range<ForwardIterator1T> Result
                    =last_finder(
                        ::boost::make_iterator_range(SubBegin, SubEnd),
                        Comp)(Begin, End);

                return !Result.empty() && Result.end()==End;
            }

        }
    }
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
namespace boost {
    namespace algorithm {
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
            inline bool starts_with(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            typedef typename
                range_const_iterator<Range1T>::type Iterator1T;
            typedef typename
                range_const_iterator<Range2T>::type Iterator2T;

            Iterator1T InputEnd=::boost::end(lit_input);
            Iterator2T TestEnd=::boost::end(lit_test);

            Iterator1T it=::boost::begin(lit_input);
            Iterator2T pit=::boost::begin(lit_test);
            for(;
                it!=InputEnd && pit!=TestEnd;
                ++it,++pit)
            {
                if( !(Comp(*it,*pit)) )
                    return false;
            }

            return pit==TestEnd;
        }





        template<typename Range1T, typename Range2T>
        inline bool starts_with(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::starts_with(Input, Test, is_equal());
        }
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool istarts_with(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
        }
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool ends_with(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            typedef typename
                range_const_iterator<Range1T>::type Iterator1T;
            typedef typename boost::detail::
                iterator_traits<Iterator1T>::iterator_category category;

            return detail::
                ends_with_iter_select(
                    ::boost::begin(lit_input),
                    ::boost::end(lit_input),
                    ::boost::begin(lit_test),
                    ::boost::end(lit_test),
                    Comp,
                    category());
        }






        template<typename Range1T, typename Range2T>
        inline bool ends_with(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::ends_with(Input, Test, is_equal());
        }
# 188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool iends_with(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
        }
# 212 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool contains(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            if (::boost::empty(lit_test))
            {

                return true;
            }


            bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
            return bResult;
        }





        template<typename Range1T, typename Range2T>
        inline bool contains(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::contains(Input, Test, is_equal());
        }
# 256 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool icontains(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
        }
# 283 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool equals(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            typedef typename
                range_const_iterator<Range1T>::type Iterator1T;
            typedef typename
                range_const_iterator<Range2T>::type Iterator2T;

            Iterator1T InputEnd=::boost::end(lit_input);
            Iterator2T TestEnd=::boost::end(lit_test);

            Iterator1T it=::boost::begin(lit_input);
            Iterator2T pit=::boost::begin(lit_test);
            for(;
                it!=InputEnd && pit!=TestEnd;
                ++it,++pit)
            {
                if( !(Comp(*it,*pit)) )
                    return false;
            }

            return (pit==TestEnd) && (it==InputEnd);
        }





        template<typename Range1T, typename Range2T>
        inline bool equals(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::equals(Input, Test, is_equal());
        }
# 340 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool iequals(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
        }
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool lexicographical_compare(
            const Range1T& Arg1,
            const Range2T& Arg2,
            PredicateT Pred)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2));

            return std::lexicographical_compare(
                ::boost::begin(lit_arg1),
                ::boost::end(lit_arg1),
                ::boost::begin(lit_arg2),
                ::boost::end(lit_arg2),
                Pred);
        }





        template<typename Range1T, typename Range2T>
            inline bool lexicographical_compare(
            const Range1T& Arg1,
            const Range2T& Arg2)
        {
            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
        }
# 414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool ilexicographical_compare(
            const Range1T& Arg1,
            const Range2T& Arg2,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
        }
# 437 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename RangeT, typename PredicateT>
        inline bool all(
            const RangeT& Input,
            PredicateT Pred)
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            typedef typename
                range_const_iterator<RangeT>::type Iterator1T;

            Iterator1T InputEnd=::boost::end(lit_input);
            for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It)
            {
                if (!Pred(*It))
                    return false;
            }

            return true;
        }

    }


    using algorithm::starts_with;
    using algorithm::istarts_with;
    using algorithm::ends_with;
    using algorithm::iends_with;
    using algorithm::contains;
    using algorithm::icontains;
    using algorithm::equals;
    using algorithm::iequals;
    using algorithm::all;
    using algorithm::lexicographical_compare;
    using algorithm::ilexicographical_compare;

}
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std_containers_traits.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std_containers_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/string_traits.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/string_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/yes_no_type.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/yes_no_type.hpp" 3 4
namespace boost {
    namespace algorithm {





        template<int I> struct size_descriptor
        {
            typedef char (& type)[I];
        };

        typedef size_descriptor<1>::type yes_type;
        typedef size_descriptor<2>::type no_type;

    }
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/string_traits.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/sequence_traits.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/sequence_traits.hpp" 3 4
namespace boost {
    namespace algorithm {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/sequence_traits.hpp" 3 4
        template< typename T >
        class has_native_replace
        {

        public:



            static const bool value=false;



            typedef mpl::bool_<has_native_replace<T>::value> type;
        };







        template< typename T >
        class has_stable_iterators
        {
        public:



            static const bool value=false;


            typedef mpl::bool_<has_stable_iterators<T>::value> type;
        };







        template< typename T >
        class has_const_time_insert
        {
        public:



            static const bool value=false;


            typedef mpl::bool_<has_const_time_insert<T>::value> type;
        };







        template< typename T >
        class has_const_time_erase
        {
        public:



            static const bool value=false;


            typedef mpl::bool_<has_const_time_erase<T>::value> type;
        };

    }
}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/string_traits.hpp" 2 3 4

namespace boost {
    namespace algorithm {





        template<typename T, typename TraitsT, typename AllocT>
        class has_native_replace< std::basic_string<T, TraitsT, AllocT> >
        {
        public:



            static const bool value=true;


        typedef mpl::bool_<has_native_replace<T>::value> type;
        };



    }
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std_containers_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/list_traits.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/list_traits.hpp" 3 4
# 1 "/usr/include/c++/10/list" 1 3 4
# 58 "/usr/include/c++/10/list" 3 4
       
# 59 "/usr/include/c++/10/list" 3




# 1 "/usr/include/c++/10/bits/stl_list.h" 1 3
# 63 "/usr/include/c++/10/bits/stl_list.h" 3
# 1 "/usr/include/c++/10/bits/allocated_ptr.h" 1 3
# 40 "/usr/include/c++/10/bits/allocated_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<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) };
    }


}
# 64 "/usr/include/c++/10/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; }
    };
  }




  template<typename _Tp>
    struct _List_node : public __detail::_List_node_base
    {

      __gnu_cxx::__aligned_membuf<_Tp> _M_storage;
      _Tp* _M_valptr() { return _M_storage._M_ptr(); }
      _Tp const* _M_valptr() const { return _M_storage._M_ptr(); }





    };






  template<typename _Tp>
    struct _List_iterator
    {
      typedef _List_iterator<_Tp> _Self;
      typedef _List_node<_Tp> _Node;

      typedef ptrdiff_t difference_type;
      typedef std::bidirectional_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef _Tp* pointer;
      typedef _Tp& reference;

      _List_iterator() noexcept
      : _M_node() { }

      explicit
      _List_iterator(__detail::_List_node_base* __x) noexcept
      : _M_node(__x) { }

      _Self
      _M_const_cast() const noexcept
      { return *this; }


      reference
      operator*() const noexcept
      { return *static_cast<_Node*>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Node*>(_M_node)->_M_valptr(); }

      _Self&
      operator++() noexcept
      {
 _M_node = _M_node->_M_next;
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_next;
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 _M_node = _M_node->_M_prev;
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_prev;
 return __tmp;
      }

      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }

      friend bool
      operator!=(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node != __y._M_node; }


      __detail::_List_node_base* _M_node;
    };






  template<typename _Tp>
    struct _List_const_iterator
    {
      typedef _List_const_iterator<_Tp> _Self;
      typedef const _List_node<_Tp> _Node;
      typedef _List_iterator<_Tp> iterator;

      typedef ptrdiff_t difference_type;
      typedef std::bidirectional_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef const _Tp* pointer;
      typedef const _Tp& reference;

      _List_const_iterator() noexcept
      : _M_node() { }

      explicit
      _List_const_iterator(const __detail::_List_node_base* __x)
      noexcept
      : _M_node(__x) { }

      _List_const_iterator(const iterator& __x) noexcept
      : _M_node(__x._M_node) { }

      iterator
      _M_const_cast() const noexcept
      { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); }


      reference
      operator*() const noexcept
      { return *static_cast<_Node*>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Node*>(_M_node)->_M_valptr(); }

      _Self&
      operator++() noexcept
      {
 _M_node = _M_node->_M_next;
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_next;
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 _M_node = _M_node->_M_prev;
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _M_node->_M_prev;
 return __tmp;
      }

      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }

      friend bool
      operator!=(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node != __y._M_node; }


      const __detail::_List_node_base* _M_node;
    };

namespace __cxx11 {

  template<typename _Tp, typename _Alloc>
    class _List_base
    {
    protected:
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Tp>::other _Tp_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tp_alloc_traits;
      typedef typename _Tp_alloc_traits::template
 rebind<_List_node<_Tp> >::other _Node_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;


      static size_t
      _S_distance(const __detail::_List_node_base* __first,
    const __detail::_List_node_base* __last)
      {
 size_t __n = 0;
 while (__first != __last)
   {
     __first = __first->_M_next;
     ++__n;
   }
 return __n;
      }


      struct _List_impl
      : public _Node_alloc_type
      {
 __detail::_List_node_header _M_node;

 _List_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value)

 : _Node_alloc_type()
 { }

 _List_impl(const _Node_alloc_type& __a) noexcept
 : _Node_alloc_type(__a)
 { }


 _List_impl(_List_impl&&) = default;

 _List_impl(_Node_alloc_type&& __a, _List_impl&& __x)
 : _Node_alloc_type(std::move(__a)), _M_node(std::move(__x._M_node))
 { }

 _List_impl(_Node_alloc_type&& __a) noexcept
 : _Node_alloc_type(std::move(__a))
 { }

      };

      _List_impl _M_impl;


      size_t _M_get_size() const { return _M_impl._M_node._M_size; }

      void _M_set_size(size_t __n) { _M_impl._M_node._M_size = __n; }

      void _M_inc_size(size_t __n) { _M_impl._M_node._M_size += __n; }

      void _M_dec_size(size_t __n) { _M_impl._M_node._M_size -= __n; }


      size_t
      _M_distance(const __detail::_List_node_base* __first,
    const __detail::_List_node_base* __last) const
      { return _S_distance(__first, __last); }


      size_t _M_node_count() const { return _M_get_size(); }
# 436 "/usr/include/c++/10/bits/stl_list.h" 3
      typename _Node_alloc_traits::pointer
      _M_get_node()
      { return _Node_alloc_traits::allocate(_M_impl, 1); }

      void
      _M_put_node(typename _Node_alloc_traits::pointer __p) noexcept
      { _Node_alloc_traits::deallocate(_M_impl, __p, 1); }

  public:
      typedef _Alloc allocator_type;

      _Node_alloc_type&
      _M_get_Node_allocator() noexcept
      { return _M_impl; }

      const _Node_alloc_type&
      _M_get_Node_allocator() const noexcept
      { return _M_impl; }


      _List_base() = default;




      _List_base(const _Node_alloc_type& __a) noexcept
      : _M_impl(__a)
      { }


      _List_base(_List_base&&) = default;


      _List_base(_List_base&& __x, _Node_alloc_type&& __a)
      : _M_impl(std::move(__a))
      {
 if (__x._M_get_Node_allocator() == _M_get_Node_allocator())
   _M_move_nodes(std::move(__x));

      }



      _List_base(_Node_alloc_type&& __a, _List_base&& __x)
      : _M_impl(std::move(__a), std::move(__x._M_impl))
      { }


      _List_base(_Node_alloc_type&& __a)
      : _M_impl(std::move(__a))
      { }

      void
      _M_move_nodes(_List_base&& __x)
      { _M_impl._M_node._M_move_nodes(std::move(__x._M_impl._M_node)); }



      ~_List_base() noexcept
      { _M_clear(); }

      void
      _M_clear() noexcept;

      void
      _M_init() noexcept
      { this->_M_impl._M_node._M_init(); }
    };
# 551 "/usr/include/c++/10/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class list : protected _List_base<_Tp, _Alloc>
    {
# 564 "/usr/include/c++/10/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;
# 626 "/usr/include/c++/10/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(); }
# 661 "/usr/include/c++/10/bits/stl_list.h" 3
    public:







      list() = default;
# 678 "/usr/include/c++/10/bits/stl_list.h" 3
      explicit
      list(const allocator_type& __a) noexcept
      : _Base(_Node_alloc_type(__a)) { }
# 691 "/usr/include/c++/10/bits/stl_list.h" 3
      explicit
      list(size_type __n, const allocator_type& __a = allocator_type())
      : _Base(_Node_alloc_type(__a))
      { _M_default_initialize(__n); }
# 704 "/usr/include/c++/10/bits/stl_list.h" 3
      list(size_type __n, const value_type& __value,
    const allocator_type& __a = allocator_type())
      : _Base(_Node_alloc_type(__a))
      { _M_fill_initialize(__n, __value); }
# 731 "/usr/include/c++/10/bits/stl_list.h" 3
      list(const list& __x)
      : _Base(_Node_alloc_traits::
       _S_select_on_copy(__x._M_get_Node_allocator()))
      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
# 744 "/usr/include/c++/10/bits/stl_list.h" 3
      list(list&&) = default;
# 754 "/usr/include/c++/10/bits/stl_list.h" 3
      list(initializer_list<value_type> __l,
    const allocator_type& __a = allocator_type())
      : _Base(_Node_alloc_type(__a))
      { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }

      list(const list& __x, const allocator_type& __a)
      : _Base(_Node_alloc_type(__a))
      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }

    private:
      list(list&& __x, const allocator_type& __a, true_type) noexcept
      : _Base(_Node_alloc_type(__a), std::move(__x))
      { }

      list(list&& __x, const allocator_type& __a, false_type)
      : _Base(_Node_alloc_type(__a))
      {
 if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator())
   this->_M_move_nodes(std::move(__x));
 else
   insert(begin(), std::__make_move_if_noexcept_iterator(__x.begin()),
     std::__make_move_if_noexcept_iterator(__x.end()));
      }

    public:
      list(list&& __x, const allocator_type& __a)
      noexcept(_Node_alloc_traits::_S_always_equal())
      : list(std::move(__x), __a,
      typename _Node_alloc_traits::is_always_equal{})
      { }
# 797 "/usr/include/c++/10/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()); }
# 823 "/usr/include/c++/10/bits/stl_list.h" 3
      ~list() = default;
# 834 "/usr/include/c++/10/bits/stl_list.h" 3
      list&
      operator=(const list& __x);
# 848 "/usr/include/c++/10/bits/stl_list.h" 3
      list&
      operator=(list&& __x)
      noexcept(_Node_alloc_traits::_S_nothrow_move())
      {
 constexpr bool __move_storage =
   _Node_alloc_traits::_S_propagate_on_move_assign()
   || _Node_alloc_traits::_S_always_equal();
 _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
 return *this;
      }
# 866 "/usr/include/c++/10/bits/stl_list.h" 3
      list&
      operator=(initializer_list<value_type> __l)
      {
 this->assign(__l.begin(), __l.end());
 return *this;
      }
# 884 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 901 "/usr/include/c++/10/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()); }
# 925 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      assign(initializer_list<value_type> __l)
      { this->_M_assign_dispatch(__l.begin(), __l.end(), __false_type()); }



      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_Base::_M_get_Node_allocator()); }






      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_node._M_next); }






      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_node._M_next); }






      iterator
      end() noexcept
      { return iterator(&this->_M_impl._M_node); }






      const_iterator
      end() const noexcept
      { return const_iterator(&this->_M_impl._M_node); }






      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }






      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }






      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }






      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }







      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_node._M_next); }






      const_iterator
      cend() const noexcept
      { return const_iterator(&this->_M_impl._M_node); }






      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }






      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }







      [[__nodiscard__]] bool
      empty() const noexcept
      { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }


      size_type
      size() const noexcept
      { return _M_node_count(); }


      size_type
      max_size() const noexcept
      { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); }
# 1074 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      resize(size_type __new_size);
# 1087 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      resize(size_type __new_size, const value_type& __x);
# 1109 "/usr/include/c++/10/bits/stl_list.h" 3
      reference
      front() noexcept
      { return *begin(); }





      const_reference
      front() const noexcept
      { return *begin(); }





      reference
      back() noexcept
      {
 iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }





      const_reference
      back() const noexcept
      {
 const_iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }
# 1156 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      push_front(const value_type& __x)
      { this->_M_insert(begin(), __x); }


      void
      push_front(value_type&& __x)
      { this->_M_insert(begin(), std::move(__x)); }

      template<typename... _Args>

 reference



 emplace_front(_Args&&... __args)
 {
   this->_M_insert(begin(), std::forward<_Args>(__args)...);

   return front();

 }
# 1192 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      pop_front() noexcept
      { this->_M_erase(begin()); }
# 1206 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      push_back(const value_type& __x)
      { this->_M_insert(end(), __x); }


      void
      push_back(value_type&& __x)
      { this->_M_insert(end(), std::move(__x)); }

      template<typename... _Args>

 reference



 emplace_back(_Args&&... __args)
 {
   this->_M_insert(end(), std::forward<_Args>(__args)...);

 return back();

 }
# 1241 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      pop_back() noexcept
      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
# 1258 "/usr/include/c++/10/bits/stl_list.h" 3
      template<typename... _Args>
 iterator
 emplace(const_iterator __position, _Args&&... __args);
# 1273 "/usr/include/c++/10/bits/stl_list.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1303 "/usr/include/c++/10/bits/stl_list.h" 3
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return emplace(__position, std::move(__x)); }
# 1322 "/usr/include/c++/10/bits/stl_list.h" 3
      iterator
      insert(const_iterator __p, initializer_list<value_type> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }
# 1342 "/usr/include/c++/10/bits/stl_list.h" 3
      iterator
      insert(const_iterator __position, size_type __n, const value_type& __x);
# 1381 "/usr/include/c++/10/bits/stl_list.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 iterator
 insert(const_iterator __position, _InputIterator __first,
        _InputIterator __last);
# 1425 "/usr/include/c++/10/bits/stl_list.h" 3
      iterator

      erase(const_iterator __position) noexcept;
# 1450 "/usr/include/c++/10/bits/stl_list.h" 3
      iterator

      erase(const_iterator __first, const_iterator __last) noexcept



      {
 while (__first != __last)
   __first = erase(__first);
 return __last._M_const_cast();
      }
# 1473 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      swap(list& __x) noexcept
      {
 __detail::_List_node_base::swap(this->_M_impl._M_node,
     __x._M_impl._M_node);

 size_t __xsize = __x._M_get_size();
 __x._M_set_size(this->_M_get_size());
 this->_M_set_size(__xsize);

 _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(),
           __x._M_get_Node_allocator());
      }







      void
      clear() noexcept
      {
 _Base::_M_clear();
 _Base::_M_init();
      }
# 1512 "/usr/include/c++/10/bits/stl_list.h" 3
      void

      splice(const_iterator __position, list&& __x) noexcept



      {
 if (!__x.empty())
   {
     _M_check_equal_allocators(__x);

     this->_M_transfer(__position._M_const_cast(),
         __x.begin(), __x.end());

     this->_M_inc_size(__x._M_get_size());
     __x._M_set_size(0);
   }
      }


      void
      splice(const_iterator __position, list& __x) noexcept
      { splice(__position, std::move(__x)); }
# 1548 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
# 1563 "/usr/include/c++/10/bits/stl_list.h" 3
      {
 iterator __j = __i._M_const_cast();
 ++__j;
 if (__position == __i || __position == __j)
   return;

 if (this != std::__addressof(__x))
   _M_check_equal_allocators(__x);

 this->_M_transfer(__position._M_const_cast(),
     __i._M_const_cast(), __j);

 this->_M_inc_size(1);
 __x._M_dec_size(1);
      }
# 1590 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
      { splice(__position, std::move(__x), __i); }
# 1609 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      splice(const_iterator __position, list&& __x, const_iterator __first,
      const_iterator __last) noexcept
# 1629 "/usr/include/c++/10/bits/stl_list.h" 3
      {
 if (__first != __last)
   {
     if (this != std::__addressof(__x))
       _M_check_equal_allocators(__x);

     size_t __n = _S_distance(__first, __last);
     this->_M_inc_size(__n);
     __x._M_dec_size(__n);

     this->_M_transfer(__position._M_const_cast(),
         __first._M_const_cast(),
         __last._M_const_cast());
   }
      }
# 1659 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      splice(const_iterator __position, list& __x, const_iterator __first,
      const_iterator __last) noexcept
      { splice(__position, std::move(__x), __first, __last); }


    private:






      typedef void __remove_return_type;


    public:
# 1688 "/usr/include/c++/10/bits/stl_list.h" 3
     
      __remove_return_type
      remove(const _Tp& __value);
# 1703 "/usr/include/c++/10/bits/stl_list.h" 3
      template<typename _Predicate>
 __remove_return_type
 remove_if(_Predicate);
# 1717 "/usr/include/c++/10/bits/stl_list.h" 3
     
      __remove_return_type
      unique();
# 1733 "/usr/include/c++/10/bits/stl_list.h" 3
      template<typename _BinaryPredicate>
 __remove_return_type
 unique(_BinaryPredicate);
# 1749 "/usr/include/c++/10/bits/stl_list.h" 3
      void
      merge(list&& __x);

      void
      merge(list& __x)
      { merge(std::move(__x)); }
# 1774 "/usr/include/c++/10/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); }
# 1793 "/usr/include/c++/10/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);
# 1871 "/usr/include/c++/10/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); }
# 1903 "/usr/include/c++/10/bits/stl_list.h" 3
     template<typename... _Args>
       void
       _M_insert(iterator __position, _Args&&... __args)
       {
  _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
  __tmp->_M_hook(__position._M_node);
  this->_M_inc_size(1);
       }



      void
      _M_erase(iterator __position) noexcept
      {
 this->_M_dec_size(1);
 __position._M_node->_M_unhook();
 _Node* __n = static_cast<_Node*>(__position._M_node);

 _Node_alloc_traits::destroy(_M_get_Node_allocator(), __n->_M_valptr());




 _M_put_node(__n);
      }


      void
      _M_check_equal_allocators(list& __x) noexcept
      {
 if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
     _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
   __builtin_abort();
      }


      const_iterator
      _M_resize_pos(size_type& __new_size) const;


      void
      _M_move_assign(list&& __x, true_type) noexcept
      {
 this->_M_clear();
 this->_M_move_nodes(std::move(__x));
 std::__alloc_on_move(this->_M_get_Node_allocator(),
        __x._M_get_Node_allocator());
      }

      void
      _M_move_assign(list&& __x, false_type)
      {
 if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator())
   _M_move_assign(std::move(__x), true_type{});
 else


   _M_assign_dispatch(std::make_move_iterator(__x.begin()),
        std::make_move_iterator(__x.end()),
        __false_type{});
      }

    };


  template<typename _InputIterator, typename _ValT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_ValT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    list(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> list<_ValT, _Allocator>;


}
# 1989 "/usr/include/c++/10/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    {

      if (__x.size() != __y.size())
 return false;


      typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
      const_iterator __end1 = __x.end();
      const_iterator __end2 = __y.end();

      const_iterator __i1 = __x.begin();
      const_iterator __i2 = __y.begin();
      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
 {
   ++__i1;
   ++__i2;
 }
      return __i1 == __end1 && __i2 == __end2;
    }
# 2023 "/usr/include/c++/10/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end()); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Alloc>
    inline void
    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }






  template<typename _Tp>
    inline ptrdiff_t
    __distance(std::_List_iterator<_Tp> __first,
        std::_List_iterator<_Tp> __last,
        input_iterator_tag __tag)
    {
      typedef std::_List_const_iterator<_Tp> _CIter;
      return std::__distance(_CIter(__first), _CIter(__last), __tag);
    }

  template<typename _Tp>
    inline ptrdiff_t
    __distance(std::_List_const_iterator<_Tp> __first,
        std::_List_const_iterator<_Tp> __last,
        input_iterator_tag)
    {
      typedef __detail::_List_node_header _Sentinel;
      std::_List_const_iterator<_Tp> __beyond = __last;
      ++__beyond;
      const bool __whole = __first == __beyond;
      if (__builtin_constant_p (__whole) && __whole)
 return static_cast<const _Sentinel*>(__last._M_node)->_M_size;

      ptrdiff_t __n = 0;
      while (__first != __last)
 {
   ++__first;
   ++__n;
 }
      return __n;
    }



}
# 64 "/usr/include/c++/10/list" 2 3
# 1 "/usr/include/c++/10/bits/list.tcc" 1 3
# 59 "/usr/include/c++/10/bits/list.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Alloc>
    void
    _List_base<_Tp, _Alloc>::
    _M_clear() noexcept
    {
      typedef _List_node<_Tp> _Node;
      __detail::_List_node_base* __cur = _M_impl._M_node._M_next;
      while (__cur != &_M_impl._M_node)
 {
   _Node* __tmp = static_cast<_Node*>(__cur);
   __cur = __tmp->_M_next;
   _Tp* __val = __tmp->_M_valptr();

   _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val);



   _M_put_node(__tmp);
 }
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      typename list<_Tp, _Alloc>::iterator
      list<_Tp, _Alloc>::
      emplace(const_iterator __position, _Args&&... __args)
      {
 _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
 __tmp->_M_hook(__position._M_const_cast()._M_node);
 this->_M_inc_size(1);
 return iterator(__tmp);
      }


  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::

    insert(const_iterator __position, const value_type& __x)



    {
      _Node* __tmp = _M_create_node(__x);
      __tmp->_M_hook(__position._M_const_cast()._M_node);
      this->_M_inc_size(1);
      return iterator(__tmp);
    }


  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::
    insert(const_iterator __position, size_type __n, const value_type& __x)
    {
      if (__n)
 {
   list __tmp(__n, __x, get_allocator());
   iterator __it = __tmp.begin();
   splice(__position, __tmp);
   return __it;
 }
      return __position._M_const_cast();
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator, typename>
      typename list<_Tp, _Alloc>::iterator
      list<_Tp, _Alloc>::
      insert(const_iterator __position, _InputIterator __first,
      _InputIterator __last)
      {
 list __tmp(__first, __last, get_allocator());
 if (!__tmp.empty())
   {
     iterator __it = __tmp.begin();
     splice(__position, __tmp);
     return __it;
   }
 return __position._M_const_cast();
      }


  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::

    erase(const_iterator __position) noexcept



    {
      iterator __ret = iterator(__position._M_node->_M_next);
      _M_erase(__position._M_const_cast());
      return __ret;
    }
# 173 "/usr/include/c++/10/bits/list.tcc" 3
  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::const_iterator
    list<_Tp, _Alloc>::
    _M_resize_pos(size_type& __new_size) const
    {
      const_iterator __i;

      const size_type __len = size();
      if (__new_size < __len)
 {
   if (__new_size <= __len / 2)
     {
       __i = begin();
       std::advance(__i, __new_size);
     }
   else
     {
       __i = end();
       ptrdiff_t __num_erase = __len - __new_size;
       std::advance(__i, -__num_erase);
     }
   __new_size = 0;
   return __i;
 }
      else
 __i = end();





      __new_size -= __len;
      return __i;
    }


  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    _M_default_append(size_type __n)
    {
      size_type __i = 0;
      try
 {
   for (; __i < __n; ++__i)
     emplace_back();
 }
      catch(...)
 {
   for (; __i; --__i)
     pop_back();
   throw;
 }
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    resize(size_type __new_size)
    {
      const_iterator __i = _M_resize_pos(__new_size);
      if (__new_size)
 _M_default_append(__new_size);
      else
        erase(__i, end());
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    resize(size_type __new_size, const value_type& __x)
    {
      const_iterator __i = _M_resize_pos(__new_size);
      if (__new_size)
        insert(end(), __new_size, __x);
      else
        erase(__i, end());
    }
# 265 "/usr/include/c++/10/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)
    {
      size_type __removed __attribute__((__unused__)) = 0;
      iterator __first = begin();
      iterator __last = end();
      iterator __extra = __last;
      while (__first != __last)
 {
   iterator __next = __first;
   ++__next;
   if (*__first == __value)
     {



       if (std::__addressof(*__first) != std::__addressof(__value))
  {
    _M_erase(__first);
    ;
  }
       else
  __extra = __first;
     }
   __first = __next;
 }
      if (__extra != __last)
 {
   _M_erase(__extra);
   ;
 }
      return ;
    }

  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::__remove_return_type
    list<_Tp, _Alloc>::
    unique()
    {
      iterator __first = begin();
      iterator __last = end();
      if (__first == __last)
 return ;
      size_type __removed __attribute__((__unused__)) = 0;
      iterator __next = __first;
      while (++__next != __last)
 {
   if (*__first == *__next)
     {
       _M_erase(__next);
       ;
     }
   else
     __first = __next;
   __next = __first;
 }
      return ;
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::

    merge(list&& __x)



    {


      if (this != std::__addressof(__x))
 {
   _M_check_equal_allocators(__x);

   iterator __first1 = begin();
   iterator __last1 = end();
   iterator __first2 = __x.begin();
   iterator __last2 = __x.end();
   const size_t __orig_size = __x.size();
   try {
     while (__first1 != __last1 && __first2 != __last2)
       if (*__first2 < *__first1)
  {
    iterator __next = __first2;
    _M_transfer(__first1, __first2, ++__next);
    __first2 = __next;
  }
       else
  ++__first1;
     if (__first2 != __last2)
       _M_transfer(__last1, __first2, __last2);

     this->_M_inc_size(__x._M_get_size());
     __x._M_set_size(0);
   }
   catch(...)
     {
       const size_t __dist = std::distance(__first2, __last2);
       this->_M_inc_size(__orig_size - __dist);
       __x._M_set_size(__dist);
       throw;
     }
 }
    }

  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp, _Alloc>::

      merge(list&& __x, _StrictWeakOrdering __comp)



      {


 if (this != std::__addressof(__x))
   {
     _M_check_equal_allocators(__x);

     iterator __first1 = begin();
     iterator __last1 = end();
     iterator __first2 = __x.begin();
     iterator __last2 = __x.end();
     const size_t __orig_size = __x.size();
     try
       {
  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first2, *__first1))
      {
        iterator __next = __first2;
        _M_transfer(__first1, __first2, ++__next);
        __first2 = __next;
      }
    else
      ++__first1;
  if (__first2 != __last2)
    _M_transfer(__last1, __first2, __last2);

  this->_M_inc_size(__x._M_get_size());
  __x._M_set_size(0);
       }
     catch(...)
       {
  const size_t __dist = std::distance(__first2, __last2);
  this->_M_inc_size(__orig_size - __dist);
  __x._M_set_size(__dist);
  throw;
       }
   }
      }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    sort()
    {

      if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
   && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
      {
        list __carry;
        list __tmp[64];
        list * __fill = __tmp;
        list * __counter;
 try
   {
     do
       {
  __carry.splice(__carry.begin(), *this, begin());

  for(__counter = __tmp;
      __counter != __fill && !__counter->empty();
      ++__counter)
    {
      __counter->merge(__carry);
      __carry.swap(*__counter);
    }
  __carry.swap(*__counter);
  if (__counter == __fill)
    ++__fill;
       }
     while ( !empty() );

     for (__counter = __tmp + 1; __counter != __fill; ++__counter)
       __counter->merge(*(__counter - 1));
     swap( *(__fill - 1) );
   }
 catch(...)
   {
     this->splice(this->end(), __carry);
     for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
       this->splice(this->end(), __tmp[__i]);
     throw;
   }
      }
    }

  template<typename _Tp, typename _Alloc>
    template <typename _Predicate>
      typename list<_Tp, _Alloc>::__remove_return_type
      list<_Tp, _Alloc>::
      remove_if(_Predicate __pred)
      {
 size_type __removed __attribute__((__unused__)) = 0;
        iterator __first = begin();
        iterator __last = end();
        while (__first != __last)
   {
     iterator __next = __first;
     ++__next;
     if (__pred(*__first))
       {
  _M_erase(__first);
  ;
       }
     __first = __next;
   }
 return ;
      }

  template<typename _Tp, typename _Alloc>
    template <typename _BinaryPredicate>
      typename list<_Tp, _Alloc>::__remove_return_type
      list<_Tp, _Alloc>::
      unique(_BinaryPredicate __binary_pred)
      {
        iterator __first = begin();
        iterator __last = end();
        if (__first == __last)
   return ;
        size_type __removed __attribute__((__unused__)) = 0;
        iterator __next = __first;
        while (++__next != __last)
   {
     if (__binary_pred(*__first, *__next))
       {
  _M_erase(__next);
  ;
       }
     else
       __first = __next;
     __next = __first;
   }
 return ;
      }



  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp, _Alloc>::
      sort(_StrictWeakOrdering __comp)
      {

 if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
     && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
   {
     list __carry;
     list __tmp[64];
     list * __fill = __tmp;
     list * __counter;
     try
       {
  do
    {
      __carry.splice(__carry.begin(), *this, begin());

      for(__counter = __tmp;
   __counter != __fill && !__counter->empty();
   ++__counter)
        {
   __counter->merge(__carry, __comp);
   __carry.swap(*__counter);
        }
      __carry.swap(*__counter);
      if (__counter == __fill)
        ++__fill;
    }
  while ( !empty() );

  for (__counter = __tmp + 1; __counter != __fill; ++__counter)
    __counter->merge(*(__counter - 1), __comp);
  swap(*(__fill - 1));
       }
     catch(...)
       {
  this->splice(this->end(), __carry);
  for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
    this->splice(this->end(), __tmp[__i]);
  throw;
       }
   }
      }



}
# 65 "/usr/include/c++/10/list" 2 3






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

  namespace pmr
  {
    template<typename _Tp> class polymorphic_allocator;
    template<typename _Tp>
      using list = std::list<_Tp, polymorphic_allocator<_Tp>>;
  }

}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/list_traits.hpp" 2 3 4


namespace boost {
    namespace algorithm {





        template<typename T, typename AllocT>
        class has_stable_iterators< ::std::list<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_stable_iterators<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_insert< ::std::list<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_insert<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_erase< ::std::list<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_erase<T>::value> type;
        };


    }
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std_containers_traits.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/slist_traits.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/slist_traits.hpp" 3 4
# 1 "/usr/include/c++/10/ext/slist" 1 3 4
# 54 "/usr/include/c++/10/ext/slist" 3 4
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{


  struct _Slist_node_base
  {
    _Slist_node_base* _M_next;
  };

  inline _Slist_node_base*
  __slist_make_link(_Slist_node_base* __prev_node,
      _Slist_node_base* __new_node)
  {
    __new_node->_M_next = __prev_node->_M_next;
    __prev_node->_M_next = __new_node;
    return __new_node;
  }

  inline _Slist_node_base*
  __slist_previous(_Slist_node_base* __head,
     const _Slist_node_base* __node)
  {
    while (__head && __head->_M_next != __node)
      __head = __head->_M_next;
    return __head;
  }

  inline const _Slist_node_base*
  __slist_previous(const _Slist_node_base* __head,
     const _Slist_node_base* __node)
  {
    while (__head && __head->_M_next != __node)
      __head = __head->_M_next;
    return __head;
  }

  inline void
  __slist_splice_after(_Slist_node_base* __pos,
         _Slist_node_base* __before_first,
         _Slist_node_base* __before_last)
  {
    if (__pos != __before_first && __pos != __before_last)
      {
 _Slist_node_base* __first = __before_first->_M_next;
 _Slist_node_base* __after = __pos->_M_next;
 __before_first->_M_next = __before_last->_M_next;
 __pos->_M_next = __first;
 __before_last->_M_next = __after;
      }
  }

  inline void
  __slist_splice_after(_Slist_node_base* __pos, _Slist_node_base* __head)
  {
    _Slist_node_base* __before_last = __slist_previous(__head, 0);
    if (__before_last != __head)
      {
 _Slist_node_base* __after = __pos->_M_next;
 __pos->_M_next = __head->_M_next;
 __head->_M_next = 0;
 __before_last->_M_next = __after;
      }
  }

  inline _Slist_node_base*
  __slist_reverse(_Slist_node_base* __node)
  {
    _Slist_node_base* __result = __node;
    __node = __node->_M_next;
    __result->_M_next = 0;
    while(__node)
      {
 _Slist_node_base* __next = __node->_M_next;
 __node->_M_next = __result;
 __result = __node;
 __node = __next;
      }
    return __result;
  }

  inline std::size_t
  __slist_size(_Slist_node_base* __node)
  {
    std::size_t __result = 0;
    for (; __node != 0; __node = __node->_M_next)
      ++__result;
    return __result;
  }

  template <class _Tp>
    struct _Slist_node : public _Slist_node_base
    {
      _Tp _M_data;
    };

  struct _Slist_iterator_base
  {
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
    typedef std::forward_iterator_tag iterator_category;

    _Slist_node_base* _M_node;

    _Slist_iterator_base(_Slist_node_base* __x)
    : _M_node(__x) {}

    void
    _M_incr()
    { _M_node = _M_node->_M_next; }

    bool
    operator==(const _Slist_iterator_base& __x) const
    { return _M_node == __x._M_node; }

    bool
    operator!=(const _Slist_iterator_base& __x) const
    { return _M_node != __x._M_node; }
  };

  template <class _Tp, class _Ref, class _Ptr>
    struct _Slist_iterator : public _Slist_iterator_base
    {
      typedef _Slist_iterator<_Tp, _Tp&, _Tp*> iterator;
      typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
      typedef _Slist_iterator<_Tp, _Ref, _Ptr> _Self;

      typedef _Tp value_type;
      typedef _Ptr pointer;
      typedef _Ref reference;
      typedef _Slist_node<_Tp> _Node;

      explicit
      _Slist_iterator(_Node* __x)
      : _Slist_iterator_base(__x) {}

      _Slist_iterator()
      : _Slist_iterator_base(0) {}

      _Slist_iterator(const iterator& __x)
      : _Slist_iterator_base(__x._M_node) {}

      reference
      operator*() const
      { return ((_Node*) _M_node)->_M_data; }

      pointer
      operator->() const
      { return &(operator*()); }

      _Self&
      operator++()
      {
 _M_incr();
 return *this;
      }

      _Self
      operator++(int)
      {
 _Self __tmp = *this;
 _M_incr();
 return __tmp;
      }
    };

  template <class _Tp, class _Alloc>
    struct _Slist_base
    : public __alloc_traits<_Alloc>::template rebind<_Slist_node<_Tp> >::other
    {
      typedef typename __alloc_traits<_Alloc>::template
 rebind<_Slist_node<_Tp> >::other _Node_alloc;
      typedef _Alloc allocator_type;

      allocator_type
      get_allocator() const
      { return *static_cast<const _Node_alloc*>(this); }

      _Slist_base(const allocator_type& __a)
      : _Node_alloc(__a)
      { this->_M_head._M_next = 0; }

      ~_Slist_base()
      { _M_erase_after(&this->_M_head, 0); }

    protected:
      _Slist_node_base _M_head;

      _Slist_node<_Tp>*
      _M_get_node()
      { return _Node_alloc::allocate(1); }

      void
      _M_put_node(_Slist_node<_Tp>* __p)
      { _Node_alloc::deallocate(__p, 1); }

    protected:
      _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)
      {
 _Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);
 _Slist_node_base* __next_next = __next->_M_next;
 __pos->_M_next = __next_next;
 allocator_type __a = get_allocator();
 __alloc_traits<allocator_type>::destroy(__a, &__next->_M_data);
 _M_put_node(__next);
 return __next_next;
      }
      _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);
    };

  template <class _Tp, class _Alloc>
    _Slist_node_base*
    _Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first,
         _Slist_node_base* __last_node)
    {
      _Slist_node<_Tp>* __cur = (_Slist_node<_Tp>*) (__before_first->_M_next);
      while (__cur != __last_node)
 {
   _Slist_node<_Tp>* __tmp = __cur;
   __cur = (_Slist_node<_Tp>*) __cur->_M_next;
   allocator_type __a = get_allocator();
   __alloc_traits<allocator_type>::destroy(__a, &__tmp->_M_data);
   _M_put_node(__tmp);
 }
      __before_first->_M_next = __last_node;
      return __last_node;
    }






  template <class _Tp, class _Alloc = std::allocator<_Tp> >
    class slist : private _Slist_base<_Tp,_Alloc>
    {

     

    private:
      typedef _Slist_base<_Tp,_Alloc> _Base;

    public:
      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 std::size_t size_type;
      typedef std::ptrdiff_t difference_type;

      typedef _Slist_iterator<_Tp, _Tp&, _Tp*> iterator;
      typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;

      typedef typename _Base::allocator_type allocator_type;

      allocator_type
      get_allocator() const
      { return _Base::get_allocator(); }

    private:
      typedef _Slist_node<_Tp> _Node;
      typedef _Slist_node_base _Node_base;
      typedef _Slist_iterator_base _Iterator_base;

      _Node*
      _M_create_node(const value_type& __x)
      {
 _Node* __node = this->_M_get_node();
 try
   {
     allocator_type __a = get_allocator();
     __alloc_traits<allocator_type>::construct(__a, &__node->_M_data,
            __x);
     __node->_M_next = 0;
   }
 catch(...)
   {
     this->_M_put_node(__node);
     throw;
   }
 return __node;
      }

      _Node*
      _M_create_node()
      {
 _Node* __node = this->_M_get_node();
 try
   {
     allocator_type __a = get_allocator();
     __alloc_traits<allocator_type>::construct(__a, &__node->_M_data,
            value_type());
     __node->_M_next = 0;
   }
 catch(...)
   {
     this->_M_put_node(__node);
     throw;
   }
 return __node;
      }

    public:
      explicit
      slist(const allocator_type& __a = allocator_type())
      : _Base(__a) {}

      slist(size_type __n, const value_type& __x,
     const allocator_type& __a = allocator_type())
      : _Base(__a)
      { _M_insert_after_fill(&this->_M_head, __n, __x); }

      explicit
      slist(size_type __n)
      : _Base(allocator_type())
      { _M_insert_after_fill(&this->_M_head, __n, value_type()); }



      template <class _InputIterator>
        slist(_InputIterator __first, _InputIterator __last,
       const allocator_type& __a = allocator_type())
 : _Base(__a)
        { _M_insert_after_range(&this->_M_head, __first, __last); }

      slist(const slist& __x)
      : _Base(__x.get_allocator())
      { _M_insert_after_range(&this->_M_head, __x.begin(), __x.end()); }

      slist&
      operator= (const slist& __x);

      ~slist() {}

    public:





      void
      assign(size_type __n, const _Tp& __val)
      { _M_fill_assign(__n, __val); }

      void
      _M_fill_assign(size_type __n, const _Tp& __val);

      template <class _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {
   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_assign_dispatch(__first, __last, _Integral());
 }

      template <class _Integer>
      void
      _M_assign_dispatch(_Integer __n, _Integer __val, std::__true_type)
      { _M_fill_assign((size_type) __n, (_Tp) __val); }

      template <class _InputIterator>
      void
      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    std::__false_type);

    public:

      iterator
      begin()
      { return iterator((_Node*)this->_M_head._M_next); }

      const_iterator
      begin() const
      { return const_iterator((_Node*)this->_M_head._M_next);}

      iterator
      end()
      { return iterator(0); }

      const_iterator
      end() const
      { return const_iterator(0); }
# 444 "/usr/include/c++/10/ext/slist" 3 4
      iterator
      before_begin()
      { return iterator((_Node*) &this->_M_head); }

      const_iterator
      before_begin() const
      { return const_iterator((_Node*) &this->_M_head); }

      size_type
      size() const
      { return __slist_size(this->_M_head._M_next); }

      size_type
      max_size() const
      { return size_type(-1); }

      [[__nodiscard__]] bool
      empty() const
      { return this->_M_head._M_next == 0; }

      void
      swap(slist& __x)
      { std::swap(this->_M_head._M_next, __x._M_head._M_next); }

    public:

      reference
      front()
      { return ((_Node*) this->_M_head._M_next)->_M_data; }

      const_reference
      front() const
      { return ((_Node*) this->_M_head._M_next)->_M_data; }

      void
      push_front(const value_type& __x)
      { __slist_make_link(&this->_M_head, _M_create_node(__x)); }

      void
      push_front()
      { __slist_make_link(&this->_M_head, _M_create_node()); }

      void
      pop_front()
      {
 _Node* __node = (_Node*) this->_M_head._M_next;
 this->_M_head._M_next = __node->_M_next;
 allocator_type __a = get_allocator();
 __alloc_traits<allocator_type>::destroy(__a, &__node->_M_data);
 this->_M_put_node(__node);
      }

      iterator
      previous(const_iterator __pos)
      { return iterator((_Node*) __slist_previous(&this->_M_head,
        __pos._M_node)); }

      const_iterator
      previous(const_iterator __pos) const
      { return const_iterator((_Node*) __slist_previous(&this->_M_head,
       __pos._M_node)); }

    private:
      _Node*
      _M_insert_after(_Node_base* __pos, const value_type& __x)
      { return (_Node*) (__slist_make_link(__pos, _M_create_node(__x))); }

      _Node*
      _M_insert_after(_Node_base* __pos)
      { return (_Node*) (__slist_make_link(__pos, _M_create_node())); }

      void
      _M_insert_after_fill(_Node_base* __pos,
      size_type __n, const value_type& __x)
      {
 for (size_type __i = 0; __i < __n; ++__i)
   __pos = __slist_make_link(__pos, _M_create_node(__x));
      }


      template <class _InIterator>
        void
        _M_insert_after_range(_Node_base* __pos,
         _InIterator __first, _InIterator __last)
        {
   typedef typename std::__is_integer<_InIterator>::__type _Integral;
   _M_insert_after_range(__pos, __first, __last, _Integral());
 }

      template <class _Integer>
        void
        _M_insert_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
         std::__true_type)
        { _M_insert_after_fill(__pos, __n, __x); }

      template <class _InIterator>
        void
        _M_insert_after_range(_Node_base* __pos,
         _InIterator __first, _InIterator __last,
         std::__false_type)
        {
   while (__first != __last)
     {
       __pos = __slist_make_link(__pos, _M_create_node(*__first));
       ++__first;
     }
 }

    public:
      iterator
      insert_after(iterator __pos, const value_type& __x)
      { return iterator(_M_insert_after(__pos._M_node, __x)); }

      iterator
      insert_after(iterator __pos)
      { return insert_after(__pos, value_type()); }

      void
      insert_after(iterator __pos, size_type __n, const value_type& __x)
      { _M_insert_after_fill(__pos._M_node, __n, __x); }



      template <class _InIterator>
        void
        insert_after(iterator __pos, _InIterator __first, _InIterator __last)
        { _M_insert_after_range(__pos._M_node, __first, __last); }

      iterator
      insert(iterator __pos, const value_type& __x)
      { return iterator(_M_insert_after(__slist_previous(&this->_M_head,
        __pos._M_node),
     __x)); }

      iterator
      insert(iterator __pos)
      { return iterator(_M_insert_after(__slist_previous(&this->_M_head,
        __pos._M_node),
     value_type())); }

      void
      insert(iterator __pos, size_type __n, const value_type& __x)
      { _M_insert_after_fill(__slist_previous(&this->_M_head, __pos._M_node),
        __n, __x); }



      template <class _InIterator>
        void
        insert(iterator __pos, _InIterator __first, _InIterator __last)
        { _M_insert_after_range(__slist_previous(&this->_M_head, __pos._M_node),
    __first, __last); }

    public:
      iterator
      erase_after(iterator __pos)
      { return iterator((_Node*) this->_M_erase_after(__pos._M_node)); }

      iterator
      erase_after(iterator __before_first, iterator __last)
      {
 return iterator((_Node*) this->_M_erase_after(__before_first._M_node,
            __last._M_node));
      }

      iterator
      erase(iterator __pos)
      {
 return iterator((_Node*) this->_M_erase_after
   (__slist_previous(&this->_M_head, __pos._M_node)));
      }

      iterator
      erase(iterator __first, iterator __last)
      {
 return iterator((_Node*) this->_M_erase_after
   (__slist_previous(&this->_M_head, __first._M_node),
    __last._M_node));
      }

      void
      resize(size_type new_size, const _Tp& __x);

      void
      resize(size_type new_size)
      { resize(new_size, _Tp()); }

      void
      clear()
      { this->_M_erase_after(&this->_M_head, 0); }

    public:


      void
      splice_after(iterator __pos,
     iterator __before_first, iterator __before_last)
      {
 if (__before_first != __before_last)
   __slist_splice_after(__pos._M_node, __before_first._M_node,
          __before_last._M_node);
      }



      void
      splice_after(iterator __pos, iterator __prev)
      { __slist_splice_after(__pos._M_node,
        __prev._M_node, __prev._M_node->_M_next); }




      void
      splice_after(iterator __pos, slist& __x)
      { __slist_splice_after(__pos._M_node, &__x._M_head); }


      void
      splice(iterator __pos, slist& __x)
      {
 if (__x._M_head._M_next)
   __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
          &__x._M_head,
          __slist_previous(&__x._M_head, 0)); }


      void
      splice(iterator __pos, slist& __x, iterator __i)
      { __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
        __slist_previous(&__x._M_head, __i._M_node),
        __i._M_node); }



      void
      splice(iterator __pos, slist& __x, iterator __first, iterator __last)
      {
 if (__first != __last)
   __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
          __slist_previous(&__x._M_head, __first._M_node),
          __slist_previous(__first._M_node,
      __last._M_node));
      }

    public:
      void
      reverse()
      {
 if (this->_M_head._M_next)
   this->_M_head._M_next = __slist_reverse(this->_M_head._M_next);
      }

      void
      remove(const _Tp& __val);

      void
      unique();

      void
      merge(slist& __x);

      void
      sort();

      template <class _Predicate>
        void
        remove_if(_Predicate __pred);

      template <class _BinaryPredicate>
        void
        unique(_BinaryPredicate __pred);

      template <class _StrictWeakOrdering>
        void
        merge(slist&, _StrictWeakOrdering);

      template <class _StrictWeakOrdering>
        void
        sort(_StrictWeakOrdering __comp);
    };

  template <class _Tp, class _Alloc>
    slist<_Tp, _Alloc>&
    slist<_Tp, _Alloc>::operator=(const slist<_Tp, _Alloc>& __x)
    {
      if (&__x != this)
 {
   _Node_base* __p1 = &this->_M_head;
   _Node* __n1 = (_Node*) this->_M_head._M_next;
   const _Node* __n2 = (const _Node*) __x._M_head._M_next;
   while (__n1 && __n2)
     {
       __n1->_M_data = __n2->_M_data;
       __p1 = __n1;
       __n1 = (_Node*) __n1->_M_next;
       __n2 = (const _Node*) __n2->_M_next;
     }
   if (__n2 == 0)
     this->_M_erase_after(__p1, 0);
   else
     _M_insert_after_range(__p1, const_iterator((_Node*)__n2),
                                  const_iterator(0));
 }
      return *this;
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val)
    {
      _Node_base* __prev = &this->_M_head;
      _Node* __node = (_Node*) this->_M_head._M_next;
      for (; __node != 0 && __n > 0; --__n)
 {
   __node->_M_data = __val;
   __prev = __node;
   __node = (_Node*) __node->_M_next;
 }
      if (__n > 0)
 _M_insert_after_fill(__prev, __n, __val);
      else
 this->_M_erase_after(__prev, 0);
    }

  template <class _Tp, class _Alloc>
    template <class _InputIterator>
      void
      slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIterator __first,
          _InputIterator __last,
          std::__false_type)
      {
 _Node_base* __prev = &this->_M_head;
 _Node* __node = (_Node*) this->_M_head._M_next;
 while (__node != 0 && __first != __last)
   {
     __node->_M_data = *__first;
     __prev = __node;
     __node = (_Node*) __node->_M_next;
     ++__first;
   }
 if (__first != __last)
   _M_insert_after_range(__prev, __first, __last);
 else
   this->_M_erase_after(__prev, 0);
      }

  template <class _Tp, class _Alloc>
    inline bool
    operator==(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    {
      typedef typename slist<_Tp,_Alloc>::const_iterator const_iterator;
      const_iterator __end1 = _SL1.end();
      const_iterator __end2 = _SL2.end();

      const_iterator __i1 = _SL1.begin();
      const_iterator __i2 = _SL2.begin();
      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
 {
   ++__i1;
   ++__i2;
 }
      return __i1 == __end1 && __i2 == __end2;
    }


  template <class _Tp, class _Alloc>
    inline bool
    operator<(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return std::lexicographical_compare(_SL1.begin(), _SL1.end(),
       _SL2.begin(), _SL2.end()); }

  template <class _Tp, class _Alloc>
    inline bool
    operator!=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return !(_SL1 == _SL2); }

  template <class _Tp, class _Alloc>
    inline bool
    operator>(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return _SL2 < _SL1; }

  template <class _Tp, class _Alloc>
    inline bool
    operator<=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return !(_SL2 < _SL1); }

  template <class _Tp, class _Alloc>
    inline bool
    operator>=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return !(_SL1 < _SL2); }

  template <class _Tp, class _Alloc>
    inline void
    swap(slist<_Tp, _Alloc>& __x, slist<_Tp, _Alloc>& __y)
    { __x.swap(__y); }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::resize(size_type __len, const _Tp& __x)
    {
      _Node_base* __cur = &this->_M_head;
      while (__cur->_M_next != 0 && __len > 0)
 {
   --__len;
   __cur = __cur->_M_next;
 }
      if (__cur->_M_next)
 this->_M_erase_after(__cur, 0);
      else
 _M_insert_after_fill(__cur, __len, __x);
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::remove(const _Tp& __val)
    {
      _Node_base* __cur = &this->_M_head;
      while (__cur && __cur->_M_next)
 {
   if (((_Node*) __cur->_M_next)->_M_data == __val)
     this->_M_erase_after(__cur);
   else
     __cur = __cur->_M_next;
 }
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::unique()
    {
      _Node_base* __cur = this->_M_head._M_next;
      if (__cur)
 {
   while (__cur->_M_next)
     {
       if (((_Node*)__cur)->_M_data
    == ((_Node*)(__cur->_M_next))->_M_data)
  this->_M_erase_after(__cur);
       else
  __cur = __cur->_M_next;
     }
 }
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::merge(slist<_Tp, _Alloc>& __x)
    {
      _Node_base* __n1 = &this->_M_head;
      while (__n1->_M_next && __x._M_head._M_next)
 {
   if (((_Node*) __x._M_head._M_next)->_M_data
       < ((_Node*) __n1->_M_next)->_M_data)
     __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
   __n1 = __n1->_M_next;
 }
      if (__x._M_head._M_next)
 {
   __n1->_M_next = __x._M_head._M_next;
   __x._M_head._M_next = 0;
 }
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::sort()
    {
      if (this->_M_head._M_next && this->_M_head._M_next->_M_next)
 {
   slist __carry;
   slist __counter[64];
   int __fill = 0;
   while (!empty())
     {
       __slist_splice_after(&__carry._M_head,
       &this->_M_head, this->_M_head._M_next);
       int __i = 0;
       while (__i < __fill && !__counter[__i].empty())
  {
    __counter[__i].merge(__carry);
    __carry.swap(__counter[__i]);
    ++__i;
  }
       __carry.swap(__counter[__i]);
       if (__i == __fill)
  ++__fill;
     }

   for (int __i = 1; __i < __fill; ++__i)
     __counter[__i].merge(__counter[__i-1]);
   this->swap(__counter[__fill-1]);
 }
    }

  template <class _Tp, class _Alloc>
    template <class _Predicate>
      void slist<_Tp, _Alloc>::remove_if(_Predicate __pred)
      {
 _Node_base* __cur = &this->_M_head;
 while (__cur->_M_next)
   {
     if (__pred(((_Node*) __cur->_M_next)->_M_data))
       this->_M_erase_after(__cur);
     else
       __cur = __cur->_M_next;
   }
      }

  template <class _Tp, class _Alloc>
    template <class _BinaryPredicate>
      void
      slist<_Tp, _Alloc>::unique(_BinaryPredicate __pred)
      {
 _Node* __cur = (_Node*) this->_M_head._M_next;
 if (__cur)
   {
     while (__cur->_M_next)
       {
  if (__pred(((_Node*)__cur)->_M_data,
      ((_Node*)(__cur->_M_next))->_M_data))
    this->_M_erase_after(__cur);
  else
    __cur = (_Node*) __cur->_M_next;
       }
   }
      }

  template <class _Tp, class _Alloc>
    template <class _StrictWeakOrdering>
      void
      slist<_Tp, _Alloc>::merge(slist<_Tp, _Alloc>& __x,
          _StrictWeakOrdering __comp)
      {
 _Node_base* __n1 = &this->_M_head;
 while (__n1->_M_next && __x._M_head._M_next)
   {
     if (__comp(((_Node*) __x._M_head._M_next)->_M_data,
         ((_Node*) __n1->_M_next)->_M_data))
       __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
     __n1 = __n1->_M_next;
   }
 if (__x._M_head._M_next)
   {
     __n1->_M_next = __x._M_head._M_next;
     __x._M_head._M_next = 0;
   }
      }

  template <class _Tp, class _Alloc>
    template <class _StrictWeakOrdering>
      void
      slist<_Tp, _Alloc>::sort(_StrictWeakOrdering __comp)
      {
 if (this->_M_head._M_next && this->_M_head._M_next->_M_next)
   {
     slist __carry;
     slist __counter[64];
     int __fill = 0;
     while (!empty())
       {
  __slist_splice_after(&__carry._M_head,
         &this->_M_head, this->_M_head._M_next);
  int __i = 0;
  while (__i < __fill && !__counter[__i].empty())
    {
      __counter[__i].merge(__carry, __comp);
      __carry.swap(__counter[__i]);
      ++__i;
    }
  __carry.swap(__counter[__i]);
  if (__i == __fill)
    ++__fill;
       }

     for (int __i = 1; __i < __fill; ++__i)
       __counter[__i].merge(__counter[__i-1], __comp);
     this->swap(__counter[__fill-1]);
   }
      }


}

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




  template <class _Tp, class _Alloc>
    class insert_iterator<__gnu_cxx::slist<_Tp, _Alloc> >
    {
    protected:
      typedef __gnu_cxx::slist<_Tp, _Alloc> _Container;
      _Container* container;
      typename _Container::iterator iter;

    public:
      typedef _Container container_type;
      typedef output_iterator_tag iterator_category;
      typedef void value_type;
      typedef void difference_type;
      typedef void pointer;
      typedef void reference;

      insert_iterator(_Container& __x, typename _Container::iterator __i)
      : container(&__x)
      {
 if (__i == __x.begin())
   iter = __x.before_begin();
 else
   iter = __x.previous(__i);
      }

      insert_iterator<_Container>&
      operator=(const typename _Container::value_type& __value)
      {
 iter = container->insert_after(iter, __value);
 return *this;
      }

      insert_iterator<_Container>&
      operator*()
      { return *this; }

      insert_iterator<_Container>&
      operator++()
      { return *this; }

      insert_iterator<_Container>&
      operator++(int)
      { return *this; }
    };


}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std/slist_traits.hpp" 2 3 4


namespace boost {
    namespace algorithm {





        template<typename T, typename AllocT>
        class has_stable_iterators< __gnu_cxx::slist<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_stable_iterators<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_insert< __gnu_cxx::slist<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_insert<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_erase< __gnu_cxx::slist<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_erase<T>::value> type;
        };


    }
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/std_containers_traits.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/trim.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/trim.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_end_iter_select(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace,
                std::forward_iterator_tag )
            {
                ForwardIteratorT TrimIt=InBegin;

                for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
                {
                    if ( !IsSpace(*It) )
                    {
                        TrimIt=It;
                        ++TrimIt;
                    }
                }

                return TrimIt;
            }

            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_end_iter_select(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace,
                std::bidirectional_iterator_tag )
            {
                for( ForwardIteratorT It=InEnd; It!=InBegin; )
                {
                    if ( !IsSpace(*(--It)) )
                        return ++It;
                }

                return InBegin;
            }

            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_begin(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace )
            {
                ForwardIteratorT It=InBegin;
                for(; It!=InEnd; ++It )
                {
                    if (!IsSpace(*It))
                        return It;
                }

                return It;
            }


            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_end(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace )
            {
                typedef typename boost::detail::
                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
            }


        }
    }
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/classification.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/classification.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate_facade.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate_facade.hpp" 3 4
namespace boost {
    namespace algorithm {
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/predicate_facade.hpp" 3 4
        template<typename Derived>
        struct predicate_facade {};

    }
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/classification.hpp" 2 3 4


namespace boost {
    namespace algorithm {
        namespace detail {




            struct is_classifiedF :
                public predicate_facade<is_classifiedF>
            {

                typedef bool result_type;


                is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
                    m_Type(Type), m_Locale(Loc) {}

                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
                }
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/classification.hpp" 3 4
            private:
                std::ctype_base::mask m_Type;
                std::locale m_Locale;
            };






            template<typename CharT>
            struct is_any_ofF :
                public predicate_facade<is_any_ofF<CharT> >
            {
            private:

                typedef typename ::boost::remove_const<CharT>::type set_value_type;

            public:

                typedef bool result_type;


                template<typename RangeT>
                is_any_ofF( const RangeT& Range ) : m_Size(0)
                {

                    m_Storage.m_dynSet=0;

                    std::size_t Size=::boost::distance(Range);
                    m_Size=Size;
                    set_value_type* Storage=0;

                    if(use_fixed_storage(m_Size))
                    {

                        Storage=&m_Storage.m_fixSet[0];
                    }
                    else
                    {

                        m_Storage.m_dynSet=new set_value_type[m_Size];
                        Storage=m_Storage.m_dynSet;
                    }


                    ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
                    ::std::sort(Storage, Storage+m_Size);
                }


                is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
                {

                    m_Storage.m_dynSet=0;
                    const set_value_type* SrcStorage=0;
                    set_value_type* DestStorage=0;

                    if(use_fixed_storage(m_Size))
                    {

                        DestStorage=&m_Storage.m_fixSet[0];
                        SrcStorage=&Other.m_Storage.m_fixSet[0];
                    }
                    else
                    {

                        m_Storage.m_dynSet=new set_value_type[m_Size];
                        DestStorage=m_Storage.m_dynSet;
                        SrcStorage=Other.m_Storage.m_dynSet;
                    }


                    ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
                }


                ~is_any_ofF()
                {
                    if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
                    {
                        delete [] m_Storage.m_dynSet;
                    }
                }


                is_any_ofF& operator=(const is_any_ofF& Other)
                {

                    if(this==&Other) return *this;


                    const set_value_type* SrcStorage;
                    set_value_type* DestStorage;

                    if(use_fixed_storage(Other.m_Size))
                    {

                        DestStorage=&m_Storage.m_fixSet[0];
                        SrcStorage=&Other.m_Storage.m_fixSet[0];


                        if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
                        {
                            delete [] m_Storage.m_dynSet;
                        }


                        m_Size=Other.m_Size;
                    }
                    else
                    {

                        SrcStorage=Other.m_Storage.m_dynSet;


                        if(use_fixed_storage(m_Size))
                        {

                            set_value_type* pTemp=new set_value_type[Other.m_Size];
                            DestStorage=pTemp;
                            m_Storage.m_dynSet=pTemp;
                            m_Size=Other.m_Size;
                        }
                        else
                        {

                            if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
                            {

                                DestStorage=m_Storage.m_dynSet;
                                m_Size=Other.m_Size;
                            }
                            else
                            {

                                set_value_type* pTemp=new set_value_type[Other.m_Size];
                                DestStorage=pTemp;


                                if(m_Storage.m_dynSet!=0)
                                {
                                    delete [] m_Storage.m_dynSet;
                                }

                                m_Storage.m_dynSet=pTemp;

                                m_Size=Other.m_Size;
                            }
                        }
                    }


                    ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);

                    return *this;
                }


                template<typename Char2T>
                bool operator()( Char2T Ch ) const
                {
                    const set_value_type* Storage=
                        (use_fixed_storage(m_Size))
                        ? &m_Storage.m_fixSet[0]
                        : m_Storage.m_dynSet;

                    return ::std::binary_search(Storage, Storage+m_Size, Ch);
                }
            private:

                static bool use_fixed_storage(std::size_t size)
                {
                    return size<=sizeof(set_value_type*)*2;
                }


            private:


                union
                {
                    set_value_type* m_dynSet;
                    set_value_type m_fixSet[sizeof(set_value_type*)*2];
                }
                m_Storage;


                ::std::size_t m_Size;
            };






            template<typename CharT>
            struct is_from_rangeF :
                public predicate_facade< is_from_rangeF<CharT> >
            {

                typedef bool result_type;


                is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}


                template<typename Char2T>
                bool operator()( Char2T Ch ) const
                {
                    return ( m_From <= Ch ) && ( Ch <= m_To );
                }

            private:
                CharT m_From;
                CharT m_To;
            };


            template<typename Pred1T, typename Pred2T>
            struct pred_andF :
                public predicate_facade< pred_andF<Pred1T,Pred2T> >
            {
            public:


                typedef bool result_type;


                pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
                    m_Pred1(Pred1), m_Pred2(Pred2) {}


                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return m_Pred1(Ch) && m_Pred2(Ch);
                }

            private:
                Pred1T m_Pred1;
                Pred2T m_Pred2;
            };


            template<typename Pred1T, typename Pred2T>
            struct pred_orF :
                public predicate_facade< pred_orF<Pred1T,Pred2T> >
            {
            public:

                typedef bool result_type;


                pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
                    m_Pred1(Pred1), m_Pred2(Pred2) {}


                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return m_Pred1(Ch) || m_Pred2(Ch);
                }

            private:
                Pred1T m_Pred1;
                Pred2T m_Pred2;
            };


            template< typename PredT >
            struct pred_notF :
                public predicate_facade< pred_notF<PredT> >
            {
            public:

                typedef bool result_type;


                pred_notF( PredT Pred ) : m_Pred(Pred) {}


                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return !m_Pred(Ch);
                }

            private:
                PredT m_Pred;
            };

        }
    }
}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
namespace boost {
    namespace algorithm {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(Type, Loc);
        }
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_space(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::space, Loc);
        }
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_alnum(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::alnum, Loc);
        }
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_alpha(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::alpha, Loc);
        }
# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_cntrl(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
        }
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_digit(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::digit, Loc);
        }
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_graph(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::graph, Loc);
        }
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_lower(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::lower, Loc);
        }
# 147 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_print(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::print, Loc);
        }
# 160 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_punct(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::punct, Loc);
        }
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_upper(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::upper, Loc);
        }
# 186 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_xdigit(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
        }
# 200 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename RangeT>
        inline detail::is_any_ofF<
            typename range_value<RangeT>::type>
        is_any_of( const RangeT& Set )
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
            return detail::is_any_ofF<typename range_value<RangeT>::type>(lit_set);
        }
# 218 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename CharT>
        inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
        {
            return detail::is_from_rangeF<CharT>(From,To);
        }
# 236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename Pred1T, typename Pred2T>
        inline detail::pred_andF<Pred1T, Pred2T>
        operator&&(
            const predicate_facade<Pred1T>& Pred1,
            const predicate_facade<Pred2T>& Pred2 )
        {



            return detail::pred_andF<Pred1T,Pred2T>(
                *static_cast<const Pred1T*>(&Pred1),
                *static_cast<const Pred2T*>(&Pred2) );
        }
# 260 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename Pred1T, typename Pred2T>
        inline detail::pred_orF<Pred1T, Pred2T>
        operator||(
            const predicate_facade<Pred1T>& Pred1,
            const predicate_facade<Pred2T>& Pred2 )
        {



            return detail::pred_orF<Pred1T,Pred2T>(
                *static_cast<const Pred1T*>(&Pred1),
                *static_cast<const Pred2T*>(&Pred2));
        }
# 282 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename PredT>
        inline detail::pred_notF<PredT>
        operator!( const predicate_facade<PredT>& Pred )
        {



            return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred));
        }

    }


    using algorithm::is_classified;
    using algorithm::is_space;
    using algorithm::is_alnum;
    using algorithm::is_alpha;
    using algorithm::is_cntrl;
    using algorithm::is_digit;
    using algorithm::is_graph;
    using algorithm::is_lower;
    using algorithm::is_upper;
    using algorithm::is_print;
    using algorithm::is_punct;
    using algorithm::is_xdigit;
    using algorithm::is_any_of;
    using algorithm::is_from_range;

}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
namespace boost {
    namespace algorithm {
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
        inline OutputIteratorT trim_left_copy_if(
            OutputIteratorT Output,
            const RangeT& Input,
            PredicateT IsSpace)
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));

            std::copy(
                ::boost::algorithm::detail::trim_begin(
                    ::boost::begin(lit_range),
                    ::boost::end(lit_range),
                    IsSpace ),
                ::boost::end(lit_range),
                Output);

            return Output;
        }





        template<typename SequenceT, typename PredicateT>
        inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace)
        {
            return SequenceT(
                ::boost::algorithm::detail::trim_begin(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace ),
                ::boost::end(Input));
        }
# 105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
        {
            return
                ::boost::algorithm::trim_left_copy_if(
                    Input,
                    is_space(Loc));
        }
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT, typename PredicateT>
        inline void trim_left_if(SequenceT& Input, PredicateT IsSpace)
        {
            Input.erase(
                ::boost::begin(Input),
                ::boost::algorithm::detail::trim_begin(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace));
        }
# 142 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::trim_left_if(
                Input,
                is_space(Loc));
        }
# 168 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
        inline OutputIteratorT trim_right_copy_if(
            OutputIteratorT Output,
            const RangeT& Input,
            PredicateT IsSpace )
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));

            std::copy(
                ::boost::begin(lit_range),
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(lit_range),
                    ::boost::end(lit_range),
                    IsSpace ),
                Output );

            return Output;
        }





        template<typename SequenceT, typename PredicateT>
        inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
        {
            return SequenceT(
                ::boost::begin(Input),
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace)
                );
        }
# 214 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
        {
            return
                ::boost::algorithm::trim_right_copy_if(
                    Input,
                    is_space(Loc));
        }
# 233 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT, typename PredicateT>
        inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
        {
            Input.erase(
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace ),
                ::boost::end(Input)
                );
        }
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::trim_right_if(
                Input,
                is_space(Loc) );
        }
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
        inline OutputIteratorT trim_copy_if(
            OutputIteratorT Output,
            const RangeT& Input,
            PredicateT IsSpace)
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));

            typename
                range_const_iterator<RangeT>::type TrimEnd=
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(lit_range),
                    ::boost::end(lit_range),
                    IsSpace);

            std::copy(
                detail::trim_begin(
                    ::boost::begin(lit_range), TrimEnd, IsSpace),
                TrimEnd,
                Output
                );

            return Output;
        }





        template<typename SequenceT, typename PredicateT>
        inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace)
        {
            typename
                range_const_iterator<SequenceT>::type TrimEnd=
                    ::boost::algorithm::detail::trim_end(
                        ::boost::begin(Input),
                        ::boost::end(Input),
                        IsSpace);

            return SequenceT(
                detail::trim_begin(
                    ::boost::begin(Input),
                    TrimEnd,
                    IsSpace),
                TrimEnd
                );
        }
# 339 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
        {
            return
                ::boost::algorithm::trim_copy_if(
                    Input,
                    is_space(Loc) );
        }
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT, typename PredicateT>
        inline void trim_if(SequenceT& Input, PredicateT IsSpace)
        {
            ::boost::algorithm::trim_right_if( Input, IsSpace );
            ::boost::algorithm::trim_left_if( Input, IsSpace );
        }
# 372 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::trim_if(
                Input,
                is_space( Loc ) );
        }

    }


    using algorithm::trim_left;
    using algorithm::trim_left_if;
    using algorithm::trim_left_copy;
    using algorithm::trim_left_copy_if;
    using algorithm::trim_right;
    using algorithm::trim_right_if;
    using algorithm::trim_right_copy;
    using algorithm::trim_right_copy_if;
    using algorithm::trim;
    using algorithm::trim_if;
    using algorithm::trim_copy;
    using algorithm::trim_copy_if;

}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/transform_iterator.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/transform_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/iterate.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/slot.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/slot.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/def.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/slot.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/iterate.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum_shifted_params.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/facilities/intercept.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/type_identity.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;




}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 2 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
{
};
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F >
struct tr1_result_of<F()>
    : 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(),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F(),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F >
struct result_of<F()>
    : detail::cpp0x_result_of<F()> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F >
struct cpp0x_result_of<F()>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type(), false
          >
        , detail::cpp0x_result_of_impl<
              F()
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F >
struct cpp0x_result_of_impl<F(),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                   
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
     
    )
  ) type;
};



}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0>
struct tr1_result_of<F( T0)>
    : 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( T0),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0>
struct result_of<F( T0)>
    : detail::cpp0x_result_of<F( T0)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0>
struct cpp0x_result_of<F( T0)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0>
struct cpp0x_result_of_impl<F( T0),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0>
struct tr1_result_of_impl<R (*)( T0), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0>
struct tr1_result_of_impl<R (&)( T0), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0>
struct tr1_result_of_impl<R (T0::*)
                     (),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0>
struct tr1_result_of_impl<R (T0::*)
                     ()
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0>
struct tr1_result_of_impl<R (T0::*)
                     ()
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0>
struct tr1_result_of_impl<R (T0::*)
                     ()
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1>
struct tr1_result_of<F( T0 , T1)>
    : 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( T0 , T1),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1>
struct result_of<F( T0 , T1)>
    : detail::cpp0x_result_of<F( T0 , T1)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1>
struct cpp0x_result_of<F( T0 , T1)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1>
struct cpp0x_result_of_impl<F( T0 , T1),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1>
struct tr1_result_of_impl<R (*)( T0 , T1), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1>
struct tr1_result_of_impl<R (&)( T0 , T1), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1>
struct tr1_result_of_impl<R (T0::*)
                     ( T1),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1>
struct tr1_result_of_impl<R (T0::*)
                     ( T1)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1>
struct tr1_result_of_impl<R (T0::*)
                     ( T1)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1>
struct tr1_result_of_impl<R (T0::*)
                     ( T1)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2>
struct tr1_result_of<F( T0 , T1 , T2)>
    : 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( T0 , T1 , T2),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2>
struct result_of<F( T0 , T1 , T2)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2>
struct cpp0x_result_of<F( T0 , T1 , T2)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2>
struct cpp0x_result_of_impl<F( T0 , T1 , T2),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3>
struct tr1_result_of<F( T0 , T1 , T2 , T3)>
    : 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( T0 , T1 , T2 , T3),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3>
struct result_of<F( T0 , T1 , T2 , T3)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4)>
    : 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( T0 , T1 , T2 , T3 , T4),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct result_of<F( T0 , T1 , T2 , T3 , T4)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)>
    : 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( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };



template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)>
    : detail::cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { };
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct cpp0x_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), false
          >
        , detail::cpp0x_result_of_impl<
              F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
          >
      >::type
{};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct cpp0x_result_of_impl<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >() , boost::declval<T15 >()
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<T0 >() , boost::declval<T1 >() , boost::declval<T2 >() , boost::declval<T3 >() , boost::declval<T4 >() , boost::declval<T5 >() , boost::declval<T6 >() , boost::declval<T7 >() , boost::declval<T8 >() , boost::declval<T9 >() , boost::declval<T10 >() , boost::declval<T11 >() , boost::declval<T12 >() , boost::declval<T13 >() , boost::declval<T14 >() , boost::declval<T15 >()
    )
  ) type;
};



}
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/result_of_iterate.hpp" 3 4
namespace detail {

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), FArgs, false>
{
  typedef R type;
};


template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
                     const,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
                     volatile,
                 FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 222 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 2 3 4
# 232 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/result_of.hpp" 3 4
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/transform_iterator.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
  }
# 147 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
  }
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/transform_iterator.hpp" 3 4
}

using iterators::transform_iterator;
using iterators::make_transform_iterator;

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 174 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/transform_iterator.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/case_conv.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/case_conv.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/case_conv.hpp" 3 4
            template<typename CharT>
            struct to_lowerF
            {
                typedef CharT argument_type;
                typedef CharT result_type;

                to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}


                CharT operator ()( CharT Ch ) const
                {



                        return std::tolower<CharT>( Ch, *m_Loc );

                }
            private:
                const std::locale* m_Loc;
            };


            template<typename CharT>
            struct to_upperF
            {
                typedef CharT argument_type;
                typedef CharT result_type;

                to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}


                CharT operator ()( CharT Ch ) const
                {



                        return std::toupper<CharT>( Ch, *m_Loc );

                }
            private:
                const std::locale* m_Loc;
            };
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/case_conv.hpp" 3 4
            template<typename OutputIteratorT, typename RangeT, typename FunctorT>
            OutputIteratorT transform_range_copy(
                OutputIteratorT Output,
                const RangeT& Input,
                FunctorT Functor)
            {
                return std::transform(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    Output,
                    Functor);
            }


            template<typename RangeT, typename FunctorT>
            void transform_range(
                const RangeT& Input,
                FunctorT Functor)
            {
                std::transform(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    ::boost::begin(Input),
                    Functor);
            }

            template<typename SequenceT, typename RangeT, typename FunctorT>
            inline SequenceT transform_range_copy(
                const RangeT& Input,
                FunctorT Functor)
            {
                return SequenceT(
                    ::boost::make_transform_iterator(
                        ::boost::begin(Input),
                        Functor),
                    ::boost::make_transform_iterator(
                        ::boost::end(Input),
                        Functor));
            }

        }
    }
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 2 3 4







namespace boost {
    namespace algorithm {
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT>
        inline OutputIteratorT
        to_lower_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy(
               Output,
               ::boost::as_literal(Input),
               ::boost::algorithm::detail::to_lowerF<
                    typename range_value<RangeT>::type >(Loc));
        }





        template<typename SequenceT>
        inline SequenceT to_lower_copy(
            const SequenceT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
                Input,
                ::boost::algorithm::detail::to_lowerF<
                    typename range_value<SequenceT>::type >(Loc));
        }
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename WritableRangeT>
        inline void to_lower(
            WritableRangeT& Input,
            const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::detail::transform_range(
                ::boost::as_literal(Input),
                ::boost::algorithm::detail::to_lowerF<
                    typename range_value<WritableRangeT>::type >(Loc));
        }
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT>
        inline OutputIteratorT
        to_upper_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy(
               Output,
               ::boost::as_literal(Input),
               ::boost::algorithm::detail::to_upperF<
                    typename range_value<RangeT>::type >(Loc));
        }





        template<typename SequenceT>
        inline SequenceT to_upper_copy(
            const SequenceT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
                Input,
                ::boost::algorithm::detail::to_upperF<
                    typename range_value<SequenceT>::type >(Loc));
        }
# 155 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename WritableRangeT>
        inline void to_upper(
            WritableRangeT& Input,
            const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::detail::transform_range(
                ::boost::as_literal(Input),
                ::boost::algorithm::detail::to_upperF<
                    typename range_value<WritableRangeT>::type >(Loc));
        }

    }


    using algorithm::to_lower;
    using algorithm::to_lower_copy;
    using algorithm::to_upper;
    using algorithm::to_upper_copy;

}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/split.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/split.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/concept.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/concept.hpp" 3 4
namespace boost {
    namespace algorithm {
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/concept.hpp" 3 4
        template<typename FinderT, typename IteratorT>
        struct FinderConcept
        {
        private:
            typedef iterator_range<IteratorT> range;
        public:
            void constraints()
            {

                r=(*pF)(i,i);
            }
        private:
            range r;
            IteratorT i;
            FinderT* pF;
        };
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/concept.hpp" 3 4
        template<typename FormatterT, typename FinderT, typename IteratorT>
        struct FormatterConcept
        {
        public:
            void constraints()
            {

                ::boost::begin((*pFo)( (*pF)(i,i) ));
                ::boost::end((*pFo)( (*pF)(i,i) ));
            }
        private:
            IteratorT i;
            FinderT* pF;
            FormatterT *pFo;
        };

    }
}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_iterator.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iterate.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 3 4
# 1 "/usr/include/c++/10/cassert" 1 3 4
# 41 "/usr/include/c++/10/cassert" 3 4
       
# 42 "/usr/include/c++/10/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 45 "/usr/include/c++/10/cassert" 2 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/no_tr1/functional.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 3 4
# 1 "/usr/include/c++/10/memory" 1 3 4
# 47 "/usr/include/c++/10/memory" 3 4
       
# 48 "/usr/include/c++/10/memory" 3
# 68 "/usr/include/c++/10/memory" 3
# 1 "/usr/include/c++/10/bits/stl_raw_storage_iter.h" 1 3
# 59 "/usr/include/c++/10/bits/stl_raw_storage_iter.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{






  template <class _OutputIterator, class _Tp>
    class raw_storage_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _OutputIterator _M_iter;

    public:
      explicit
      raw_storage_iterator(_OutputIterator __x)
      : _M_iter(__x) {}

      raw_storage_iterator&
      operator*() { return *this; }

      raw_storage_iterator&
      operator=(const _Tp& __element)
      {
 std::_Construct(std::__addressof(*_M_iter), __element);
 return *this;
      }




      raw_storage_iterator&
      operator=(_Tp&& __element)
      {
 std::_Construct(std::__addressof(*_M_iter), std::move(__element));
 return *this;
      }


      raw_storage_iterator&
      operator++()
      {
 ++_M_iter;
 return *this;
      }

      raw_storage_iterator
      operator++(int)
      {
 raw_storage_iterator __tmp = *this;
 ++_M_iter;
 return __tmp;
      }



      _OutputIterator base() const { return _M_iter; }
    };


}
# 69 "/usr/include/c++/10/memory" 2 3






# 1 "/usr/include/c++/10/ext/concurrence.h" 1 3
# 32 "/usr/include/c++/10/ext/concurrence.h" 3
       
# 33 "/usr/include/c++/10/ext/concurrence.h" 3







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







  enum _Lock_policy { _S_single, _S_mutex, _S_atomic };



  static const _Lock_policy __default_lock_policy =



  _S_atomic;






  class __concurrence_lock_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_lock_error"; }
  };

  class __concurrence_unlock_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_unlock_error"; }
  };

  class __concurrence_broadcast_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_broadcast_error"; }
  };

  class __concurrence_wait_error : public std::exception
  {
  public:
    virtual char const*
    what() const throw()
    { return "__gnu_cxx::__concurrence_wait_error"; }
  };


  inline void
  __throw_concurrence_lock_error()
  { (throw (__concurrence_lock_error())); }

  inline void
  __throw_concurrence_unlock_error()
  { (throw (__concurrence_unlock_error())); }


  inline void
  __throw_concurrence_broadcast_error()
  { (throw (__concurrence_broadcast_error())); }

  inline void
  __throw_concurrence_wait_error()
  { (throw (__concurrence_wait_error())); }


  class __mutex
  {
  private:

    __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_DEFAULT, 0, 0, { 0, 0 } } };




    __mutex(const __mutex&);
    __mutex& operator=(const __mutex&);

  public:
    __mutex()
    {




    }
# 144 "/usr/include/c++/10/ext/concurrence.h" 3
    void lock()
    {

      if (__gthread_active_p())
 {
   if (__gthread_mutex_lock(&_M_mutex) != 0)
     __throw_concurrence_lock_error();
 }

    }

    void unlock()
    {

      if (__gthread_active_p())
 {
   if (__gthread_mutex_unlock(&_M_mutex) != 0)
     __throw_concurrence_unlock_error();
 }

    }

    __gthread_mutex_t* gthread_mutex(void)
      { return &_M_mutex; }
  };

  class __recursive_mutex
  {
  private:

    __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };




    __recursive_mutex(const __recursive_mutex&);
    __recursive_mutex& operator=(const __recursive_mutex&);

  public:
    __recursive_mutex()
    {




    }
# 199 "/usr/include/c++/10/ext/concurrence.h" 3
    void lock()
    {

      if (__gthread_active_p())
 {
   if (__gthread_recursive_mutex_lock(&_M_mutex) != 0)
     __throw_concurrence_lock_error();
 }

    }

    void unlock()
    {

      if (__gthread_active_p())
 {
   if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0)
     __throw_concurrence_unlock_error();
 }

    }

    __gthread_recursive_mutex_t* gthread_recursive_mutex(void)
    { return &_M_mutex; }
  };




  class __scoped_lock
  {
  public:
    typedef __mutex __mutex_type;

  private:
    __mutex_type& _M_device;

    __scoped_lock(const __scoped_lock&);
    __scoped_lock& operator=(const __scoped_lock&);

  public:
    explicit __scoped_lock(__mutex_type& __name) : _M_device(__name)
    { _M_device.lock(); }

    ~__scoped_lock() throw()
    { _M_device.unlock(); }
  };


  class __cond
  {
  private:

    __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } };




    __cond(const __cond&);
    __cond& operator=(const __cond&);

  public:
    __cond()
    {




    }
# 277 "/usr/include/c++/10/ext/concurrence.h" 3
    void broadcast()
    {

      if (__gthread_active_p())
 {
   if (__gthread_cond_broadcast(&_M_cond) != 0)
     __throw_concurrence_broadcast_error();
 }

    }

    void wait(__mutex *mutex)
    {

      {
   if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0)
     __throw_concurrence_wait_error();
      }

    }

    void wait_recursive(__recursive_mutex *mutex)
    {

      {
   if (__gthread_cond_wait_recursive(&_M_cond,
         mutex->gthread_recursive_mutex())
       != 0)
     __throw_concurrence_wait_error();
      }

    }
  };



}
# 76 "/usr/include/c++/10/memory" 2 3







# 1 "/usr/include/c++/10/bits/shared_ptr.h" 1 3
# 52 "/usr/include/c++/10/bits/shared_ptr.h" 3
# 1 "/usr/include/c++/10/bits/shared_ptr_base.h" 1 3
# 58 "/usr/include/c++/10/bits/shared_ptr_base.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename> class auto_ptr;
#pragma GCC diagnostic pop






  class bad_weak_ptr : public std::exception
  {
  public:
    virtual char const* what() const noexcept;

    virtual ~bad_weak_ptr() noexcept;
  };


  inline void
  __throw_bad_weak_ptr()
  { (throw (bad_weak_ptr())); }

  using __gnu_cxx::_Lock_policy;
  using __gnu_cxx::__default_lock_policy;
  using __gnu_cxx::_S_single;
  using __gnu_cxx::_S_mutex;
  using __gnu_cxx::_S_atomic;


  template<_Lock_policy _Lp>
    class _Mutex_base
    {
    protected:

      enum { _S_need_barriers = 0 };
    };

  template<>
    class _Mutex_base<_S_mutex>
    : public __gnu_cxx::__mutex
    {
    protected:



      enum { _S_need_barriers = 1 };
    };

  template<_Lock_policy _Lp = __default_lock_policy>
    class _Sp_counted_base
    : public _Mutex_base<_Lp>
    {
    public:
      _Sp_counted_base() noexcept
      : _M_use_count(1), _M_weak_count(1) { }

      virtual
      ~_Sp_counted_base() noexcept
      { }



      virtual void
      _M_dispose() noexcept = 0;


      virtual void
      _M_destroy() noexcept
      { delete this; }

      virtual void*
      _M_get_deleter(const std::type_info&) noexcept = 0;

      void
      _M_add_ref_copy()
      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

      void
      _M_add_ref_lock();

      bool
      _M_add_ref_lock_nothrow();

      void
      _M_release() noexcept
      {

        ;
 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
   {
            ;
     _M_dispose();




     if (_Mutex_base<_Lp>::_S_need_barriers)
       {
  __atomic_thread_fence (4);
       }


            ;
     if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
             -1) == 1)
              {
                ;
         _M_destroy();
              }
   }
      }

      void
      _M_weak_add_ref() noexcept
      { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

      void
      _M_weak_release() noexcept
      {

        ;
 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
   {
            ;
     if (_Mutex_base<_Lp>::_S_need_barriers)
       {


  __atomic_thread_fence (4);
       }
     _M_destroy();
   }
      }

      long
      _M_get_use_count() const noexcept
      {


        return __atomic_load_n(&_M_use_count, 0);
      }

    private:
      _Sp_counted_base(_Sp_counted_base const&) = delete;
      _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

      _Atomic_word _M_use_count;
      _Atomic_word _M_weak_count;
    };

  template<>
    inline void
    _Sp_counted_base<_S_single>::
    _M_add_ref_lock()
    {
      if (_M_use_count == 0)
 __throw_bad_weak_ptr();
      ++_M_use_count;
    }

  template<>
    inline void
    _Sp_counted_base<_S_mutex>::
    _M_add_ref_lock()
    {
      __gnu_cxx::__scoped_lock sentry(*this);
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
 {
   _M_use_count = 0;
   __throw_bad_weak_ptr();
 }
    }

  template<>
    inline void
    _Sp_counted_base<_S_atomic>::
    _M_add_ref_lock()
    {

      _Atomic_word __count = _M_get_use_count();
      do
 {
   if (__count == 0)
     __throw_bad_weak_ptr();


 }
      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
       true, 4,
       0));
    }

  template<>
    inline bool
    _Sp_counted_base<_S_single>::
    _M_add_ref_lock_nothrow()
    {
      if (_M_use_count == 0)
 return false;
      ++_M_use_count;
      return true;
    }

  template<>
    inline bool
    _Sp_counted_base<_S_mutex>::
    _M_add_ref_lock_nothrow()
    {
      __gnu_cxx::__scoped_lock sentry(*this);
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
 {
   _M_use_count = 0;
   return false;
 }
      return true;
    }

  template<>
    inline bool
    _Sp_counted_base<_S_atomic>::
    _M_add_ref_lock_nothrow()
    {

      _Atomic_word __count = _M_get_use_count();
      do
 {
   if (__count == 0)
     return false;


 }
      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
       true, 4,
       0));
      return true;
    }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_add_ref_copy()
    { ++_M_use_count; }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_release() noexcept
    {
      if (--_M_use_count == 0)
        {
          _M_dispose();
          if (--_M_weak_count == 0)
            _M_destroy();
        }
    }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
    { ++_M_weak_count; }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_weak_release() noexcept
    {
      if (--_M_weak_count == 0)
        _M_destroy();
    }

  template<>
    inline long
    _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
    { return _M_use_count; }



  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __shared_ptr;

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __weak_ptr;

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __enable_shared_from_this;

  template<typename _Tp>
    class shared_ptr;

  template<typename _Tp>
    class weak_ptr;

  template<typename _Tp>
    struct owner_less;

  template<typename _Tp>
    class enable_shared_from_this;

  template<_Lock_policy _Lp = __default_lock_policy>
    class __weak_count;

  template<_Lock_policy _Lp = __default_lock_policy>
    class __shared_count;



  template<typename _Ptr, _Lock_policy _Lp>
    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
    {
    public:
      explicit
      _Sp_counted_ptr(_Ptr __p) noexcept
      : _M_ptr(__p) { }

      virtual void
      _M_dispose() noexcept
      { delete _M_ptr; }

      virtual void
      _M_destroy() noexcept
      { delete this; }

      virtual void*
      _M_get_deleter(const std::type_info&) noexcept
      { return nullptr; }

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

    private:
      _Ptr _M_ptr;
    };

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }

  template<int _Nm, typename _Tp,
    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
    struct _Sp_ebo_helper;


  template<int _Nm, typename _Tp>
    struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
    {
      explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
      explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

      static _Tp&
      _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
    };


  template<int _Nm, typename _Tp>
    struct _Sp_ebo_helper<_Nm, _Tp, false>
    {
      explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
      explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

      static _Tp&
      _S_get(_Sp_ebo_helper& __eboh)
      { return __eboh._M_tp; }

    private:
      _Tp _M_tp;
    };


  template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
    class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
    {
      class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
      {
 typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
 typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;

      public:
 _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
 : _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
 { }

 _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
 _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }

 _Ptr _M_ptr;
      };

    public:
      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;


      _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
      : _M_impl(__p, std::move(__d), _Alloc()) { }


      _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
      : _M_impl(__p, std::move(__d), __a) { }

      ~_Sp_counted_deleter() noexcept { }

      virtual void
      _M_dispose() noexcept
      { _M_impl._M_del()(_M_impl._M_ptr); }

      virtual void
      _M_destroy() noexcept
      {
 __allocator_type __a(_M_impl._M_alloc());
 __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
 this->~_Sp_counted_deleter();
      }

      virtual void*
      _M_get_deleter(const std::type_info& __ti) noexcept
      {



        return __ti == typeid(_Deleter)
   ? std::__addressof(_M_impl._M_del())
   : nullptr;



      }

    private:
      _Impl _M_impl;
    };



  struct _Sp_make_shared_tag
  {
  private:
    template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
      friend class _Sp_counted_ptr_inplace;

    static const type_info&
    _S_ti() noexcept __attribute__ ((__visibility__ ("default")))
    {
      alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
      return reinterpret_cast<const type_info&>(__tag);
    }

    static bool _S_eq(const type_info&) noexcept;
  };

  template<typename _Alloc>
    struct _Sp_alloc_shared_tag
    {
      const _Alloc& _M_a;
    };

  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
    class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
    {
      class _Impl : _Sp_ebo_helper<0, _Alloc>
      {
 typedef _Sp_ebo_helper<0, _Alloc> _A_base;

      public:
 explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }

 _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }

 __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
      };

    public:
      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;


      template<typename... _Args>
 _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
 : _M_impl(__a)
 {


   allocator_traits<_Alloc>::construct(__a, _M_ptr(),
       std::forward<_Args>(__args)...);
 }

      ~_Sp_counted_ptr_inplace() noexcept { }

      virtual void
      _M_dispose() noexcept
      {
 allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
      }


      virtual void
      _M_destroy() noexcept
      {
 __allocator_type __a(_M_impl._M_alloc());
 __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
 this->~_Sp_counted_ptr_inplace();
      }

    private:
      friend class __shared_count<_Lp>;



      virtual void*
      _M_get_deleter(const std::type_info& __ti) noexcept override
      {
 auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());




 if (&__ti == &_Sp_make_shared_tag::_S_ti()
     ||

     __ti == typeid(_Sp_make_shared_tag)



    )
   return __ptr;
 return nullptr;
      }

      _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

      _Impl _M_impl;
    };


  struct __sp_array_delete
  {
    template<typename _Yp>
      void operator()(_Yp* __p) const { delete[] __p; }
  };

  template<_Lock_policy _Lp>
    class __shared_count
    {
      template<typename _Tp>
 struct __not_alloc_shared_tag { using type = void; };

      template<typename _Tp>
 struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };

    public:
      constexpr __shared_count() noexcept : _M_pi(0)
      { }

      template<typename _Ptr>
        explicit
 __shared_count(_Ptr __p) : _M_pi(0)
 {
   try
     {
       _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
     }
   catch(...)
     {
       delete __p;
       throw;
     }
 }

      template<typename _Ptr>
 __shared_count(_Ptr __p, false_type)
 : __shared_count(__p)
 { }

      template<typename _Ptr>
 __shared_count(_Ptr __p, true_type)
 : __shared_count(__p, __sp_array_delete{}, allocator<void>())
 { }

      template<typename _Ptr, typename _Deleter,
        typename = typename __not_alloc_shared_tag<_Deleter>::type>
 __shared_count(_Ptr __p, _Deleter __d)
 : __shared_count(__p, std::move(__d), allocator<void>())
 { }

      template<typename _Ptr, typename _Deleter, typename _Alloc,
        typename = typename __not_alloc_shared_tag<_Deleter>::type>
 __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
 {
   typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
   try
     {
       typename _Sp_cd_type::__allocator_type __a2(__a);
       auto __guard = std::__allocate_guarded(__a2);
       _Sp_cd_type* __mem = __guard.get();
       ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
       _M_pi = __mem;
       __guard = nullptr;
     }
   catch(...)
     {
       __d(__p);
       throw;
     }
 }

      template<typename _Tp, typename _Alloc, typename... _Args>
 __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
         _Args&&... __args)
 {
   typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
   typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
   auto __guard = std::__allocate_guarded(__a2);
   _Sp_cp_type* __mem = __guard.get();
   auto __pi = ::new (__mem)
     _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
   __guard = nullptr;
   _M_pi = __pi;
   __p = __pi->_M_ptr();
 }


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

      template<typename _Tp>
        explicit
 __shared_count(std::auto_ptr<_Tp>&& __r);
#pragma GCC diagnostic pop



      template<typename _Tp, typename _Del>
        explicit
 __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
 {


   if (__r.get() == nullptr)
     return;

   using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
   using _Del2 = typename conditional<is_reference<_Del>::value,
       reference_wrapper<typename remove_reference<_Del>::type>,
       _Del>::type;
   using _Sp_cd_type
     = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
   using _Alloc = allocator<_Sp_cd_type>;
   using _Alloc_traits = allocator_traits<_Alloc>;
   _Alloc __a;
   _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
   _Alloc_traits::construct(__a, __mem, __r.release(),
       __r.get_deleter());
   _M_pi = __mem;
 }


      explicit __shared_count(const __weak_count<_Lp>& __r);


      explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);

      ~__shared_count() noexcept
      {
 if (_M_pi != nullptr)
   _M_pi->_M_release();
      }

      __shared_count(const __shared_count& __r) noexcept
      : _M_pi(__r._M_pi)
      {
 if (_M_pi != 0)
   _M_pi->_M_add_ref_copy();
      }

      __shared_count&
      operator=(const __shared_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 if (__tmp != _M_pi)
   {
     if (__tmp != 0)
       __tmp->_M_add_ref_copy();
     if (_M_pi != 0)
       _M_pi->_M_release();
     _M_pi = __tmp;
   }
 return *this;
      }

      void
      _M_swap(__shared_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 __r._M_pi = _M_pi;
 _M_pi = __tmp;
      }

      long
      _M_get_use_count() const noexcept
      { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }

      bool
      _M_unique() const noexcept
      { return this->_M_get_use_count() == 1; }

      void*
      _M_get_deleter(const std::type_info& __ti) const noexcept
      { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

      bool
      _M_less(const __shared_count& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

      bool
      _M_less(const __weak_count<_Lp>& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }


      friend inline bool
      operator==(const __shared_count& __a, const __shared_count& __b) noexcept
      { return __a._M_pi == __b._M_pi; }

    private:
      friend class __weak_count<_Lp>;

      _Sp_counted_base<_Lp>* _M_pi;
    };


  template<_Lock_policy _Lp>
    class __weak_count
    {
    public:
      constexpr __weak_count() noexcept : _M_pi(nullptr)
      { }

      __weak_count(const __shared_count<_Lp>& __r) noexcept
      : _M_pi(__r._M_pi)
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_add_ref();
      }

      __weak_count(const __weak_count& __r) noexcept
      : _M_pi(__r._M_pi)
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_add_ref();
      }

      __weak_count(__weak_count&& __r) noexcept
      : _M_pi(__r._M_pi)
      { __r._M_pi = nullptr; }

      ~__weak_count() noexcept
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
      }

      __weak_count&
      operator=(const __shared_count<_Lp>& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 if (__tmp != nullptr)
   __tmp->_M_weak_add_ref();
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
 _M_pi = __tmp;
 return *this;
      }

      __weak_count&
      operator=(const __weak_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 if (__tmp != nullptr)
   __tmp->_M_weak_add_ref();
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
 _M_pi = __tmp;
 return *this;
      }

      __weak_count&
      operator=(__weak_count&& __r) noexcept
      {
 if (_M_pi != nullptr)
   _M_pi->_M_weak_release();
 _M_pi = __r._M_pi;
        __r._M_pi = nullptr;
 return *this;
      }

      void
      _M_swap(__weak_count& __r) noexcept
      {
 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 __r._M_pi = _M_pi;
 _M_pi = __tmp;
      }

      long
      _M_get_use_count() const noexcept
      { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }

      bool
      _M_less(const __weak_count& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

      bool
      _M_less(const __shared_count<_Lp>& __rhs) const noexcept
      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }


      friend inline bool
      operator==(const __weak_count& __a, const __weak_count& __b) noexcept
      { return __a._M_pi == __b._M_pi; }

    private:
      friend class __shared_count<_Lp>;

      _Sp_counted_base<_Lp>* _M_pi;
    };


  template<_Lock_policy _Lp>
    inline
    __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
    : _M_pi(__r._M_pi)
    {
      if (_M_pi != nullptr)
 _M_pi->_M_add_ref_lock();
      else
 __throw_bad_weak_ptr();
    }


  template<_Lock_policy _Lp>
    inline
    __shared_count<_Lp>::
    __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
    : _M_pi(__r._M_pi)
    {
      if (_M_pi != nullptr)
 if (!_M_pi->_M_add_ref_lock_nothrow())
   _M_pi = nullptr;
    }







  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 (! (_M_get() != nullptr)) std::__replacement_assert("/usr/include/c++/10/bits/shared_ptr_base.h", 1007, __PRETTY_FUNCTION__, "_M_get() != nullptr"); } 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;
# 1065 "/usr/include/c++/10/bits/shared_ptr_base.h" 3
      element_type&
      operator[](ptrdiff_t __i) const
      {
 do { if (! (_M_get() != nullptr)) std::__replacement_assert("/usr/include/c++/10/bits/shared_ptr_base.h", 1068, __PRETTY_FUNCTION__, "_M_get() != nullptr"); } while (false);
 do { if (! (!extent<_Tp>::value || __i < extent<_Tp>::value)) std::__replacement_assert("/usr/include/c++/10/bits/shared_ptr_base.h", 1069, __PRETTY_FUNCTION__, "!extent<_Tp>::value || __i < extent<_Tp>::value"); } 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 = typename enable_if<__and_<
   __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
   >::value, _Res>::type;


      template<typename _Yp, typename _Del>
 using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

    public:


      using weak_type = __weak_ptr<_Tp, _Lp>;


      constexpr __shared_ptr() noexcept
      : _M_ptr(0), _M_refcount()
      { }

      template<typename _Yp, typename = _SafeConv<_Yp>>
 explicit
 __shared_ptr(_Yp* __p)
 : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
 {
   static_assert( !is_void<_Yp>::value, "incomplete type" );
   static_assert( sizeof(_Yp) > 0, "incomplete type" );
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
 __shared_ptr(_Yp* __p, _Deleter __d)
 : _M_ptr(__p), _M_refcount(__p, std::move(__d))
 {
   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
       "deleter expression d(p) is well-formed");
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _SafeConv<_Yp>>
 __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
 : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
 {
   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
       "deleter expression d(p) is well-formed");
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Deleter>
 __shared_ptr(nullptr_t __p, _Deleter __d)
 : _M_ptr(0), _M_refcount(__p, std::move(__d))
 { }

      template<typename _Deleter, typename _Alloc>
        __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
 : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
 { }


      template<typename _Yp>
 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
       element_type* __p) noexcept
 : _M_ptr(__p), _M_refcount(__r._M_refcount)
 { }


      template<typename _Yp>
 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
       element_type* __p) noexcept
 : _M_ptr(__p), _M_refcount()
 {
   _M_refcount._M_swap(__r._M_refcount);
   __r._M_ptr = 0;
 }

      __shared_ptr(const __shared_ptr&) noexcept = default;
      __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
      ~__shared_ptr() = default;

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
 { }

      __shared_ptr(__shared_ptr&& __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount()
      {
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
      }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount()
 {
   _M_refcount._M_swap(__r._M_refcount);
   __r._M_ptr = 0;
 }

      template<typename _Yp, typename = _Compatible<_Yp>>
 explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
 : _M_refcount(__r._M_refcount)
 {


   _M_ptr = __r._M_ptr;
 }


      template<typename _Yp, typename _Del,
        typename = _UniqCompatible<_Yp, _Del>>
 __shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : _M_ptr(__r.get()), _M_refcount()
 {
   auto __raw = __to_address(__r.get());
   _M_refcount = __shared_count<_Lp>(std::move(__r));
   _M_enable_shared_from_this_with(__raw);
 }
# 1241 "/usr/include/c++/10/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 (! (__p == 0 || __p != _M_ptr)) std::__replacement_assert("/usr/include/c++/10/bits/shared_ptr_base.h", 1305, __PRETTY_FUNCTION__, "__p == 0 || __p != _M_ptr"); } 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
      { return _M_ptr == 0 ? false : true; }


      bool
      unique() const noexcept
      { return _M_refcount._M_unique(); }


      long
      use_count() const noexcept
      { return _M_refcount._M_get_use_count(); }


      void
      swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
      {
 std::swap(_M_ptr, __other._M_ptr);
 _M_refcount._M_swap(__other._M_refcount);
      }
# 1353 "/usr/include/c++/10/bits/shared_ptr_base.h" 3
      template<typename _Tp1>
 bool
 owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      template<typename _Tp1>
 bool
 owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }


    protected:

      template<typename _Alloc, typename... _Args>
 __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
 : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
 { _M_enable_shared_from_this_with(_M_ptr); }

      template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
        typename... _Args>
 friend __shared_ptr<_Tp1, _Lp1>
 __allocate_shared(const _Alloc& __a, _Args&&... __args);



      __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
      : _M_refcount(__r._M_refcount, std::nothrow)
      {
 _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
      }

      friend class __weak_ptr<_Tp, _Lp>;

    private:

      template<typename _Yp>
 using __esft_base_t = decltype(__enable_shared_from_this_base(
       std::declval<const __shared_count<_Lp>&>(),
       std::declval<_Yp*>()));


      template<typename _Yp, typename = void>
 struct __has_esft_base
 : false_type { };

      template<typename _Yp>
 struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
 : __not_<is_array<_Tp>> { };

      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
 typename enable_if<__has_esft_base<_Yp2>::value>::type
 _M_enable_shared_from_this_with(_Yp* __p) noexcept
 {
   if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
     __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
 }

      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
 typename enable_if<!__has_esft_base<_Yp2>::value>::type
 _M_enable_shared_from_this_with(_Yp*) noexcept
 { }

      void*
      _M_get_deleter(const std::type_info& __ti) const noexcept
      { return _M_refcount._M_get_deleter(__ti); }

      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

      template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
 friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

      template<typename _Del, typename _Tp1>
 friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;

      element_type* _M_ptr;
      __shared_count<_Lp> _M_refcount;
    };



  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp1, _Lp>& __a,
        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return __a.get() == __b.get(); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return !__a; }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
    { return !__a; }

  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return __a.get() != __b.get(); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return (bool)__a; }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
    { return (bool)__a; }

  template<typename _Tp, typename _Up, _Lock_policy _Lp>
    inline bool
    operator<(const __shared_ptr<_Tp, _Lp>& __a,
       const __shared_ptr<_Up, _Lp>& __b) noexcept
    {
      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
      using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
      using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
      return less<_Vp>()(__a.get(), __b.get());
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    {
      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
      return less<_Tp_elt*>()(__a.get(), nullptr);
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
    {
      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
      return less<_Tp_elt*>()(nullptr, __a.get());
    }

  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return !(__b < __a); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return !(nullptr < __a); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
    { return !(__a < nullptr); }

  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator>(const __shared_ptr<_Tp1, _Lp>& __a,
       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return (__b < __a); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return nullptr < __a; }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
    { return __a < nullptr; }

  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return !(__a < __b); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return !(__a < nullptr); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
    { return !(nullptr < __a); }


  template<typename _Tp, _Lock_policy _Lp>
    inline void
    swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
    { __a.swap(__b); }
# 1554 "/usr/include/c++/10/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;
# 1636 "/usr/include/c++/10/bits/shared_ptr_base.h" 3
      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 : _M_refcount(__r._M_refcount)
        { _M_ptr = __r.lock().get(); }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
 { }

      __weak_ptr(__weak_ptr&& __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
        { __r._M_ptr = nullptr; }

      __weak_ptr&
      operator=(const __weak_ptr& __r) noexcept = default;

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r.lock().get();
   _M_refcount = __r._M_refcount;
   return *this;
 }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r._M_ptr;
   _M_refcount = __r._M_refcount;
   return *this;
 }

      __weak_ptr&
      operator=(__weak_ptr&& __r) noexcept
      {
 _M_ptr = __r._M_ptr;
 _M_refcount = std::move(__r._M_refcount);
 __r._M_ptr = nullptr;
 return *this;
      }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 {
   _M_ptr = __r.lock().get();
   _M_refcount = std::move(__r._M_refcount);
   __r._M_ptr = nullptr;
   return *this;
 }

      __shared_ptr<_Tp, _Lp>
      lock() const noexcept
      { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }

      long
      use_count() const noexcept
      { return _M_refcount._M_get_use_count(); }

      bool
      expired() const noexcept
      { return _M_refcount._M_get_use_count() == 0; }

      template<typename _Tp1>
 bool
 owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      template<typename _Tp1>
 bool
 owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      void
      reset() noexcept
      { __weak_ptr().swap(*this); }

      void
      swap(__weak_ptr& __s) noexcept
      {
 std::swap(_M_ptr, __s._M_ptr);
 _M_refcount._M_swap(__s._M_refcount);
      }

    private:

      void
      _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
      {
 if (use_count() == 0)
   {
     _M_ptr = __ptr;
     _M_refcount = __refcount;
   }
      }

      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
      friend class __enable_shared_from_this<_Tp, _Lp>;
      friend class enable_shared_from_this<_Tp>;

      element_type* _M_ptr;
      __weak_count<_Lp> _M_refcount;
    };


  template<typename _Tp, _Lock_policy _Lp>
    inline void
    swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
    { __a.swap(__b); }

  template<typename _Tp, typename _Tp1>
    struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }

      bool
      operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }

      bool
      operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }
    };

  template<>
    struct _Sp_owner_less<void, void>
    {
      template<typename _Tp, typename _Up>
 auto
 operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
 -> decltype(__lhs.owner_before(__rhs))
 { return __lhs.owner_before(__rhs); }

      using is_transparent = void;
    };

  template<typename _Tp, _Lock_policy _Lp>
    struct owner_less<__shared_ptr<_Tp, _Lp>>
    : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
    { };

  template<typename _Tp, _Lock_policy _Lp>
    struct owner_less<__weak_ptr<_Tp, _Lp>>
    : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
    { };


  template<typename _Tp, _Lock_policy _Lp>
    class __enable_shared_from_this
    {
    protected:
      constexpr __enable_shared_from_this() noexcept { }

      __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

      __enable_shared_from_this&
      operator=(const __enable_shared_from_this&) noexcept
      { return *this; }

      ~__enable_shared_from_this() { }

    public:
      __shared_ptr<_Tp, _Lp>
      shared_from_this()
      { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

      __shared_ptr<const _Tp, _Lp>
      shared_from_this() const
      { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }


      __weak_ptr<_Tp, _Lp>
      weak_from_this() noexcept
      { return this->_M_weak_this; }

      __weak_ptr<const _Tp, _Lp>
      weak_from_this() const noexcept
      { return this->_M_weak_this; }


    private:
      template<typename _Tp1>
 void
 _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
 { _M_weak_this._M_assign(__p, __n); }

      friend const __enable_shared_from_this*
      __enable_shared_from_this_base(const __shared_count<_Lp>&,
         const __enable_shared_from_this* __p)
      { return __p; }

      template<typename, _Lock_policy>
 friend class __shared_ptr;

      mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
    };

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
    typename _Alloc, typename... _Args>
    inline __shared_ptr<_Tp, _Lp>
    __allocate_shared(const _Alloc& __a, _Args&&... __args)
    {
      return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
    typename... _Args>
    inline __shared_ptr<_Tp, _Lp>
    __make_shared(_Args&&... __args)
    {
      typedef typename std::remove_const<_Tp>::type _Tp_nc;
      return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
           std::forward<_Args>(__args)...);
    }


  template<typename _Tp, _Lock_policy _Lp>
    struct hash<__shared_ptr<_Tp, _Lp>>
    : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
    {
      size_t
      operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
      {
 return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
     __s.get());
      }
    };


}
# 53 "/usr/include/c++/10/bits/shared_ptr.h" 2 3

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

# 67 "/usr/include/c++/10/bits/shared_ptr.h" 3
  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
    inline std::basic_ostream<_Ch, _Tr>&
    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
        const __shared_ptr<_Tp, _Lp>& __p)
    {
      __os << __p.get();
      return __os;
    }

  template<typename _Del, typename _Tp, _Lock_policy _Lp>
    inline _Del*
    get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
    {

      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));



    }





  template<typename _Del, typename _Tp>
    inline _Del*
    get_deleter(const shared_ptr<_Tp>& __p) noexcept
    {

      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));



    }
# 120 "/usr/include/c++/10/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) { }
# 174 "/usr/include/c++/10/bits/shared_ptr.h" 3
      template<typename _Yp, typename _Deleter,
        typename = _Constructible<_Yp*, _Deleter>>
 shared_ptr(_Yp* __p, _Deleter __d)
        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
# 192 "/usr/include/c++/10/bits/shared_ptr.h" 3
      template<typename _Deleter>
 shared_ptr(nullptr_t __p, _Deleter __d)
        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
# 211 "/usr/include/c++/10/bits/shared_ptr.h" 3
      template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _Constructible<_Yp*, _Deleter, _Alloc>>
 shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
# 231 "/usr/include/c++/10/bits/shared_ptr.h" 3
      template<typename _Deleter, typename _Alloc>
 shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
# 255 "/usr/include/c++/10/bits/shared_ptr.h" 3
      template<typename _Yp>
 shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
 : __shared_ptr<_Tp>(__r, __p) { }
# 293 "/usr/include/c++/10/bits/shared_ptr.h" 3
      template<typename _Yp,
        typename = _Constructible<const shared_ptr<_Yp>&>>
 shared_ptr(const shared_ptr<_Yp>& __r) noexcept
        : __shared_ptr<_Tp>(__r) { }






      shared_ptr(shared_ptr&& __r) noexcept
      : __shared_ptr<_Tp>(std::move(__r)) { }






      template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
 shared_ptr(shared_ptr<_Yp>&& __r) noexcept
 : __shared_ptr<_Tp>(std::move(__r)) { }
# 323 "/usr/include/c++/10/bits/shared_ptr.h" 3
      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
 explicit shared_ptr(const weak_ptr<_Yp>& __r)
 : __shared_ptr<_Tp>(__r) { }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
 shared_ptr(auto_ptr<_Yp>&& __r);
#pragma GCC diagnostic pop




      template<typename _Yp, typename _Del,
        typename = _Constructible<unique_ptr<_Yp, _Del>>>
 shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : __shared_ptr<_Tp>(std::move(__r)) { }
# 356 "/usr/include/c++/10/bits/shared_ptr.h" 3
      constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

      shared_ptr& operator=(const shared_ptr&) noexcept = default;

      template<typename _Yp>
 _Assignable<const shared_ptr<_Yp>&>
 operator=(const shared_ptr<_Yp>& __r) noexcept
 {
   this->__shared_ptr<_Tp>::operator=(__r);
   return *this;
 }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp>
 _Assignable<auto_ptr<_Yp>>
 operator=(auto_ptr<_Yp>&& __r)
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }
#pragma GCC diagnostic pop


      shared_ptr&
      operator=(shared_ptr&& __r) noexcept
      {
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
      }

      template<class _Yp>
 _Assignable<shared_ptr<_Yp>>
 operator=(shared_ptr<_Yp>&& __r) noexcept
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

      template<typename _Yp, typename _Del>
 _Assignable<unique_ptr<_Yp, _Del>>
 operator=(unique_ptr<_Yp, _Del>&& __r)
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

    private:

      template<typename _Alloc, typename... _Args>
 shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
 : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
 { }

      template<typename _Yp, typename _Alloc, typename... _Args>
 friend shared_ptr<_Yp>
 allocate_shared(const _Alloc& __a, _Args&&... __args);


      shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
      : __shared_ptr<_Tp>(__r, std::nothrow) { }

      friend class weak_ptr<_Tp>;
    };


  template<typename _Tp>
    shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
  template<typename _Tp, typename _Del>
    shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>;







  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    { return __a.get() == __b.get(); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    { return !__a; }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
    { return !__a; }


  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    { return __a.get() != __b.get(); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    { return (bool)__a; }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
    { return (bool)__a; }


  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    {
      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
      using _Up_elt = typename shared_ptr<_Up>::element_type;
      using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
      return less<_Vp>()(__a.get(), __b.get());
    }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    {
      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
      return less<_Tp_elt*>()(__a.get(), nullptr);
    }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
    {
      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
      return less<_Tp_elt*>()(nullptr, __a.get());
    }


  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    { return !(__b < __a); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    { return !(nullptr < __a); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
    { return !(__a < nullptr); }


  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    { return (__b < __a); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    { return nullptr < __a; }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
    { return __a < nullptr; }


  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    { return !(__a < __b); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    { return !(__a < nullptr); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
    { return !(nullptr < __a); }




  template<typename _Tp>
    inline void
    swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
    { __a.swap(__b); }




  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
    }


  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
    }


  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
 return _Sp(__r, __p);
      return _Sp();
    }



  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
    }
# 668 "/usr/include/c++/10/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;
    };
# 839 "/usr/include/c++/10/bits/shared_ptr.h" 3
  template<typename _Tp, typename _Alloc, typename... _Args>
    inline shared_ptr<_Tp>
    allocate_shared(const _Alloc& __a, _Args&&... __args)
    {
      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }
# 854 "/usr/include/c++/10/bits/shared_ptr.h" 3
  template<typename _Tp, typename... _Args>
    inline shared_ptr<_Tp>
    make_shared(_Args&&... __args)
    {
      typedef typename std::remove_cv<_Tp>::type _Tp_nc;
      return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
           std::forward<_Args>(__args)...);
    }


  template<typename _Tp>
    struct hash<shared_ptr<_Tp>>
    : public __hash_base<size_t, shared_ptr<_Tp>>
    {
      size_t
      operator()(const shared_ptr<_Tp>& __s) const noexcept
      {
 return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
      }
    };





  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp>
      struct _Never_valueless_alt<std::shared_ptr<_Tp>>
      : std::true_type
      { };



    template<typename _Tp>
      struct _Never_valueless_alt<std::weak_ptr<_Tp>>
      : std::true_type
      { };
  }



}
# 84 "/usr/include/c++/10/memory" 2 3
# 1 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 1 3
# 33 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3
# 1 "/usr/include/c++/10/bits/atomic_base.h" 1 3
# 33 "/usr/include/c++/10/bits/atomic_base.h" 3
       
# 34 "/usr/include/c++/10/bits/atomic_base.h" 3



# 1 "/usr/include/c++/10/bits/atomic_lockfree_defines.h" 1 3
# 33 "/usr/include/c++/10/bits/atomic_lockfree_defines.h" 3
       
# 34 "/usr/include/c++/10/bits/atomic_lockfree_defines.h" 3
# 38 "/usr/include/c++/10/bits/atomic_base.h" 2 3






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

# 74 "/usr/include/c++/10/bits/atomic_base.h" 3
  typedef enum memory_order
    {
      memory_order_relaxed,
      memory_order_consume,
      memory_order_acquire,
      memory_order_release,
      memory_order_acq_rel,
      memory_order_seq_cst
    } memory_order;


  enum __memory_order_modifier
    {
      __memory_order_mask = 0x0ffff,
      __memory_order_modifier_mask = 0xffff0000,
      __memory_order_hle_acquire = 0x10000,
      __memory_order_hle_release = 0x20000
    };

  constexpr memory_order
  operator|(memory_order __m, __memory_order_modifier __mod)
  {
    return memory_order(int(__m) | int(__mod));
  }

  constexpr memory_order
  operator&(memory_order __m, __memory_order_modifier __mod)
  {
    return memory_order(int(__m) & int(__mod));
  }


  constexpr memory_order
  __cmpexch_failure_order2(memory_order __m) noexcept
  {
    return __m == memory_order_acq_rel ? memory_order_acquire
      : __m == memory_order_release ? memory_order_relaxed : __m;
  }

  constexpr memory_order
  __cmpexch_failure_order(memory_order __m) noexcept
  {
    return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
      | __memory_order_modifier(__m & __memory_order_modifier_mask));
  }

  inline __attribute__((__always_inline__)) void
  atomic_thread_fence(memory_order __m) noexcept
  { __atomic_thread_fence(int(__m)); }

  inline __attribute__((__always_inline__)) void
  atomic_signal_fence(memory_order __m) noexcept
  { __atomic_signal_fence(int(__m)); }


  template<typename _Tp>
    inline _Tp
    kill_dependency(_Tp __y) noexcept
    {
      _Tp __ret(__y);
      return __ret;
    }



  template<typename _IntTp>
    struct __atomic_base;
# 151 "/usr/include/c++/10/bits/atomic_base.h" 3
  template<typename _Tp>
    struct atomic;

  template<typename _Tp>
    struct atomic<_Tp*>;



    typedef bool __atomic_flag_data_type;
# 174 "/usr/include/c++/10/bits/atomic_base.h" 3
  extern "C" {

  struct __atomic_flag_base
  {
    __atomic_flag_data_type _M_i ;
  };

  }




  struct atomic_flag : public __atomic_flag_base
  {
    atomic_flag() noexcept = default;
    ~atomic_flag() noexcept = default;
    atomic_flag(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) volatile = delete;


    constexpr atomic_flag(bool __i) noexcept
      : __atomic_flag_base{ _S_init(__i) }
    { }

    inline __attribute__((__always_inline__)) bool
    test_and_set(memory_order __m = memory_order_seq_cst) noexcept
    {
      return __atomic_test_and_set (&_M_i, int(__m));
    }

    inline __attribute__((__always_inline__)) bool
    test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
    {
      return __atomic_test_and_set (&_M_i, int(__m));
    }

    inline __attribute__((__always_inline__)) void
    clear(memory_order __m = memory_order_seq_cst) noexcept
    {
      memory_order __b = __m & __memory_order_mask;
      do { if (! (__b != memory_order_consume)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 215, __PRETTY_FUNCTION__, "__b != memory_order_consume"); } while (false);
      do { if (! (__b != memory_order_acquire)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 216, __PRETTY_FUNCTION__, "__b != memory_order_acquire"); } while (false);
      do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 217, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } 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 = __m & __memory_order_mask;
      do { if (! (__b != memory_order_consume)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 226, __PRETTY_FUNCTION__, "__b != memory_order_consume"); } while (false);
      do { if (! (__b != memory_order_acquire)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 227, __PRETTY_FUNCTION__, "__b != memory_order_acquire"); } while (false);
      do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 228, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } while (false);

      __atomic_clear (&_M_i, int(__m));
    }

  private:
    static constexpr __atomic_flag_data_type
    _S_init(bool __i)
    { return __i ? 1 : 0; }
  };
# 264 "/usr/include/c++/10/bits/atomic_base.h" 3
  template<typename _ITp>
    struct __atomic_base
    {
      using value_type = _ITp;
      using difference_type = value_type;

    private:
      typedef _ITp __int_type;

      static constexpr int _S_alignment =
 sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);

      alignas(_S_alignment) __int_type _M_i ;

    public:
      __atomic_base() noexcept = default;
      ~__atomic_base() noexcept = default;
      __atomic_base(const __atomic_base&) = delete;
      __atomic_base& operator=(const __atomic_base&) = delete;
      __atomic_base& operator=(const __atomic_base&) volatile = delete;


      constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }

      operator __int_type() const noexcept
      { return load(); }

      operator __int_type() const volatile noexcept
      { return load(); }

      __int_type
      operator=(__int_type __i) noexcept
      {
 store(__i);
 return __i;
      }

      __int_type
      operator=(__int_type __i) volatile noexcept
      {
 store(__i);
 return __i;
      }

      __int_type
      operator++(int) noexcept
      { return fetch_add(1); }

      __int_type
      operator++(int) volatile noexcept
      { return fetch_add(1); }

      __int_type
      operator--(int) noexcept
      { return fetch_sub(1); }

      __int_type
      operator--(int) volatile noexcept
      { return fetch_sub(1); }

      __int_type
      operator++() noexcept
      { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator++() volatile noexcept
      { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator--() noexcept
      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator--() volatile noexcept
      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }

      __int_type
      operator+=(__int_type __i) noexcept
      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator+=(__int_type __i) volatile noexcept
      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator-=(__int_type __i) noexcept
      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator-=(__int_type __i) volatile noexcept
      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator&=(__int_type __i) noexcept
      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator&=(__int_type __i) volatile noexcept
      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator|=(__int_type __i) noexcept
      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator|=(__int_type __i) volatile noexcept
      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator^=(__int_type __i) noexcept
      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      __int_type
      operator^=(__int_type __i) volatile noexcept
      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }

      bool
      is_lock_free() const noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }

      inline __attribute__((__always_inline__)) void
      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
      {
 memory_order __b = __m & __memory_order_mask;
 do { if (! (__b != memory_order_acquire)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 400, __PRETTY_FUNCTION__, "__b != memory_order_acquire"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 401, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } while (false);
 do { if (! (__b != memory_order_consume)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 402, __PRETTY_FUNCTION__, "__b != memory_order_consume"); } 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 = __m & __memory_order_mask;
 do { if (! (__b != memory_order_acquire)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 412, __PRETTY_FUNCTION__, "__b != memory_order_acquire"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 413, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } while (false);
 do { if (! (__b != memory_order_consume)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 414, __PRETTY_FUNCTION__, "__b != memory_order_consume"); } 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 = __m & __memory_order_mask;
 do { if (! (__b != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 423, __PRETTY_FUNCTION__, "__b != memory_order_release"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 424, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } 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 = __m & __memory_order_mask;
 do { if (! (__b != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 433, __PRETTY_FUNCTION__, "__b != memory_order_release"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 434, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } 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
      {
 memory_order __b2 = __m2 & __memory_order_mask;
 memory_order __b1 = __m1 & __memory_order_mask;
 do { if (! (__b2 != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 460, __PRETTY_FUNCTION__, "__b2 != memory_order_release"); } while (false);
 do { if (! (__b2 != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 461, __PRETTY_FUNCTION__, "__b2 != memory_order_acq_rel"); } while (false);
 do { if (! (__b2 <= __b1)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 462, __PRETTY_FUNCTION__, "__b2 <= __b1"); } 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
      {
 memory_order __b2 = __m2 & __memory_order_mask;
 memory_order __b1 = __m1 & __memory_order_mask;
 do { if (! (__b2 != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 475, __PRETTY_FUNCTION__, "__b2 != memory_order_release"); } while (false);
 do { if (! (__b2 != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 476, __PRETTY_FUNCTION__, "__b2 != memory_order_acq_rel"); } while (false);
 do { if (! (__b2 <= __b1)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 477, __PRETTY_FUNCTION__, "__b2 <= __b1"); } 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
      {
 memory_order __b2 = __m2 & __memory_order_mask;
 memory_order __b1 = __m1 & __memory_order_mask;
 do { if (! (__b2 != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 505, __PRETTY_FUNCTION__, "__b2 != memory_order_release"); } while (false);
 do { if (! (__b2 != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 506, __PRETTY_FUNCTION__, "__b2 != memory_order_acq_rel"); } while (false);
 do { if (! (__b2 <= __b1)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 507, __PRETTY_FUNCTION__, "__b2 <= __b1"); } 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
      {
 memory_order __b2 = __m2 & __memory_order_mask;
 memory_order __b1 = __m1 & __memory_order_mask;

 do { if (! (__b2 != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 521, __PRETTY_FUNCTION__, "__b2 != memory_order_release"); } while (false);
 do { if (! (__b2 != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 522, __PRETTY_FUNCTION__, "__b2 != memory_order_acq_rel"); } while (false);
 do { if (! (__b2 <= __b1)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 523, __PRETTY_FUNCTION__, "__b2 <= __b1"); } 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__)) __int_type
      fetch_add(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_add(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_sub(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_sub(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_and(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_and(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_or(__int_type __i,
        memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_or(__int_type __i,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_xor(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_xor(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }
    };



  template<typename _PTp>
    struct __atomic_base<_PTp*>
    {
    private:
      typedef _PTp* __pointer_type;

      __pointer_type _M_p ;


      constexpr ptrdiff_t
      _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }

      constexpr ptrdiff_t
      _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }

    public:
      __atomic_base() noexcept = default;
      ~__atomic_base() noexcept = default;
      __atomic_base(const __atomic_base&) = delete;
      __atomic_base& operator=(const __atomic_base&) = delete;
      __atomic_base& operator=(const __atomic_base&) volatile = delete;


      constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }

      operator __pointer_type() const noexcept
      { return load(); }

      operator __pointer_type() const volatile noexcept
      { return load(); }

      __pointer_type
      operator=(__pointer_type __p) noexcept
      {
 store(__p);
 return __p;
      }

      __pointer_type
      operator=(__pointer_type __p) volatile noexcept
      {
 store(__p);
 return __p;
      }

      __pointer_type
      operator++(int) noexcept
      { return fetch_add(1); }

      __pointer_type
      operator++(int) volatile noexcept
      { return fetch_add(1); }

      __pointer_type
      operator--(int) noexcept
      { return fetch_sub(1); }

      __pointer_type
      operator--(int) volatile noexcept
      { return fetch_sub(1); }

      __pointer_type
      operator++() noexcept
      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator++() volatile noexcept
      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator--() noexcept
      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator--() volatile noexcept
      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator+=(ptrdiff_t __d) noexcept
      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator+=(ptrdiff_t __d) volatile noexcept
      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator-=(ptrdiff_t __d) noexcept
      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
      int(memory_order_seq_cst)); }

      __pointer_type
      operator-=(ptrdiff_t __d) volatile noexcept
      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
      int(memory_order_seq_cst)); }

      bool
      is_lock_free() const noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_p),
     reinterpret_cast<void *>(-__alignof(_M_p)));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_p),
     reinterpret_cast<void *>(-__alignof(_M_p)));
      }

      inline __attribute__((__always_inline__)) void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) noexcept
      {
        memory_order __b = __m & __memory_order_mask;

 do { if (! (__b != memory_order_acquire)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 721, __PRETTY_FUNCTION__, "__b != memory_order_acquire"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 722, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } while (false);
 do { if (! (__b != memory_order_consume)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 723, __PRETTY_FUNCTION__, "__b != memory_order_consume"); } 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 = __m & __memory_order_mask;
 do { if (! (__b != memory_order_acquire)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 733, __PRETTY_FUNCTION__, "__b != memory_order_acquire"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 734, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } while (false);
 do { if (! (__b != memory_order_consume)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 735, __PRETTY_FUNCTION__, "__b != memory_order_consume"); } 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 = __m & __memory_order_mask;
 do { if (! (__b != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 744, __PRETTY_FUNCTION__, "__b != memory_order_release"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 745, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } 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 = __m & __memory_order_mask;
 do { if (! (__b != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 754, __PRETTY_FUNCTION__, "__b != memory_order_release"); } while (false);
 do { if (! (__b != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 755, __PRETTY_FUNCTION__, "__b != memory_order_acq_rel"); } 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_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1,
         memory_order __m2) noexcept
      {
 memory_order __b2 = __m2 & __memory_order_mask;
 memory_order __b1 = __m1 & __memory_order_mask;
 do { if (! (__b2 != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 782, __PRETTY_FUNCTION__, "__b2 != memory_order_release"); } while (false);
 do { if (! (__b2 != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 783, __PRETTY_FUNCTION__, "__b2 != memory_order_acq_rel"); } while (false);
 do { if (! (__b2 <= __b1)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 784, __PRETTY_FUNCTION__, "__b2 <= __b1"); } 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
      {
 memory_order __b2 = __m2 & __memory_order_mask;
 memory_order __b1 = __m1 & __memory_order_mask;

 do { if (! (__b2 != memory_order_release)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 798, __PRETTY_FUNCTION__, "__b2 != memory_order_release"); } while (false);
 do { if (! (__b2 != memory_order_acq_rel)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 799, __PRETTY_FUNCTION__, "__b2 != memory_order_acq_rel"); } while (false);
 do { if (! (__b2 <= __b1)) std::__replacement_assert("/usr/include/c++/10/bits/atomic_base.h", 800, __PRETTY_FUNCTION__, "__b2 <= __b1"); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); }

      inline __attribute__((__always_inline__)) __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); }

      inline __attribute__((__always_inline__)) __pointer_type
      fetch_sub(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); }

      inline __attribute__((__always_inline__)) __pointer_type
      fetch_sub(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); }
    };
# 1700 "/usr/include/c++/10/bits/atomic_base.h" 3

}
# 34 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 2 3

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

# 47 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3
  struct _Sp_locker
  {
    _Sp_locker(const _Sp_locker&) = delete;
    _Sp_locker& operator=(const _Sp_locker&) = delete;


    explicit
    _Sp_locker(const void*) noexcept;
    _Sp_locker(const void*, const void*) noexcept;
    ~_Sp_locker();

  private:
    unsigned char _M_key1;
    unsigned char _M_key2;



  };
# 74 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3
  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
    {

      return __gthread_active_p() == 0;



    }

  template<typename _Tp>
    inline bool
    atomic_is_lock_free(const shared_ptr<_Tp>* __p)
    { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
# 101 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

  template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_load(const shared_ptr<_Tp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }

  template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
# 137 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    inline void
    atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
    }

  template<typename _Tp>
    inline void
    atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }

  template<typename _Tp, _Lock_policy _Lp>
    inline void
    atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
     __shared_ptr<_Tp, _Lp> __r,
     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline void
    atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
# 174 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
        memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

  template<typename _Tp>
    inline shared_ptr<_Tp>
    atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    {
      return std::atomic_exchange_explicit(__p, std::move(__r),
        memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
        __shared_ptr<_Tp, _Lp> __r,
        memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
    {
      return std::atomic_exchange_explicit(__p, std::move(__r),
        memory_order_seq_cst);
    }
# 223 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    bool
    atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
         shared_ptr<_Tp>* __v,
         shared_ptr<_Tp> __w,
         memory_order,
         memory_order)
    {
      shared_ptr<_Tp> __x;
      _Sp_locker __lock{__p, __v};
      owner_less<shared_ptr<_Tp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 {
   __x = std::move(*__p);
   *__p = std::move(__w);
   return true;
 }
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

  template<typename _Tp>
    inline bool
    atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
     shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp>
    inline bool
    atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
       shared_ptr<_Tp>* __v,
       shared_ptr<_Tp> __w,
       memory_order __success,
       memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), __success, __failure);
    }

  template<typename _Tp>
    inline bool
    atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
     shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_weak_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    bool
    atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
         __shared_ptr<_Tp, _Lp>* __v,
         __shared_ptr<_Tp, _Lp> __w,
         memory_order,
         memory_order)
    {
      __shared_ptr<_Tp, _Lp> __x;
      _Sp_locker __lock{__p, __v};
      owner_less<__shared_ptr<_Tp, _Lp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 {
   __x = std::move(*__p);
   *__p = std::move(__w);
   return true;
 }
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
       __shared_ptr<_Tp, _Lp>* __v,
       __shared_ptr<_Tp, _Lp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
       __shared_ptr<_Tp, _Lp>* __v,
       __shared_ptr<_Tp, _Lp> __w,
       memory_order __success,
       memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), __success, __failure);
    }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
     __shared_ptr<_Tp, _Lp>* __v,
     __shared_ptr<_Tp, _Lp> __w)
    {
      return std::atomic_compare_exchange_weak_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }






}
# 85 "/usr/include/c++/10/memory" 2 3

# 1 "/usr/include/c++/10/backward/auto_ptr.h" 1 3
# 36 "/usr/include/c++/10/backward/auto_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 47 "/usr/include/c++/10/backward/auto_ptr.h" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    } __attribute__ ((__deprecated__));

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 88 "/usr/include/c++/10/backward/auto_ptr.h" 3
  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:

      typedef _Tp element_type;







      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
# 114 "/usr/include/c++/10/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 126 "/usr/include/c++/10/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 137 "/usr/include/c++/10/backward/auto_ptr.h" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 154 "/usr/include/c++/10/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 172 "/usr/include/c++/10/backward/auto_ptr.h" 3
      ~auto_ptr() { delete _M_ptr; }
# 182 "/usr/include/c++/10/backward/auto_ptr.h" 3
      element_type&
      operator*() const throw()
      {
 do { if (! (_M_ptr != 0)) std::__replacement_assert("/usr/include/c++/10/backward/auto_ptr.h", 185, __PRETTY_FUNCTION__, "_M_ptr != 0"); } while (false);
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 do { if (! (_M_ptr != 0)) std::__replacement_assert("/usr/include/c++/10/backward/auto_ptr.h", 198, __PRETTY_FUNCTION__, "_M_ptr != 0"); } while (false);
 return _M_ptr;
      }
# 212 "/usr/include/c++/10/backward/auto_ptr.h" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 226 "/usr/include/c++/10/backward/auto_ptr.h" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 241 "/usr/include/c++/10/backward/auto_ptr.h" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 266 "/usr/include/c++/10/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
 if (__ref._M_ptr != this->get())
   {
     delete _M_ptr;
     _M_ptr = __ref._M_ptr;
   }
 return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }
    } __attribute__ ((__deprecated__));



  template<>
    class auto_ptr<void>
    {
    public:
      typedef void element_type;
    } __attribute__ ((__deprecated__));


  template<_Lock_policy _Lp>
  template<typename _Tp>
    inline
    __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
    : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
    { __r.release(); }

  template<typename _Tp, _Lock_policy _Lp>
  template<typename _Tp1, typename>
    inline
    __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
    : _M_ptr(__r.get()), _M_refcount()
    {
     
      static_assert( sizeof(_Tp1) > 0, "incomplete type" );
      _Tp1* __tmp = __r.get();
      _M_refcount = __shared_count<_Lp>(std::move(__r));
      _M_enable_shared_from_this_with(__tmp);
    }

  template<typename _Tp>
  template<typename _Tp1, typename>
    inline
    shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
    : __shared_ptr<_Tp>(std::move(__r)) { }

  template<typename _Tp, typename _Dp>
  template<typename _Up, typename>
    inline
    unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
    : _M_t(__u.release(), deleter_type()) { }


#pragma GCC diagnostic pop


}
# 87 "/usr/include/c++/10/memory" 2 3
# 99 "/usr/include/c++/10/memory" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 121 "/usr/include/c++/10/memory" 3
inline void*
align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
{

  const auto __intptr = reinterpret_cast<uintptr_t>(__ptr);






  const auto __aligned = (__intptr - 1u + __align) & -__align;
  const auto __diff = __aligned - __intptr;
  if ((__size + __diff) > __space)
    return nullptr;
  else
    {
      __space -= __diff;
      return __ptr = reinterpret_cast<void*>(__aligned);
    }
}
# 157 "/usr/include/c++/10/memory" 3
enum class pointer_safety { relaxed, preferred, strict };


inline void
declare_reachable(void*) { }


template <typename _Tp>
  inline _Tp*
  undeclare_reachable(_Tp* __p) { return __p; }


inline void
declare_no_pointers(char*, size_t) { }


inline void
undeclare_no_pointers(char*, size_t) { }


inline pointer_safety
get_pointer_safety() noexcept { return pointer_safety::relaxed; }
# 397 "/usr/include/c++/10/memory" 3

}
# 408 "/usr/include/c++/10/memory" 3
# 1 "/usr/include/c++/10/pstl/glue_memory_defs.h" 1 3
# 15 "/usr/include/c++/10/pstl/glue_memory_defs.h" 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);

}
# 409 "/usr/include/c++/10/memory" 2 3
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_fwd.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_fwd.hpp" 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_fwd.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_traits.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_traits.hpp" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_traits.hpp" 2 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_traits.hpp" 3 4
       
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_traits.hpp" 3


namespace boost {
template<class T>
class integer_traits : public std::numeric_limits<T>
{
public:
  static const bool is_integral = false;
};

namespace detail {
template<class T, T min_val, T max_val>
class integer_traits_base
{
public:
  static const bool is_integral = true;
  static const T const_min = min_val;
  static const T const_max = max_val;
};



template<class T, T min_val, T max_val>
const bool integer_traits_base<T, min_val, max_val>::is_integral;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_min;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_max;


}

template<>
class integer_traits<bool>
  : public std::numeric_limits<bool>,
    public detail::integer_traits_base<bool, false, true>
{ };

template<>
class integer_traits<char>
  : public std::numeric_limits<char>,
    public detail::integer_traits_base<char, (-0x7f - 1), 0x7f>
{ };

template<>
class integer_traits<signed char>
  : public std::numeric_limits<signed char>,
    public detail::integer_traits_base<signed char, (-0x7f - 1), 0x7f>
{ };

template<>
class integer_traits<unsigned char>
  : public std::numeric_limits<unsigned char>,
    public detail::integer_traits_base<unsigned char, 0, (0x7f * 2 + 1)>
{ };


template<>
class integer_traits<wchar_t>
  : public std::numeric_limits<wchar_t>,



    public detail::integer_traits_base<wchar_t, (-0x7fffffff - 1), 0x7fffffff>
# 125 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_traits.hpp" 3
{ };


template<>
class integer_traits<short>
  : public std::numeric_limits<short>,
    public detail::integer_traits_base<short, (-0x7fff - 1), 0x7fff>
{ };

template<>
class integer_traits<unsigned short>
  : public std::numeric_limits<unsigned short>,
    public detail::integer_traits_base<unsigned short, 0, (0x7fff * 2 + 1)>
{ };

template<>
class integer_traits<int>
  : public std::numeric_limits<int>,
    public detail::integer_traits_base<int, (-0x7fffffff - 1), 0x7fffffff>
{ };

template<>
class integer_traits<unsigned int>
  : public std::numeric_limits<unsigned int>,
    public detail::integer_traits_base<unsigned int, 0, (0x7fffffff * 2U + 1U)>
{ };

template<>
class integer_traits<long>
  : public std::numeric_limits<long>,
    public detail::integer_traits_base<long, (-0x7fffffffffffffffL - 1L), 0x7fffffffffffffffL>
{ };

template<>
class integer_traits<unsigned long>
  : public std::numeric_limits<unsigned long>,
    public detail::integer_traits_base<unsigned long, 0, (0x7fffffffffffffffL * 2UL + 1UL)>
{ };




template<>
class integer_traits< ::boost::long_long_type>
  : public std::numeric_limits< ::boost::long_long_type>,
    public detail::integer_traits_base< ::boost::long_long_type, (-0x7fffffffffffffffLL -1), 0x7fffffffffffffffLL>
{ };

template<>
class integer_traits< ::boost::ulong_long_type>
  : public std::numeric_limits< ::boost::ulong_long_type>,
    public detail::integer_traits_base< ::boost::ulong_long_type, 0, (0x7fffffffffffffffLL * 2ULL + 1)>
{ };
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer_traits.hpp" 3
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer.hpp" 3 4
       
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer.hpp" 3
      typedef typename boost::detail::uint_least_helper
        <

          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +



          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
        >::least least;

      typedef typename int_fast_t<least>::type fast;
  };


}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
        
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/type_index_facade.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/type_index_facade.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash_fwd.hpp" 3 4
       



namespace boost
{
    template <class T> struct hash;

    template <class T> void hash_combine(std::size_t& seed, T const& v);

    template <class It> std::size_t hash_range(It, It);
    template <class It> void hash_range(std::size_t&, It, It);





}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/type_index_facade.hpp" 2 3 4

# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/type_index_facade.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/type_index_facade.hpp" 3 4
        


namespace boost { namespace typeindex {
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 2 3 4







# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/demangle.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/demangle.hpp" 3 4
        
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/demangle.hpp" 3 4
# 1 "/usr/include/c++/10/cxxabi.h" 1 3 4
# 44 "/usr/include/c++/10/cxxabi.h" 3 4
       
# 45 "/usr/include/c++/10/cxxabi.h" 3

#pragma GCC visibility push(default)

# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 49 "/usr/include/c++/10/cxxabi.h" 2 3

# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 1 3
# 34 "/usr/include/c++/10/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 3
namespace __cxxabiv1
{
  extern "C"
  {
# 46 "/usr/include/c++/10/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/include/c++/10/cxxabi.h" 2 3




namespace __cxxabiv1
{
  extern "C"
  {


  typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);


  void*
  __cxa_vec_new(size_t __element_count, size_t __element_size,
  size_t __padding_size, __cxa_cdtor_type __constructor,
  __cxa_cdtor_type __destructor);

  void*
  __cxa_vec_new2(size_t __element_count, size_t __element_size,
   size_t __padding_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
   void (*__dealloc) (void*));

  void*
  __cxa_vec_new3(size_t __element_count, size_t __element_size,
   size_t __padding_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
   void (*__dealloc) (void*, size_t));


  __cxa_vec_ctor_return_type
  __cxa_vec_ctor(void* __array_address, size_t __element_count,
   size_t __element_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor);

  __cxa_vec_ctor_return_type
  __cxa_vec_cctor(void* __dest_array, void* __src_array,
    size_t __element_count, size_t __element_size,
    __cxa_cdtor_return_type (*__constructor) (void*, void*),
    __cxa_cdtor_type __destructor);


  void
  __cxa_vec_dtor(void* __array_address, size_t __element_count,
   size_t __element_size, __cxa_cdtor_type __destructor);

  void
  __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
      __cxa_cdtor_type __destructor) noexcept;


  void
  __cxa_vec_delete(void* __array_address, size_t __element_size,
     size_t __padding_size, __cxa_cdtor_type __destructor);

  void
  __cxa_vec_delete2(void* __array_address, size_t __element_size,
      size_t __padding_size, __cxa_cdtor_type __destructor,
      void (*__dealloc) (void*));

  void
  __cxa_vec_delete3(void* __array_address, size_t __element_size,
      size_t __padding_size, __cxa_cdtor_type __destructor,
      void (*__dealloc) (void*, size_t));

  int
  __cxa_guard_acquire(__guard*);

  void
  __cxa_guard_release(__guard*) noexcept;

  void
  __cxa_guard_abort(__guard*) noexcept;


  int
  __cxa_atexit(void (*)(void*), void*, void*) noexcept;

  int
  __cxa_finalize(void*);


  int
  __cxa_thread_atexit(void (*)(void*), void*, void *) noexcept;


  void
  __cxa_pure_virtual(void) __attribute__ ((__noreturn__));

  void
  __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));


  void
  __cxa_bad_cast() __attribute__((__noreturn__));

  void
  __cxa_bad_typeid() __attribute__((__noreturn__));

  void
  __cxa_throw_bad_array_new_length() __attribute__((__noreturn__));
# 195 "/usr/include/c++/10/cxxabi.h" 3
  char*
  __cxa_demangle(const char* __mangled_name, char* __output_buffer,
   size_t* __length, int* __status);


  }
}






namespace __cxxabiv1
{

  class __fundamental_type_info : public std::type_info
  {
  public:
    explicit
    __fundamental_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__fundamental_type_info();
  };


  class __array_type_info : public std::type_info
  {
  public:
    explicit
    __array_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__array_type_info();
  };


  class __function_type_info : public std::type_info
  {
  public:
    explicit
    __function_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__function_type_info();

  protected:

    virtual bool
    __is_function_p() const;
  };


  class __enum_type_info : public std::type_info
  {
  public:
    explicit
    __enum_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__enum_type_info();
  };


  class __pbase_type_info : public std::type_info
  {
  public:
    unsigned int __flags;
    const std::type_info* __pointee;

    explicit
    __pbase_type_info(const char* __n, int __quals,
        const std::type_info* __type)
    : std::type_info(__n), __flags(__quals), __pointee(__type)
    { }

    virtual
    ~__pbase_type_info();


    enum __masks
      {
 __const_mask = 0x1,
 __volatile_mask = 0x2,
 __restrict_mask = 0x4,
 __incomplete_mask = 0x8,
 __incomplete_class_mask = 0x10,
 __transaction_safe_mask = 0x20,
 __noexcept_mask = 0x40
      };

  protected:
    __pbase_type_info(const __pbase_type_info&);

    __pbase_type_info&
    operator=(const __pbase_type_info&);


    virtual bool
    __do_catch(const std::type_info* __thr_type, void** __thr_obj,
        unsigned int __outer) const;

    inline virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };

  inline bool __pbase_type_info::
  __pointer_catch (const __pbase_type_info *thrown_type,
     void **thr_obj,
     unsigned outer) const
  {
    return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
  }


  class __pointer_type_info : public __pbase_type_info
  {
  public:
    explicit
    __pointer_type_info(const char* __n, int __quals,
   const std::type_info* __type)
    : __pbase_type_info (__n, __quals, __type) { }


    virtual
    ~__pointer_type_info();

  protected:

    virtual bool
    __is_pointer_p() const;

    virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };

  class __class_type_info;


  class __pointer_to_member_type_info : public __pbase_type_info
  {
  public:
    __class_type_info* __context;

    explicit
    __pointer_to_member_type_info(const char* __n, int __quals,
      const std::type_info* __type,
      __class_type_info* __klass)
    : __pbase_type_info(__n, __quals, __type), __context(__klass) { }

    virtual
    ~__pointer_to_member_type_info();

  protected:
    __pointer_to_member_type_info(const __pointer_to_member_type_info&);

    __pointer_to_member_type_info&
    operator=(const __pointer_to_member_type_info&);


    virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };


  class __base_class_type_info
  {
  public:
    const __class_type_info* __base_type;



    long __offset_flags;


    enum __offset_flags_masks
      {
 __virtual_mask = 0x1,
 __public_mask = 0x2,
 __hwm_bit = 2,
 __offset_shift = 8
      };


    bool
    __is_virtual_p() const
    { return __offset_flags & __virtual_mask; }

    bool
    __is_public_p() const
    { return __offset_flags & __public_mask; }

    ptrdiff_t
    __offset() const
    {



      return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
    }
  };


  class __class_type_info : public std::type_info
  {
  public:
    explicit
    __class_type_info (const char *__n) : type_info(__n) { }

    virtual
    ~__class_type_info ();






    enum __sub_kind
      {

 __unknown = 0,



 __not_contained,


 __contained_ambig,


 __contained_virtual_mask = __base_class_type_info::__virtual_mask,


 __contained_public_mask = __base_class_type_info::__public_mask,


 __contained_mask = 1 << __base_class_type_info::__hwm_bit,

 __contained_private = __contained_mask,
 __contained_public = __contained_mask | __contained_public_mask
      };

    struct __upcast_result;
    struct __dyncast_result;

  protected:

    virtual bool
    __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;

    virtual bool
    __do_catch(const type_info* __thr_type, void** __thr_obj,
        unsigned __outer) const;

  public:


    virtual bool
    __do_upcast(const __class_type_info* __dst, const void* __obj,
  __upcast_result& __restrict __result) const;







    inline __sub_kind
    __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
        const __class_type_info* __src_type,
        const void* __src_ptr) const;
# 478 "/usr/include/c++/10/cxxabi.h" 3
    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;





    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __src_ptr) const;
  };


  class __si_class_type_info : public __class_type_info
  {
  public:
    const __class_type_info* __base_type;

    explicit
    __si_class_type_info(const char *__n, const __class_type_info *__base)
    : __class_type_info(__n), __base_type(__base) { }

    virtual
    ~__si_class_type_info();

  protected:
    __si_class_type_info(const __si_class_type_info&);

    __si_class_type_info&
    operator=(const __si_class_type_info&);


    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;

    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __sub_ptr) const;

    virtual bool
    __do_upcast(const __class_type_info*__dst, const void*__obj,
  __upcast_result& __restrict __result) const;
  };


  class __vmi_class_type_info : public __class_type_info
  {
  public:
    unsigned int __flags;
    unsigned int __base_count;




    __base_class_type_info __base_info[1];

    explicit
    __vmi_class_type_info(const char* __n, int ___flags)
    : __class_type_info(__n), __flags(___flags), __base_count(0) { }

    virtual
    ~__vmi_class_type_info();


    enum __flags_masks
      {
 __non_diamond_repeat_mask = 0x1,
 __diamond_shaped_mask = 0x2,
 __flags_unknown_mask = 0x10
      };

  protected:

    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;

    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __src_ptr) const;

    virtual bool
    __do_upcast(const __class_type_info* __dst, const void* __obj,
  __upcast_result& __restrict __result) const;
  };


  struct __cxa_exception;
  struct __cxa_refcounted_exception;
  struct __cxa_dependent_exception;
  struct __cxa_eh_globals;

  extern "C"
  {
# 591 "/usr/include/c++/10/cxxabi.h" 3
  void*
  __dynamic_cast(const void* __src_ptr,
   const __class_type_info* __src_type,
   const __class_type_info* __dst_type,
   ptrdiff_t __src2dst);
# 604 "/usr/include/c++/10/cxxabi.h" 3
  __cxa_eh_globals*
  __cxa_get_globals() noexcept __attribute__ ((__const__));

  __cxa_eh_globals*
  __cxa_get_globals_fast() noexcept __attribute__ ((__const__));


  void
  __cxa_free_exception(void*) noexcept;


  void
  __cxa_throw(void*, std::type_info*, void ( *) (void *))
  __attribute__((__noreturn__));


  void*
  __cxa_get_exception_ptr(void*) noexcept __attribute__ ((__pure__));

  void*
  __cxa_begin_catch(void*) noexcept;

  void
  __cxa_end_catch();

  void
  __cxa_rethrow() __attribute__((__noreturn__));



  std::type_info*
  __cxa_current_exception_type() noexcept __attribute__ ((__pure__));




  __cxa_dependent_exception*
  __cxa_allocate_dependent_exception() noexcept;


  void
  __cxa_free_dependent_exception(__cxa_dependent_exception*) noexcept;

  }



  class __foreign_exception
  {
    virtual ~__foreign_exception() throw();
    virtual void __pure_dummy() = 0;
  };

}
# 679 "/usr/include/c++/10/cxxabi.h" 3
namespace abi = __cxxabiv1;

namespace __gnu_cxx
{
# 696 "/usr/include/c++/10/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/demangle.hpp" 2 3 4






# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/demangle.hpp" 3 4
}

}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 3 4
       


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/float_functions.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/float_functions.hpp" 3 4
       


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/no_tr1/cmath.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/no_tr1/cmath.hpp" 3 4
# 1 "/usr/include/c++/10/cmath" 1 3 4
# 39 "/usr/include/c++/10/cmath" 3 4
       
# 40 "/usr/include/c++/10/cmath" 3





# 1 "/usr/include/math.h" 1 3 4
# 27 "/usr/include/math.h" 3 4
# 1 "/usr/include/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
# 138 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4
# 139 "/usr/include/math.h" 2 3 4
# 149 "/usr/include/math.h" 3 4
typedef float float_t;
typedef double double_t;
# 190 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/fp-logb.h" 1 3 4
# 191 "/usr/include/math.h" 2 3 4
# 233 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/fp-fast.h" 1 3 4
# 234 "/usr/include/math.h" 2 3 4



enum
  {
    FP_INT_UPWARD =

      0,
    FP_INT_DOWNWARD =

      1,
    FP_INT_TOWARDZERO =

      2,
    FP_INT_TONEARESTFROMZERO =

      3,
    FP_INT_TONEAREST =

      4,
  };
# 289 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassify (double __value) throw ()
     __attribute__ ((__const__));


extern int __signbit (double __value) throw ()
     __attribute__ ((__const__));



extern int __isinf (double __value) throw () __attribute__ ((__const__));


extern int __finite (double __value) throw () __attribute__ ((__const__));


extern int __isnan (double __value) throw () __attribute__ ((__const__));


extern int __iseqsig (double __x, double __y) throw ();


extern int __issignaling (double __value) throw ()
     __attribute__ ((__const__));
# 290 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();

extern double asin (double __x) throw (); extern double __asin (double __x) throw ();

extern double atan (double __x) throw (); extern double __atan (double __x) throw ();

extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();


 extern double cos (double __x) throw (); extern double __cos (double __x) throw ();

 extern double sin (double __x) throw (); extern double __sin (double __x) throw ();

extern double tan (double __x) throw (); extern double __tan (double __x) throw ();




extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();

extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();

extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();



 extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
                                                        ;




extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();

extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();

extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();





 extern double exp (double __x) throw (); extern double __exp (double __x) throw ();


extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();


extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();


 extern double log (double __x) throw (); extern double __log (double __x) throw ();


extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();


extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();




extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();


extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();


extern double logb (double __x) throw (); extern double __logb (double __x) throw ();




extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();


extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();






 extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();


extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();



extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();




extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();






extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));


extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));


extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));


extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
# 182 "/usr/include/bits/mathcalls.h" 3 4
extern int finite (double __value) throw () __attribute__ ((__const__));


extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();



extern double significand (double __x) throw (); extern double __significand (double __x) throw ();






extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));




extern double nan (const char *__tagb) throw (); extern double __nan (const char *__tagb) throw ();
# 217 "/usr/include/bits/mathcalls.h" 3 4
extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();





extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();




extern double tgamma (double) throw (); extern double __tgamma (double) throw ();





extern double gamma (double) throw (); extern double __gamma (double) throw ();







extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();






extern double rint (double __x) throw (); extern double __rint (double __x) throw ();


extern double nextafter (double __x, double __y) throw (); extern double __nextafter (double __x, double __y) throw ();

extern double nexttoward (double __x, long double __y) throw (); extern double __nexttoward (double __x, long double __y) throw ();




extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();

extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();



extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();



extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();



extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();




extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw ();




extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();



extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();



extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));



extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();






extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
__extension__
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();



extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
__extension__
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();



extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();


extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));


extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));


extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();




extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfp (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) throw ()
                               ;


extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__));


extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__));


extern int canonicalize (double *__cx, const double *__x) throw ();




extern int totalorder (const double *__x, const double *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermag (const double *__x, const double *__y) throw ()

     __attribute__ ((__pure__));


extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw ();


extern int setpayload (double *__x, double __payload) throw ();


extern int setpayloadsig (double *__x, double __payload) throw ();







extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 291 "/usr/include/math.h" 2 3 4
# 306 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyf (float __value) throw ()
     __attribute__ ((__const__));


extern int __signbitf (float __value) throw ()
     __attribute__ ((__const__));



extern int __isinff (float __value) throw () __attribute__ ((__const__));


extern int __finitef (float __value) throw () __attribute__ ((__const__));


extern int __isnanf (float __value) throw () __attribute__ ((__const__));


extern int __iseqsigf (float __x, float __y) throw ();


extern int __issignalingf (float __value) throw ()
     __attribute__ ((__const__));
# 307 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();

extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();

extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();

extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();


 extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();

 extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();

extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();




extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();

extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();

extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();



 extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ()
                                                        ;




extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();

extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();

extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();





 extern float expf (float __x) throw (); extern float __expf (float __x) throw ();


extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();


extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();


 extern float logf (float __x) throw (); extern float __logf (float __x) throw ();


extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();


extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();




extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();


extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();


extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();




extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();


extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();






 extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();


extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();



extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();




extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();






extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));


extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));


extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));


extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
# 177 "/usr/include/bits/mathcalls.h" 3 4
extern int isinff (float __value) throw () __attribute__ ((__const__));




extern int finitef (float __value) throw () __attribute__ ((__const__));


extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();



extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();






extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));




extern float nanf (const char *__tagb) throw (); extern float __nanf (const char *__tagb) throw ();
# 211 "/usr/include/bits/mathcalls.h" 3 4
extern int isnanf (float __value) throw () __attribute__ ((__const__));





extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();





extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();




extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();





extern float gammaf (float) throw (); extern float __gammaf (float) throw ();







extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();






extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();


extern float nextafterf (float __x, float __y) throw (); extern float __nextafterf (float __x, float __y) throw ();

extern float nexttowardf (float __x, long double __y) throw (); extern float __nexttowardf (float __x, long double __y) throw ();




extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();

extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();



extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();



extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();



extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();




extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw ();




extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();



extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();



extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));



extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();






extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
__extension__
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();



extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
__extension__
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();



extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();


extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));


extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));


extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();




extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) throw ()
                               ;


extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__));


extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__));


extern int canonicalizef (float *__cx, const float *__x) throw ();




extern int totalorderf (const float *__x, const float *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermagf (const float *__x, const float *__y) throw ()

     __attribute__ ((__pure__));


extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw ();


extern int setpayloadf (float *__x, float __payload) throw ();


extern int setpayloadsigf (float *__x, float __payload) throw ();







extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 308 "/usr/include/math.h" 2 3 4
# 349 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyl (long double __value) throw ()
     __attribute__ ((__const__));


extern int __signbitl (long double __value) throw ()
     __attribute__ ((__const__));



extern int __isinfl (long double __value) throw () __attribute__ ((__const__));


extern int __finitel (long double __value) throw () __attribute__ ((__const__));


extern int __isnanl (long double __value) throw () __attribute__ ((__const__));


extern int __iseqsigl (long double __x, long double __y) throw ();


extern int __issignalingl (long double __value) throw ()
     __attribute__ ((__const__));
# 350 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();

extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();

extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();

extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();


 extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();

 extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();

extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();




extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();

extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();

extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();



 extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ()
                                                        ;




extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();

extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();

extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();





 extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();


extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();


extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();


 extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();


extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();


extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();




extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();


extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();


extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();




extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();


extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();






 extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();


extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();



extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();




extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();






extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));


extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));


extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
# 177 "/usr/include/bits/mathcalls.h" 3 4
extern int isinfl (long double __value) throw () __attribute__ ((__const__));




extern int finitel (long double __value) throw () __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();



extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();






extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));




extern long double nanl (const char *__tagb) throw (); extern long double __nanl (const char *__tagb) throw ();
# 211 "/usr/include/bits/mathcalls.h" 3 4
extern int isnanl (long double __value) throw () __attribute__ ((__const__));





extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();





extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();




extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();





extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();







extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();






extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();


extern long double nextafterl (long double __x, long double __y) throw (); extern long double __nextafterl (long double __x, long double __y) throw ();

extern long double nexttowardl (long double __x, long double __y) throw (); extern long double __nexttowardl (long double __x, long double __y) throw ();




extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();

extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();



extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();



extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();



extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();




extern long int llogbl (long double __x) throw (); extern long int __llogbl (long double __x) throw ();




extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();



extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();



extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));



extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();






extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
__extension__
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();



extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
__extension__
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();



extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();


extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));


extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));


extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();




extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) throw ()
                               ;


extern long double fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__));


extern long double fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__));


extern int canonicalizel (long double *__cx, const long double *__x) throw ();




extern int totalorderl (const long double *__x, const long double *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermagl (const long double *__x, const long double *__y) throw ()

     __attribute__ ((__pure__));


extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw ();


extern int setpayloadl (long double *__x, long double __payload) throw ();


extern int setpayloadsigl (long double *__x, long double __payload) throw ();







extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 351 "/usr/include/math.h" 2 3 4
# 389 "/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) throw (); extern _Float32 __acosf32 (_Float32 __x) throw ();

extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw ();

extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw ();

extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw ();


 extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw ();

 extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw ();

extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw ();




extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw ();

extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw ();

extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw ();



 extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw (); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw ()
                                                        ;




extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw ();

extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw ();

extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw ();





 extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw ();


extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw ();


extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw ();


 extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw ();


extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw ();


extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) throw (); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw ();




extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw ();


extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw ();


extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw ();




extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw ();


extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw ();






 extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw ();


extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw ();



extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) throw ();




extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw ();






extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__));


extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__));


extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__));


extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw ();
# 196 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));




extern _Float32 nanf32 (const char *__tagb) throw (); extern _Float32 __nanf32 (const char *__tagb) throw ();
# 217 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 j0f32 (_Float32) throw (); extern _Float32 __j0f32 (_Float32) throw ();
extern _Float32 j1f32 (_Float32) throw (); extern _Float32 __j1f32 (_Float32) throw ();
extern _Float32 jnf32 (int, _Float32) throw (); extern _Float32 __jnf32 (int, _Float32) throw ();
extern _Float32 y0f32 (_Float32) throw (); extern _Float32 __y0f32 (_Float32) throw ();
extern _Float32 y1f32 (_Float32) throw (); extern _Float32 __y1f32 (_Float32) throw ();
extern _Float32 ynf32 (int, _Float32) throw (); extern _Float32 __ynf32 (int, _Float32) throw ();





extern _Float32 erff32 (_Float32) throw (); extern _Float32 __erff32 (_Float32) throw ();
extern _Float32 erfcf32 (_Float32) throw (); extern _Float32 __erfcf32 (_Float32) throw ();
extern _Float32 lgammaf32 (_Float32) throw (); extern _Float32 __lgammaf32 (_Float32) throw ();




extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw ();
# 249 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) throw ();






extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw ();


extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) throw ();






extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw ();

extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw ();



extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw ();



extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw ();



extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw ();




extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw ();




extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw ();



extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw ();



extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__));



extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__));




extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw ();






extern long int lrintf32 (_Float32 __x) throw (); extern long int __lrintf32 (_Float32 __x) throw ();
__extension__
extern long long int llrintf32 (_Float32 __x) throw (); extern long long int __llrintf32 (_Float32 __x) throw ();



extern long int lroundf32 (_Float32 __x) throw (); extern long int __lroundf32 (_Float32 __x) throw ();
__extension__
extern long long int llroundf32 (_Float32 __x) throw (); extern long long int __llroundf32 (_Float32 __x) throw ();



extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw ();


extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));


extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));


extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw ();




extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
                               ;


extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));


extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));


extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw ();




extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) throw ()

     __attribute__ ((__pure__));


extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw ();


extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw ();


extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) throw ();
# 390 "/usr/include/math.h" 2 3 4
# 406 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 acosf64 (_Float64 __x) throw (); extern _Float64 __acosf64 (_Float64 __x) throw ();

extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw ();

extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw ();

extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw ();


 extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw ();

 extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw ();

extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw ();




extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw ();

extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw ();

extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw ();



 extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw (); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw ()
                                                        ;




extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw ();

extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw ();

extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw ();





 extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw ();


extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw ();


extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw ();


 extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw ();


extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw ();


extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) throw (); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw ();




extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw ();


extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw ();


extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw ();




extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw ();


extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw ();






 extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw ();


extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw ();



extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) throw ();




extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw ();






extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__));


extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__));


extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__));


extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw ();
# 196 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));




extern _Float64 nanf64 (const char *__tagb) throw (); extern _Float64 __nanf64 (const char *__tagb) throw ();
# 217 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 j0f64 (_Float64) throw (); extern _Float64 __j0f64 (_Float64) throw ();
extern _Float64 j1f64 (_Float64) throw (); extern _Float64 __j1f64 (_Float64) throw ();
extern _Float64 jnf64 (int, _Float64) throw (); extern _Float64 __jnf64 (int, _Float64) throw ();
extern _Float64 y0f64 (_Float64) throw (); extern _Float64 __y0f64 (_Float64) throw ();
extern _Float64 y1f64 (_Float64) throw (); extern _Float64 __y1f64 (_Float64) throw ();
extern _Float64 ynf64 (int, _Float64) throw (); extern _Float64 __ynf64 (int, _Float64) throw ();





extern _Float64 erff64 (_Float64) throw (); extern _Float64 __erff64 (_Float64) throw ();
extern _Float64 erfcf64 (_Float64) throw (); extern _Float64 __erfcf64 (_Float64) throw ();
extern _Float64 lgammaf64 (_Float64) throw (); extern _Float64 __lgammaf64 (_Float64) throw ();




extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw ();
# 249 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) throw ();






extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw ();


extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) throw ();






extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw ();

extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw ();



extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw ();



extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw ();



extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw ();




extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw ();




extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw ();



extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw ();



extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__));



extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__));




extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw ();






extern long int lrintf64 (_Float64 __x) throw (); extern long int __lrintf64 (_Float64 __x) throw ();
__extension__
extern long long int llrintf64 (_Float64 __x) throw (); extern long long int __llrintf64 (_Float64 __x) throw ();



extern long int lroundf64 (_Float64 __x) throw (); extern long int __lroundf64 (_Float64 __x) throw ();
__extension__
extern long long int llroundf64 (_Float64 __x) throw (); extern long long int __llroundf64 (_Float64 __x) throw ();



extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw ();


extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));


extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));


extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw ();




extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
                               ;


extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));


extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));


extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw ();




extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) throw ()

     __attribute__ ((__pure__));


extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw ();


extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw ();


extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw ();
# 407 "/usr/include/math.h" 2 3 4
# 420 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyf128 (_Float128 __value) throw ()
     __attribute__ ((__const__));


extern int __signbitf128 (_Float128 __value) throw ()
     __attribute__ ((__const__));



extern int __isinff128 (_Float128 __value) throw () __attribute__ ((__const__));


extern int __finitef128 (_Float128 __value) throw () __attribute__ ((__const__));


extern int __isnanf128 (_Float128 __value) throw () __attribute__ ((__const__));


extern int __iseqsigf128 (_Float128 __x, _Float128 __y) throw ();


extern int __issignalingf128 (_Float128 __value) throw ()
     __attribute__ ((__const__));
# 421 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern _Float128 acosf128 (_Float128 __x) throw (); extern _Float128 __acosf128 (_Float128 __x) throw ();

extern _Float128 asinf128 (_Float128 __x) throw (); extern _Float128 __asinf128 (_Float128 __x) throw ();

extern _Float128 atanf128 (_Float128 __x) throw (); extern _Float128 __atanf128 (_Float128 __x) throw ();

extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) throw (); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) throw ();


 extern _Float128 cosf128 (_Float128 __x) throw (); extern _Float128 __cosf128 (_Float128 __x) throw ();

 extern _Float128 sinf128 (_Float128 __x) throw (); extern _Float128 __sinf128 (_Float128 __x) throw ();

extern _Float128 tanf128 (_Float128 __x) throw (); extern _Float128 __tanf128 (_Float128 __x) throw ();




extern _Float128 coshf128 (_Float128 __x) throw (); extern _Float128 __coshf128 (_Float128 __x) throw ();

extern _Float128 sinhf128 (_Float128 __x) throw (); extern _Float128 __sinhf128 (_Float128 __x) throw ();

extern _Float128 tanhf128 (_Float128 __x) throw (); extern _Float128 __tanhf128 (_Float128 __x) throw ();



 extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw (); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw ()
                                                        ;




extern _Float128 acoshf128 (_Float128 __x) throw (); extern _Float128 __acoshf128 (_Float128 __x) throw ();

extern _Float128 asinhf128 (_Float128 __x) throw (); extern _Float128 __asinhf128 (_Float128 __x) throw ();

extern _Float128 atanhf128 (_Float128 __x) throw (); extern _Float128 __atanhf128 (_Float128 __x) throw ();





 extern _Float128 expf128 (_Float128 __x) throw (); extern _Float128 __expf128 (_Float128 __x) throw ();


extern _Float128 frexpf128 (_Float128 __x, int *__exponent) throw (); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) throw ();


extern _Float128 ldexpf128 (_Float128 __x, int __exponent) throw (); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) throw ();


 extern _Float128 logf128 (_Float128 __x) throw (); extern _Float128 __logf128 (_Float128 __x) throw ();


extern _Float128 log10f128 (_Float128 __x) throw (); extern _Float128 __log10f128 (_Float128 __x) throw ();


extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) throw (); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern _Float128 exp10f128 (_Float128 __x) throw (); extern _Float128 __exp10f128 (_Float128 __x) throw ();




extern _Float128 expm1f128 (_Float128 __x) throw (); extern _Float128 __expm1f128 (_Float128 __x) throw ();


extern _Float128 log1pf128 (_Float128 __x) throw (); extern _Float128 __log1pf128 (_Float128 __x) throw ();


extern _Float128 logbf128 (_Float128 __x) throw (); extern _Float128 __logbf128 (_Float128 __x) throw ();




extern _Float128 exp2f128 (_Float128 __x) throw (); extern _Float128 __exp2f128 (_Float128 __x) throw ();


extern _Float128 log2f128 (_Float128 __x) throw (); extern _Float128 __log2f128 (_Float128 __x) throw ();






 extern _Float128 powf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float128 sqrtf128 (_Float128 __x) throw (); extern _Float128 __sqrtf128 (_Float128 __x) throw ();



extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) throw ();




extern _Float128 cbrtf128 (_Float128 __x) throw (); extern _Float128 __cbrtf128 (_Float128 __x) throw ();






extern _Float128 ceilf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) throw () __attribute__ ((__const__));


extern _Float128 fabsf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) throw () __attribute__ ((__const__));


extern _Float128 floorf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) throw () __attribute__ ((__const__));


extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) throw ();
# 196 "/usr/include/bits/mathcalls.h" 3 4
extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));




extern _Float128 nanf128 (const char *__tagb) throw (); extern _Float128 __nanf128 (const char *__tagb) throw ();
# 217 "/usr/include/bits/mathcalls.h" 3 4
extern _Float128 j0f128 (_Float128) throw (); extern _Float128 __j0f128 (_Float128) throw ();
extern _Float128 j1f128 (_Float128) throw (); extern _Float128 __j1f128 (_Float128) throw ();
extern _Float128 jnf128 (int, _Float128) throw (); extern _Float128 __jnf128 (int, _Float128) throw ();
extern _Float128 y0f128 (_Float128) throw (); extern _Float128 __y0f128 (_Float128) throw ();
extern _Float128 y1f128 (_Float128) throw (); extern _Float128 __y1f128 (_Float128) throw ();
extern _Float128 ynf128 (int, _Float128) throw (); extern _Float128 __ynf128 (int, _Float128) throw ();





extern _Float128 erff128 (_Float128) throw (); extern _Float128 __erff128 (_Float128) throw ();
extern _Float128 erfcf128 (_Float128) throw (); extern _Float128 __erfcf128 (_Float128) throw ();
extern _Float128 lgammaf128 (_Float128) throw (); extern _Float128 __lgammaf128 (_Float128) throw ();




extern _Float128 tgammaf128 (_Float128) throw (); extern _Float128 __tgammaf128 (_Float128) throw ();
# 249 "/usr/include/bits/mathcalls.h" 3 4
extern _Float128 lgammaf128_r (_Float128, int *__signgamp) throw (); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) throw ();






extern _Float128 rintf128 (_Float128 __x) throw (); extern _Float128 __rintf128 (_Float128 __x) throw ();


extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) throw ();






extern _Float128 nextdownf128 (_Float128 __x) throw (); extern _Float128 __nextdownf128 (_Float128 __x) throw ();

extern _Float128 nextupf128 (_Float128 __x) throw (); extern _Float128 __nextupf128 (_Float128 __x) throw ();



extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) throw ();



extern _Float128 scalbnf128 (_Float128 __x, int __n) throw (); extern _Float128 __scalbnf128 (_Float128 __x, int __n) throw ();



extern int ilogbf128 (_Float128 __x) throw (); extern int __ilogbf128 (_Float128 __x) throw ();




extern long int llogbf128 (_Float128 __x) throw (); extern long int __llogbf128 (_Float128 __x) throw ();




extern _Float128 scalblnf128 (_Float128 __x, long int __n) throw (); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) throw ();



extern _Float128 nearbyintf128 (_Float128 __x) throw (); extern _Float128 __nearbyintf128 (_Float128 __x) throw ();



extern _Float128 roundf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) throw () __attribute__ ((__const__));



extern _Float128 truncf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) throw () __attribute__ ((__const__));




extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw (); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw ();






extern long int lrintf128 (_Float128 __x) throw (); extern long int __lrintf128 (_Float128 __x) throw ();
__extension__
extern long long int llrintf128 (_Float128 __x) throw (); extern long long int __llrintf128 (_Float128 __x) throw ();



extern long int lroundf128 (_Float128 __x) throw (); extern long int __lroundf128 (_Float128 __x) throw ();
__extension__
extern long long int llroundf128 (_Float128 __x) throw (); extern long long int __llroundf128 (_Float128 __x) throw ();



extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));


extern _Float128 fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));


extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw (); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw ();




extern _Float128 roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
                               ;


extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));


extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));


extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) throw ();




extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) throw ()

     __attribute__ ((__pure__));


extern _Float128 getpayloadf128 (const _Float128 *__x) throw (); extern _Float128 __getpayloadf128 (const _Float128 *__x) throw ();


extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) throw ();


extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) throw ();
# 424 "/usr/include/math.h" 2 3 4
# 440 "/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) throw (); extern _Float32x __acosf32x (_Float32x __x) throw ();

extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw ();

extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw ();

extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw ();


 extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw ();

 extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw ();

extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw ();




extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw ();

extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw ();

extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw ();



 extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw (); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw ()
                                                        ;




extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw ();

extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw ();

extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw ();





 extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw ();


extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw ();


extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw ();


 extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw ();


extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw ();


extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) throw (); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw ();




extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw ();


extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw ();


extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw ();




extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw ();


extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw ();






 extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw ();


extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw ();



extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) throw ();




extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw ();






extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__));


extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__));


extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__));


extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw ();
# 196 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));




extern _Float32x nanf32x (const char *__tagb) throw (); extern _Float32x __nanf32x (const char *__tagb) throw ();
# 217 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x j0f32x (_Float32x) throw (); extern _Float32x __j0f32x (_Float32x) throw ();
extern _Float32x j1f32x (_Float32x) throw (); extern _Float32x __j1f32x (_Float32x) throw ();
extern _Float32x jnf32x (int, _Float32x) throw (); extern _Float32x __jnf32x (int, _Float32x) throw ();
extern _Float32x y0f32x (_Float32x) throw (); extern _Float32x __y0f32x (_Float32x) throw ();
extern _Float32x y1f32x (_Float32x) throw (); extern _Float32x __y1f32x (_Float32x) throw ();
extern _Float32x ynf32x (int, _Float32x) throw (); extern _Float32x __ynf32x (int, _Float32x) throw ();





extern _Float32x erff32x (_Float32x) throw (); extern _Float32x __erff32x (_Float32x) throw ();
extern _Float32x erfcf32x (_Float32x) throw (); extern _Float32x __erfcf32x (_Float32x) throw ();
extern _Float32x lgammaf32x (_Float32x) throw (); extern _Float32x __lgammaf32x (_Float32x) throw ();




extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw ();
# 249 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) throw ();






extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw ();


extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) throw ();






extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw ();

extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw ();



extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw ();



extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw ();



extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw ();




extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw ();




extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw ();



extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw ();



extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__));



extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__));




extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw ();






extern long int lrintf32x (_Float32x __x) throw (); extern long int __lrintf32x (_Float32x __x) throw ();
__extension__
extern long long int llrintf32x (_Float32x __x) throw (); extern long long int __llrintf32x (_Float32x __x) throw ();



extern long int lroundf32x (_Float32x __x) throw (); extern long int __lroundf32x (_Float32x __x) throw ();
__extension__
extern long long int llroundf32x (_Float32x __x) throw (); extern long long int __llroundf32x (_Float32x __x) throw ();



extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw ();


extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));


extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));


extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw ();




extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
                               ;


extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));


extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));


extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw ();




extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) throw ()

     __attribute__ ((__pure__));


extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw ();


extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw ();


extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) throw ();
# 441 "/usr/include/math.h" 2 3 4
# 457 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x acosf64x (_Float64x __x) throw (); extern _Float64x __acosf64x (_Float64x __x) throw ();

extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw ();

extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw ();

extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw ();


 extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw ();

 extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw ();

extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw ();




extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw ();

extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw ();

extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw ();



 extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw (); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw ()
                                                        ;




extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw ();

extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw ();

extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw ();





 extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw ();


extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw ();


extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw ();


 extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw ();


extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw ();


extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) throw (); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) throw () __attribute__ ((__nonnull__ (2)));



extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw ();




extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw ();


extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw ();


extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw ();




extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw ();


extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw ();






 extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw ();



extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) throw ();




extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw ();






extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__));


extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__));


extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__));


extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw ();
# 196 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));




extern _Float64x nanf64x (const char *__tagb) throw (); extern _Float64x __nanf64x (const char *__tagb) throw ();
# 217 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x j0f64x (_Float64x) throw (); extern _Float64x __j0f64x (_Float64x) throw ();
extern _Float64x j1f64x (_Float64x) throw (); extern _Float64x __j1f64x (_Float64x) throw ();
extern _Float64x jnf64x (int, _Float64x) throw (); extern _Float64x __jnf64x (int, _Float64x) throw ();
extern _Float64x y0f64x (_Float64x) throw (); extern _Float64x __y0f64x (_Float64x) throw ();
extern _Float64x y1f64x (_Float64x) throw (); extern _Float64x __y1f64x (_Float64x) throw ();
extern _Float64x ynf64x (int, _Float64x) throw (); extern _Float64x __ynf64x (int, _Float64x) throw ();





extern _Float64x erff64x (_Float64x) throw (); extern _Float64x __erff64x (_Float64x) throw ();
extern _Float64x erfcf64x (_Float64x) throw (); extern _Float64x __erfcf64x (_Float64x) throw ();
extern _Float64x lgammaf64x (_Float64x) throw (); extern _Float64x __lgammaf64x (_Float64x) throw ();




extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw ();
# 249 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) throw ();






extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw ();


extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) throw ();






extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw ();

extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw ();



extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw ();



extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw ();



extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw ();




extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw ();




extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw ();



extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw ();



extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__));



extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__));




extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw ();






extern long int lrintf64x (_Float64x __x) throw (); extern long int __lrintf64x (_Float64x __x) throw ();
__extension__
extern long long int llrintf64x (_Float64x __x) throw (); extern long long int __llrintf64x (_Float64x __x) throw ();



extern long int lroundf64x (_Float64x __x) throw (); extern long int __lroundf64x (_Float64x __x) throw ();
__extension__
extern long long int llroundf64x (_Float64x __x) throw (); extern long long int __llroundf64x (_Float64x __x) throw ();



extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));


extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));


extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw ();




extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__));



extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
                            ;



extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
                              ;




extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
                             ;




extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
                               ;


extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));


extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));


extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw ();




extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) throw ()

     __attribute__ ((__pure__));


extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) throw ()

     __attribute__ ((__pure__));


extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw ();


extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw ();


extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw ();
# 458 "/usr/include/math.h" 2 3 4
# 503 "/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) throw ();


extern float fdiv (double __x, double __y) throw ();


extern float fmul (double __x, double __y) throw ();


extern float fsub (double __x, double __y) throw ();
# 504 "/usr/include/math.h" 2 3 4
# 517 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern float faddl (long double __x, long double __y) throw ();


extern float fdivl (long double __x, long double __y) throw ();


extern float fmull (long double __x, long double __y) throw ();


extern float fsubl (long double __x, long double __y) throw ();
# 518 "/usr/include/math.h" 2 3 4
# 537 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern double daddl (long double __x, long double __y) throw ();


extern double ddivl (long double __x, long double __y) throw ();


extern double dmull (long double __x, long double __y) throw ();


extern double dsubl (long double __x, long double __y) throw ();
# 538 "/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 _Float32 f32addf32x (_Float32x __x, _Float32x __y) throw ();


extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) throw ();


extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) throw ();


extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) throw ();
# 617 "/usr/include/math.h" 2 3 4
# 626 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) throw ();


extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) throw ();


extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) throw ();


extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) throw ();
# 627 "/usr/include/math.h" 2 3 4
# 636 "/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) throw ();


extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) throw ();
# 637 "/usr/include/math.h" 2 3 4
# 646 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) throw ();
# 647 "/usr/include/math.h" 2 3 4
# 666 "/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) throw ();


extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) throw ();


extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) throw ();


extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) throw ();
# 667 "/usr/include/math.h" 2 3 4
# 676 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) throw ();
# 677 "/usr/include/math.h" 2 3 4
# 686 "/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 f32xaddf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) throw ();
# 687 "/usr/include/math.h" 2 3 4
# 706 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) throw ();


extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) throw ();
# 707 "/usr/include/math.h" 2 3 4
# 716 "/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 f64addf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) throw ();
# 717 "/usr/include/math.h" 2 3 4
# 736 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) throw ();


extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) throw ();
# 737 "/usr/include/math.h" 2 3 4
# 773 "/usr/include/math.h" 3 4
extern int signgam;
# 853 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN =

      0,
    FP_INFINITE =

      1,
    FP_ZERO =

      2,
    FP_SUBNORMAL =

      3,
    FP_NORMAL =

      4
  };
# 973 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/iscanonical.h" 1 3 4
# 23 "/usr/include/bits/iscanonical.h" 3 4
extern int __iscanonicall (long double __x)
     throw () __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); }

inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); }

}
# 974 "/usr/include/math.h" 2 3 4
# 985 "/usr/include/math.h" 3 4
extern "C++" {
inline int issignaling (float __val) { return __issignalingf (__val); }
inline int issignaling (double __val) { return __issignaling (__val); }
inline int
issignaling (long double __val)
{



  return __issignalingl (__val);

}



inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }

}
# 1016 "/usr/include/math.h" 3 4
extern "C++" {
# 1047 "/usr/include/math.h" 3 4
template <class __T> inline bool
iszero (__T __val)
{
  return __val == 0;
}

}
# 1245 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathinline.h" 1 3 4
# 1246 "/usr/include/math.h" 2 3 4
# 1278 "/usr/include/math.h" 3 4
extern "C++" {
template<typename> struct __iseqsig_type;

template<> struct __iseqsig_type<float>
{
  static int __call (float __x, float __y) throw ()
  {
    return __iseqsigf (__x, __y);
  }
};

template<> struct __iseqsig_type<double>
{
  static int __call (double __x, double __y) throw ()
  {
    return __iseqsig (__x, __y);
  }
};

template<> struct __iseqsig_type<long double>
{
  static int __call (long double __x, long double __y) throw ()
  {

    return __iseqsigl (__x, __y);



  }
};




template<> struct __iseqsig_type<_Float128>
{
  static int __call (_Float128 __x, _Float128 __y) throw ()
  {
    return __iseqsigf128 (__x, __y);
  }
};


template<typename _T1, typename _T2>
inline int
iseqsig (_T1 __x, _T2 __y) throw ()
{

  typedef decltype (((__x) + (__y) + 0.0f)) _T3;



  return __iseqsig_type<_T3>::__call (__x, __y);
}

}




}
# 46 "/usr/include/c++/10/cmath" 2 3
# 77 "/usr/include/c++/10/cmath" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::acos;


  inline constexpr float
  acos(float __x)
  { return __builtin_acosf(__x); }

  inline constexpr long double
  acos(long double __x)
  { return __builtin_acosl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    acos(_Tp __x)
    { return __builtin_acos(__x); }

  using ::asin;


  inline constexpr float
  asin(float __x)
  { return __builtin_asinf(__x); }

  inline constexpr long double
  asin(long double __x)
  { return __builtin_asinl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    asin(_Tp __x)
    { return __builtin_asin(__x); }

  using ::atan;


  inline constexpr float
  atan(float __x)
  { return __builtin_atanf(__x); }

  inline constexpr long double
  atan(long double __x)
  { return __builtin_atanl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    atan(_Tp __x)
    { return __builtin_atan(__x); }

  using ::atan2;


  inline constexpr float
  atan2(float __y, float __x)
  { return __builtin_atan2f(__y, __x); }

  inline constexpr long double
  atan2(long double __y, long double __x)
  { return __builtin_atan2l(__y, __x); }


  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    atan2(_Tp __y, _Up __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return atan2(__type(__y), __type(__x));
    }

  using ::ceil;


  inline constexpr float
  ceil(float __x)
  { return __builtin_ceilf(__x); }

  inline constexpr long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ceil(_Tp __x)
    { return __builtin_ceil(__x); }

  using ::cos;


  inline constexpr float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline constexpr long double
  cos(long double __x)
  { return __builtin_cosl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cos(_Tp __x)
    { return __builtin_cos(__x); }

  using ::cosh;


  inline constexpr float
  cosh(float __x)
  { return __builtin_coshf(__x); }

  inline constexpr long double
  cosh(long double __x)
  { return __builtin_coshl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cosh(_Tp __x)
    { return __builtin_cosh(__x); }

  using ::exp;


  inline constexpr float
  exp(float __x)
  { return __builtin_expf(__x); }

  inline constexpr long double
  exp(long double __x)
  { return __builtin_expl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    exp(_Tp __x)
    { return __builtin_exp(__x); }

  using ::fabs;


  inline constexpr float
  fabs(float __x)
  { return __builtin_fabsf(__x); }

  inline constexpr long double
  fabs(long double __x)
  { return __builtin_fabsl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    fabs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::floor;


  inline constexpr float
  floor(float __x)
  { return __builtin_floorf(__x); }

  inline constexpr long double
  floor(long double __x)
  { return __builtin_floorl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    floor(_Tp __x)
    { return __builtin_floor(__x); }

  using ::fmod;


  inline constexpr float
  fmod(float __x, float __y)
  { return __builtin_fmodf(__x, __y); }

  inline constexpr long double
  fmod(long double __x, long double __y)
  { return __builtin_fmodl(__x, __y); }


  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmod(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmod(__type(__x), __type(__y));
    }

  using ::frexp;


  inline float
  frexp(float __x, int* __exp)
  { return __builtin_frexpf(__x, __exp); }

  inline long double
  frexp(long double __x, int* __exp)
  { return __builtin_frexpl(__x, __exp); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    frexp(_Tp __x, int* __exp)
    { return __builtin_frexp(__x, __exp); }

  using ::ldexp;


  inline constexpr float
  ldexp(float __x, int __exp)
  { return __builtin_ldexpf(__x, __exp); }

  inline constexpr long double
  ldexp(long double __x, int __exp)
  { return __builtin_ldexpl(__x, __exp); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ldexp(_Tp __x, int __exp)
    { return __builtin_ldexp(__x, __exp); }

  using ::log;


  inline constexpr float
  log(float __x)
  { return __builtin_logf(__x); }

  inline constexpr long double
  log(long double __x)
  { return __builtin_logl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    log(_Tp __x)
    { return __builtin_log(__x); }

  using ::log10;


  inline constexpr float
  log10(float __x)
  { return __builtin_log10f(__x); }

  inline constexpr long double
  log10(long double __x)
  { return __builtin_log10l(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    log10(_Tp __x)
    { return __builtin_log10(__x); }

  using ::modf;


  inline float
  modf(float __x, float* __iptr)
  { return __builtin_modff(__x, __iptr); }

  inline long double
  modf(long double __x, long double* __iptr)
  { return __builtin_modfl(__x, __iptr); }


  using ::pow;


  inline constexpr float
  pow(float __x, float __y)
  { return __builtin_powf(__x, __y); }

  inline constexpr long double
  pow(long double __x, long double __y)
  { return __builtin_powl(__x, __y); }
# 412 "/usr/include/c++/10/cmath" 3
  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    pow(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return pow(__type(__x), __type(__y));
    }

  using ::sin;


  inline constexpr float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline constexpr long double
  sin(long double __x)
  { return __builtin_sinl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sin(_Tp __x)
    { return __builtin_sin(__x); }

  using ::sinh;


  inline constexpr float
  sinh(float __x)
  { return __builtin_sinhf(__x); }

  inline constexpr long double
  sinh(long double __x)
  { return __builtin_sinhl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sinh(_Tp __x)
    { return __builtin_sinh(__x); }

  using ::sqrt;


  inline constexpr float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline constexpr long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sqrt(_Tp __x)
    { return __builtin_sqrt(__x); }

  using ::tan;


  inline constexpr float
  tan(float __x)
  { return __builtin_tanf(__x); }

  inline constexpr long double
  tan(long double __x)
  { return __builtin_tanl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tan(_Tp __x)
    { return __builtin_tan(__x); }

  using ::tanh;


  inline constexpr float
  tanh(float __x)
  { return __builtin_tanhf(__x); }

  inline constexpr long double
  tanh(long double __x)
  { return __builtin_tanhl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tanh(_Tp __x)
    { return __builtin_tanh(__x); }
# 536 "/usr/include/c++/10/cmath" 3
  constexpr int
  fpclassify(float __x)
  { return __builtin_fpclassify(0, 1, 4,
    3, 2, __x); }

  constexpr int
  fpclassify(double __x)
  { return __builtin_fpclassify(0, 1, 4,
    3, 2, __x); }

  constexpr int
  fpclassify(long double __x)
  { return __builtin_fpclassify(0, 1, 4,
    3, 2, __x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              int>::__type
    fpclassify(_Tp __x)
    { return __x != 0 ? 4 : 2; }



  constexpr bool
  isfinite(float __x)
  { return __builtin_isfinite(__x); }

  constexpr bool
  isfinite(double __x)
  { return __builtin_isfinite(__x); }

  constexpr bool
  isfinite(long double __x)
  { return __builtin_isfinite(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isfinite(_Tp __x)
    { return true; }



  constexpr bool
  isinf(float __x)
  { return __builtin_isinf(__x); }





  constexpr bool
  isinf(double __x)
  { return __builtin_isinf(__x); }


  constexpr bool
  isinf(long double __x)
  { return __builtin_isinf(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isinf(_Tp __x)
    { return false; }



  constexpr bool
  isnan(float __x)
  { return __builtin_isnan(__x); }





  constexpr bool
  isnan(double __x)
  { return __builtin_isnan(__x); }


  constexpr bool
  isnan(long double __x)
  { return __builtin_isnan(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isnan(_Tp __x)
    { return false; }



  constexpr bool
  isnormal(float __x)
  { return __builtin_isnormal(__x); }

  constexpr bool
  isnormal(double __x)
  { return __builtin_isnormal(__x); }

  constexpr bool
  isnormal(long double __x)
  { return __builtin_isnormal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isnormal(_Tp __x)
    { return __x != 0 ? true : false; }




  constexpr bool
  signbit(float __x)
  { return __builtin_signbit(__x); }

  constexpr bool
  signbit(double __x)
  { return __builtin_signbit(__x); }

  constexpr bool
  signbit(long double __x)
  { return __builtin_signbit(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    signbit(_Tp __x)
    { return __x < 0 ? true : false; }



  constexpr bool
  isgreater(float __x, float __y)
  { return __builtin_isgreater(__x, __y); }

  constexpr bool
  isgreater(double __x, double __y)
  { return __builtin_isgreater(__x, __y); }

  constexpr bool
  isgreater(long double __x, long double __y)
  { return __builtin_isgreater(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isgreater(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isgreater(__type(__x), __type(__y));
    }



  constexpr bool
  isgreaterequal(float __x, float __y)
  { return __builtin_isgreaterequal(__x, __y); }

  constexpr bool
  isgreaterequal(double __x, double __y)
  { return __builtin_isgreaterequal(__x, __y); }

  constexpr bool
  isgreaterequal(long double __x, long double __y)
  { return __builtin_isgreaterequal(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isgreaterequal(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isgreaterequal(__type(__x), __type(__y));
    }



  constexpr bool
  isless(float __x, float __y)
  { return __builtin_isless(__x, __y); }

  constexpr bool
  isless(double __x, double __y)
  { return __builtin_isless(__x, __y); }

  constexpr bool
  isless(long double __x, long double __y)
  { return __builtin_isless(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isless(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isless(__type(__x), __type(__y));
    }



  constexpr bool
  islessequal(float __x, float __y)
  { return __builtin_islessequal(__x, __y); }

  constexpr bool
  islessequal(double __x, double __y)
  { return __builtin_islessequal(__x, __y); }

  constexpr bool
  islessequal(long double __x, long double __y)
  { return __builtin_islessequal(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    islessequal(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_islessequal(__type(__x), __type(__y));
    }



  constexpr bool
  islessgreater(float __x, float __y)
  { return __builtin_islessgreater(__x, __y); }

  constexpr bool
  islessgreater(double __x, double __y)
  { return __builtin_islessgreater(__x, __y); }

  constexpr bool
  islessgreater(long double __x, long double __y)
  { return __builtin_islessgreater(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    islessgreater(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_islessgreater(__type(__x), __type(__y));
    }



  constexpr bool
  isunordered(float __x, float __y)
  { return __builtin_isunordered(__x, __y); }

  constexpr bool
  isunordered(double __x, double __y)
  { return __builtin_isunordered(__x, __y); }

  constexpr bool
  isunordered(long double __x, long double __y)
  { return __builtin_isunordered(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isunordered(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isunordered(__type(__x), __type(__y));
    }
# 1065 "/usr/include/c++/10/cmath" 3
  using ::double_t;
  using ::float_t;


  using ::acosh;
  using ::acoshf;
  using ::acoshl;

  using ::asinh;
  using ::asinhf;
  using ::asinhl;

  using ::atanh;
  using ::atanhf;
  using ::atanhl;

  using ::cbrt;
  using ::cbrtf;
  using ::cbrtl;

  using ::copysign;
  using ::copysignf;
  using ::copysignl;

  using ::erf;
  using ::erff;
  using ::erfl;

  using ::erfc;
  using ::erfcf;
  using ::erfcl;

  using ::exp2;
  using ::exp2f;
  using ::exp2l;

  using ::expm1;
  using ::expm1f;
  using ::expm1l;

  using ::fdim;
  using ::fdimf;
  using ::fdiml;

  using ::fma;
  using ::fmaf;
  using ::fmal;

  using ::fmax;
  using ::fmaxf;
  using ::fmaxl;

  using ::fmin;
  using ::fminf;
  using ::fminl;

  using ::hypot;
  using ::hypotf;
  using ::hypotl;

  using ::ilogb;
  using ::ilogbf;
  using ::ilogbl;

  using ::lgamma;
  using ::lgammaf;
  using ::lgammal;


  using ::llrint;
  using ::llrintf;
  using ::llrintl;

  using ::llround;
  using ::llroundf;
  using ::llroundl;


  using ::log1p;
  using ::log1pf;
  using ::log1pl;

  using ::log2;
  using ::log2f;
  using ::log2l;

  using ::logb;
  using ::logbf;
  using ::logbl;

  using ::lrint;
  using ::lrintf;
  using ::lrintl;

  using ::lround;
  using ::lroundf;
  using ::lroundl;

  using ::nan;
  using ::nanf;
  using ::nanl;

  using ::nearbyint;
  using ::nearbyintf;
  using ::nearbyintl;

  using ::nextafter;
  using ::nextafterf;
  using ::nextafterl;

  using ::nexttoward;
  using ::nexttowardf;
  using ::nexttowardl;

  using ::remainder;
  using ::remainderf;
  using ::remainderl;

  using ::remquo;
  using ::remquof;
  using ::remquol;

  using ::rint;
  using ::rintf;
  using ::rintl;

  using ::round;
  using ::roundf;
  using ::roundl;

  using ::scalbln;
  using ::scalblnf;
  using ::scalblnl;

  using ::scalbn;
  using ::scalbnf;
  using ::scalbnl;

  using ::tgamma;
  using ::tgammaf;
  using ::tgammal;

  using ::trunc;
  using ::truncf;
  using ::truncl;



  constexpr float
  acosh(float __x)
  { return __builtin_acoshf(__x); }

  constexpr long double
  acosh(long double __x)
  { return __builtin_acoshl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    acosh(_Tp __x)
    { return __builtin_acosh(__x); }



  constexpr float
  asinh(float __x)
  { return __builtin_asinhf(__x); }

  constexpr long double
  asinh(long double __x)
  { return __builtin_asinhl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    asinh(_Tp __x)
    { return __builtin_asinh(__x); }



  constexpr float
  atanh(float __x)
  { return __builtin_atanhf(__x); }

  constexpr long double
  atanh(long double __x)
  { return __builtin_atanhl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    atanh(_Tp __x)
    { return __builtin_atanh(__x); }



  constexpr float
  cbrt(float __x)
  { return __builtin_cbrtf(__x); }

  constexpr long double
  cbrt(long double __x)
  { return __builtin_cbrtl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    cbrt(_Tp __x)
    { return __builtin_cbrt(__x); }



  constexpr float
  copysign(float __x, float __y)
  { return __builtin_copysignf(__x, __y); }

  constexpr long double
  copysign(long double __x, long double __y)
  { return __builtin_copysignl(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    copysign(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return copysign(__type(__x), __type(__y));
    }



  constexpr float
  erf(float __x)
  { return __builtin_erff(__x); }

  constexpr long double
  erf(long double __x)
  { return __builtin_erfl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    erf(_Tp __x)
    { return __builtin_erf(__x); }



  constexpr float
  erfc(float __x)
  { return __builtin_erfcf(__x); }

  constexpr long double
  erfc(long double __x)
  { return __builtin_erfcl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    erfc(_Tp __x)
    { return __builtin_erfc(__x); }



  constexpr float
  exp2(float __x)
  { return __builtin_exp2f(__x); }

  constexpr long double
  exp2(long double __x)
  { return __builtin_exp2l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    exp2(_Tp __x)
    { return __builtin_exp2(__x); }



  constexpr float
  expm1(float __x)
  { return __builtin_expm1f(__x); }

  constexpr long double
  expm1(long double __x)
  { return __builtin_expm1l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    expm1(_Tp __x)
    { return __builtin_expm1(__x); }



  constexpr float
  fdim(float __x, float __y)
  { return __builtin_fdimf(__x, __y); }

  constexpr long double
  fdim(long double __x, long double __y)
  { return __builtin_fdiml(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fdim(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fdim(__type(__x), __type(__y));
    }



  constexpr float
  fma(float __x, float __y, float __z)
  { return __builtin_fmaf(__x, __y, __z); }

  constexpr long double
  fma(long double __x, long double __y, long double __z)
  { return __builtin_fmal(__x, __y, __z); }



  template<typename _Tp, typename _Up, typename _Vp>
    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
    fma(_Tp __x, _Up __y, _Vp __z)
    {
      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
      return fma(__type(__x), __type(__y), __type(__z));
    }



  constexpr float
  fmax(float __x, float __y)
  { return __builtin_fmaxf(__x, __y); }

  constexpr long double
  fmax(long double __x, long double __y)
  { return __builtin_fmaxl(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmax(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmax(__type(__x), __type(__y));
    }



  constexpr float
  fmin(float __x, float __y)
  { return __builtin_fminf(__x, __y); }

  constexpr long double
  fmin(long double __x, long double __y)
  { return __builtin_fminl(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmin(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmin(__type(__x), __type(__y));
    }



  constexpr float
  hypot(float __x, float __y)
  { return __builtin_hypotf(__x, __y); }

  constexpr long double
  hypot(long double __x, long double __y)
  { return __builtin_hypotl(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    hypot(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return hypot(__type(__x), __type(__y));
    }



  constexpr int
  ilogb(float __x)
  { return __builtin_ilogbf(__x); }

  constexpr int
  ilogb(long double __x)
  { return __builtin_ilogbl(__x); }



  template<typename _Tp>
    constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    int>::__type
    ilogb(_Tp __x)
    { return __builtin_ilogb(__x); }



  constexpr float
  lgamma(float __x)
  { return __builtin_lgammaf(__x); }

  constexpr long double
  lgamma(long double __x)
  { return __builtin_lgammal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    lgamma(_Tp __x)
    { return __builtin_lgamma(__x); }



  constexpr long long
  llrint(float __x)
  { return __builtin_llrintf(__x); }

  constexpr long long
  llrint(long double __x)
  { return __builtin_llrintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long long>::__type
    llrint(_Tp __x)
    { return __builtin_llrint(__x); }



  constexpr long long
  llround(float __x)
  { return __builtin_llroundf(__x); }

  constexpr long long
  llround(long double __x)
  { return __builtin_llroundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long long>::__type
    llround(_Tp __x)
    { return __builtin_llround(__x); }



  constexpr float
  log1p(float __x)
  { return __builtin_log1pf(__x); }

  constexpr long double
  log1p(long double __x)
  { return __builtin_log1pl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    log1p(_Tp __x)
    { return __builtin_log1p(__x); }




  constexpr float
  log2(float __x)
  { return __builtin_log2f(__x); }

  constexpr long double
  log2(long double __x)
  { return __builtin_log2l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    log2(_Tp __x)
    { return __builtin_log2(__x); }



  constexpr float
  logb(float __x)
  { return __builtin_logbf(__x); }

  constexpr long double
  logb(long double __x)
  { return __builtin_logbl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    logb(_Tp __x)
    { return __builtin_logb(__x); }



  constexpr long
  lrint(float __x)
  { return __builtin_lrintf(__x); }

  constexpr long
  lrint(long double __x)
  { return __builtin_lrintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long>::__type
    lrint(_Tp __x)
    { return __builtin_lrint(__x); }



  constexpr long
  lround(float __x)
  { return __builtin_lroundf(__x); }

  constexpr long
  lround(long double __x)
  { return __builtin_lroundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long>::__type
    lround(_Tp __x)
    { return __builtin_lround(__x); }



  constexpr float
  nearbyint(float __x)
  { return __builtin_nearbyintf(__x); }

  constexpr long double
  nearbyint(long double __x)
  { return __builtin_nearbyintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    nearbyint(_Tp __x)
    { return __builtin_nearbyint(__x); }



  constexpr float
  nextafter(float __x, float __y)
  { return __builtin_nextafterf(__x, __y); }

  constexpr long double
  nextafter(long double __x, long double __y)
  { return __builtin_nextafterl(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    nextafter(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return nextafter(__type(__x), __type(__y));
    }



  constexpr float
  nexttoward(float __x, long double __y)
  { return __builtin_nexttowardf(__x, __y); }

  constexpr long double
  nexttoward(long double __x, long double __y)
  { return __builtin_nexttowardl(__x, __y); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    nexttoward(_Tp __x, long double __y)
    { return __builtin_nexttoward(__x, __y); }



  constexpr float
  remainder(float __x, float __y)
  { return __builtin_remainderf(__x, __y); }

  constexpr long double
  remainder(long double __x, long double __y)
  { return __builtin_remainderl(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    remainder(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return remainder(__type(__x), __type(__y));
    }



  inline float
  remquo(float __x, float __y, int* __pquo)
  { return __builtin_remquof(__x, __y, __pquo); }

  inline long double
  remquo(long double __x, long double __y, int* __pquo)
  { return __builtin_remquol(__x, __y, __pquo); }



  template<typename _Tp, typename _Up>
    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    remquo(_Tp __x, _Up __y, int* __pquo)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return remquo(__type(__x), __type(__y), __pquo);
    }



  constexpr float
  rint(float __x)
  { return __builtin_rintf(__x); }

  constexpr long double
  rint(long double __x)
  { return __builtin_rintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    rint(_Tp __x)
    { return __builtin_rint(__x); }



  constexpr float
  round(float __x)
  { return __builtin_roundf(__x); }

  constexpr long double
  round(long double __x)
  { return __builtin_roundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    round(_Tp __x)
    { return __builtin_round(__x); }



  constexpr float
  scalbln(float __x, long __ex)
  { return __builtin_scalblnf(__x, __ex); }

  constexpr long double
  scalbln(long double __x, long __ex)
  { return __builtin_scalblnl(__x, __ex); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    scalbln(_Tp __x, long __ex)
    { return __builtin_scalbln(__x, __ex); }



  constexpr float
  scalbn(float __x, int __ex)
  { return __builtin_scalbnf(__x, __ex); }

  constexpr long double
  scalbn(long double __x, int __ex)
  { return __builtin_scalbnl(__x, __ex); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    scalbn(_Tp __x, int __ex)
    { return __builtin_scalbn(__x, __ex); }



  constexpr float
  tgamma(float __x)
  { return __builtin_tgammaf(__x); }

  constexpr long double
  tgamma(long double __x)
  { return __builtin_tgammal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    tgamma(_Tp __x)
    { return __builtin_tgamma(__x); }



  constexpr float
  trunc(float __x)
  { return __builtin_truncf(__x); }

  constexpr long double
  trunc(long double __x)
  { return __builtin_truncl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    trunc(_Tp __x)
    { return __builtin_trunc(__x); }
# 1852 "/usr/include/c++/10/cmath" 3
  template<typename _Tp>
    inline _Tp
    __hypot3(_Tp __x, _Tp __y, _Tp __z)
    {
      __x = std::abs(__x);
      __y = std::abs(__y);
      __z = std::abs(__z);
      if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
 return __a * std::sqrt((__x / __a) * (__x / __a)
          + (__y / __a) * (__y / __a)
          + (__z / __a) * (__z / __a));
      else
 return {};
    }

  inline float
  hypot(float __x, float __y, float __z)
  { return std::__hypot3<float>(__x, __y, __z); }

  inline double
  hypot(double __x, double __y, double __z)
  { return std::__hypot3<double>(__x, __y, __z); }

  inline long double
  hypot(long double __x, long double __y, long double __z)
  { return std::__hypot3<long double>(__x, __y, __z); }

  template<typename _Tp, typename _Up, typename _Vp>
    typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
    hypot(_Tp __x, _Up __y, _Vp __z)
    {
      using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;
      return std::__hypot3<__type>(__x, __y, __z);
    }
# 1923 "/usr/include/c++/10/cmath" 3

}


# 1 "/usr/include/c++/10/bits/specfun.h" 1 3
# 33 "/usr/include/c++/10/bits/specfun.h" 3
#pragma GCC visibility push(default)
# 49 "/usr/include/c++/10/bits/specfun.h" 3
# 1 "/usr/include/c++/10/tr1/gamma.tcc" 1 3
# 49 "/usr/include/c++/10/tr1/gamma.tcc" 3
# 1 "/usr/include/c++/10/tr1/special_function_util.h" 1 3
# 39 "/usr/include/c++/10/tr1/special_function_util.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 50 "/usr/include/c++/10/tr1/special_function_util.h" 3
  namespace __detail
  {



    template<typename _Tp>
    struct __floating_point_constant
    {
      static const _Tp __value;
    };



    template<typename _Tp>
      struct __numeric_constants
      {

        static _Tp __pi() throw()
        { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }

        static _Tp __pi_2() throw()
        { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }

        static _Tp __pi_3() throw()
        { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }

        static _Tp __pi_4() throw()
        { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }

        static _Tp __1_pi() throw()
        { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }

        static _Tp __2_sqrtpi() throw()
        { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }

        static _Tp __sqrt2() throw()
        { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }

        static _Tp __sqrt3() throw()
        { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }

        static _Tp __sqrtpio2() throw()
        { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }

        static _Tp __sqrt1_2() throw()
        { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }

        static _Tp __lnpi() throw()
        { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }

        static _Tp __gamma_e() throw()
        { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }

        static _Tp __euler() throw()
        { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
      };
# 114 "/usr/include/c++/10/tr1/special_function_util.h" 3
    template<typename _Tp>
    inline bool __isnan(_Tp __x)
    { return std::isnan(__x); }
# 133 "/usr/include/c++/10/tr1/special_function_util.h" 3
  }





}
# 50 "/usr/include/c++/10/tr1/gamma.tcc" 2 3

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

# 65 "/usr/include/c++/10/tr1/gamma.tcc" 3
  namespace __detail
  {
# 76 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template <typename _Tp>
    _Tp
    __bernoulli_series(unsigned int __n)
    {

      static const _Tp __num[28] = {
        _Tp(1UL), -_Tp(1UL) / _Tp(2UL),
        _Tp(1UL) / _Tp(6UL), _Tp(0UL),
        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
        _Tp(1UL) / _Tp(42UL), _Tp(0UL),
        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
        _Tp(5UL) / _Tp(66UL), _Tp(0UL),
        -_Tp(691UL) / _Tp(2730UL), _Tp(0UL),
        _Tp(7UL) / _Tp(6UL), _Tp(0UL),
        -_Tp(3617UL) / _Tp(510UL), _Tp(0UL),
        _Tp(43867UL) / _Tp(798UL), _Tp(0UL),
        -_Tp(174611) / _Tp(330UL), _Tp(0UL),
        _Tp(854513UL) / _Tp(138UL), _Tp(0UL),
        -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL),
        _Tp(8553103UL) / _Tp(6UL), _Tp(0UL)
      };

      if (__n == 0)
        return _Tp(1);

      if (__n == 1)
        return -_Tp(1) / _Tp(2);


      if (__n % 2 == 1)
        return _Tp(0);


      if (__n < 28)
        return __num[__n];


      _Tp __fact = _Tp(1);
      if ((__n / 2) % 2 == 0)
        __fact *= _Tp(-1);
      for (unsigned int __k = 1; __k <= __n; ++__k)
        __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi());
      __fact *= _Tp(2);

      _Tp __sum = _Tp(0);
      for (unsigned int __i = 1; __i < 1000; ++__i)
        {
          _Tp __term = std::pow(_Tp(__i), -_Tp(__n));
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term;
        }

      return __fact * __sum;
    }
# 139 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    inline _Tp
    __bernoulli(int __n)
    { return __bernoulli_series<_Tp>(__n); }
# 153 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma_bernoulli(_Tp __x)
    {
      _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x
               + _Tp(0.5L) * std::log(_Tp(2)
               * __numeric_constants<_Tp>::__pi());

      const _Tp __xx = __x * __x;
      _Tp __help = _Tp(1) / __x;
      for ( unsigned int __i = 1; __i < 20; ++__i )
        {
          const _Tp __2i = _Tp(2 * __i);
          __help /= __2i * (__2i - _Tp(1)) * __xx;
          __lg += __bernoulli<_Tp>(2 * __i) * __help;
        }

      return __lg;
    }
# 181 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma_lanczos(_Tp __x)
    {
      const _Tp __xm1 = __x - _Tp(1);

      static const _Tp __lanczos_cheb_7[9] = {
       _Tp( 0.99999999999980993227684700473478L),
       _Tp( 676.520368121885098567009190444019L),
       _Tp(-1259.13921672240287047156078755283L),
       _Tp( 771.3234287776530788486528258894L),
       _Tp(-176.61502916214059906584551354L),
       _Tp( 12.507343278686904814458936853L),
       _Tp(-0.13857109526572011689554707L),
       _Tp( 9.984369578019570859563e-6L),
       _Tp( 1.50563273514931155834e-7L)
      };

      static const _Tp __LOGROOT2PI
          = _Tp(0.9189385332046727417803297364056176L);

      _Tp __sum = __lanczos_cheb_7[0];
      for(unsigned int __k = 1; __k < 9; ++__k)
        __sum += __lanczos_cheb_7[__k] / (__xm1 + __k);

      const _Tp __term1 = (__xm1 + _Tp(0.5L))
                        * std::log((__xm1 + _Tp(7.5L))
                       / __numeric_constants<_Tp>::__euler());
      const _Tp __term2 = __LOGROOT2PI + std::log(__sum);
      const _Tp __result = __term1 + (__term2 - _Tp(7));

      return __result;
    }
# 225 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma(_Tp __x)
    {
      if (__x > _Tp(0.5L))
        return __log_gamma_lanczos(__x);
      else
        {
          const _Tp __sin_fact
                 = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x));
          if (__sin_fact == _Tp(0))
            std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma")
                                                           );
          return __numeric_constants<_Tp>::__lnpi()
                     - std::log(__sin_fact)
                     - __log_gamma_lanczos(_Tp(1) - __x);
        }
    }
# 252 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma_sign(_Tp __x)
    {
      if (__x > _Tp(0))
        return _Tp(1);
      else
        {
          const _Tp __sin_fact
                  = std::sin(__numeric_constants<_Tp>::__pi() * __x);
          if (__sin_fact > _Tp(0))
            return (1);
          else if (__sin_fact < _Tp(0))
            return -_Tp(1);
          else
            return _Tp(0);
        }
    }
# 283 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_bincoef(unsigned int __n, unsigned int __k)
    {

      static const _Tp __max_bincoeff
                      = std::numeric_limits<_Tp>::max_exponent10
                      * std::log(_Tp(10)) - _Tp(1);

      _Tp __coeff = ::std::lgamma(_Tp(1 + __n))
                  - ::std::lgamma(_Tp(1 + __k))
                  - ::std::lgamma(_Tp(1 + __n - __k));





    }
# 314 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __bincoef(unsigned int __n, unsigned int __k)
    {

      static const _Tp __max_bincoeff
                      = std::numeric_limits<_Tp>::max_exponent10
                      * std::log(_Tp(10)) - _Tp(1);

      const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k);
      if (__log_coeff > __max_bincoeff)
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return std::exp(__log_coeff);
    }
# 337 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    inline _Tp
    __gamma(_Tp __x)
    { return std::exp(__log_gamma(__x)); }
# 356 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi_series(_Tp __x)
    {
      _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x;
      const unsigned int __max_iter = 100000;
      for (unsigned int __k = 1; __k < __max_iter; ++__k)
        {
          const _Tp __term = __x / (__k * (__k + __x));
          __sum += __term;
          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
            break;
        }
      return __sum;
    }
# 386 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi_asymp(_Tp __x)
    {
      _Tp __sum = std::log(__x) - _Tp(0.5L) / __x;
      const _Tp __xx = __x * __x;
      _Tp __xp = __xx;
      const unsigned int __max_iter = 100;
      for (unsigned int __k = 1; __k < __max_iter; ++__k)
        {
          const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp);
          __sum -= __term;
          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
            break;
          __xp *= __xx;
        }
      return __sum;
    }
# 417 "/usr/include/c++/10/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi(_Tp __x)
    {
      const int __n = static_cast<int>(__x + 0.5L);
      const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon();
      if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps)
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x < _Tp(0))
        {
          const _Tp __pi = __numeric_constants<_Tp>::__pi();
          return __psi(_Tp(1) - __x)
               - __pi * std::cos(__pi * __x) / std::sin(__pi * __x);
        }
      else if (__x > _Tp(100))
        return __psi_asymp(__x);
      else
        return __psi_series(__x);
    }
# 446 "/usr/include/c++/10/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;
        }
    }
  }






}
# 50 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/bessel_function.tcc" 1 3
# 55 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 71 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
  namespace __detail
  {
# 98 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __gamma_temme(_Tp __mu,
                  _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
    {

      __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu);
      __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu);





      if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon())
        __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e());
      else
        __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu);

      __gam2 = (__gammi + __gampl) / (_Tp(2));

      return;
    }
# 136 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __bessel_jn(_Tp __nu, _Tp __x,
                _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu)
    {
      if (__x == _Tp(0))
        {
          if (__nu == _Tp(0))
            {
              __Jnu = _Tp(1);
              __Jpnu = _Tp(0);
            }
          else if (__nu == _Tp(1))
            {
              __Jnu = _Tp(0);
              __Jpnu = _Tp(0.5L);
            }
          else
            {
              __Jnu = _Tp(0);
              __Jpnu = _Tp(0);
            }
          __Nnu = -std::numeric_limits<_Tp>::infinity();
          __Npnu = std::numeric_limits<_Tp>::infinity();
          return;
        }

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();




      const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min());
      const int __max_iter = 15000;
      const _Tp __x_min = _Tp(2);

      const int __nl = (__x < __x_min
                    ? static_cast<int>(__nu + _Tp(0.5L))
                    : std::max(0, static_cast<int>(__nu - __x + _Tp(1.5L))));

      const _Tp __mu = __nu - __nl;
      const _Tp __mu2 = __mu * __mu;
      const _Tp __xi = _Tp(1) / __x;
      const _Tp __xi2 = _Tp(2) * __xi;
      _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi();
      int __isign = 1;
      _Tp __h = __nu * __xi;
      if (__h < __fp_min)
        __h = __fp_min;
      _Tp __b = __xi2 * __nu;
      _Tp __d = _Tp(0);
      _Tp __c = __h;
      int __i;
      for (__i = 1; __i <= __max_iter; ++__i)
        {
          __b += __xi2;
          __d = __b - __d;
          if (std::abs(__d) < __fp_min)
            __d = __fp_min;
          __c = __b - _Tp(1) / __c;
          if (std::abs(__c) < __fp_min)
            __c = __fp_min;
          __d = _Tp(1) / __d;
          const _Tp __del = __c * __d;
          __h *= __del;
          if (__d < _Tp(0))
            __isign = -__isign;
          if (std::abs(__del - _Tp(1)) < __eps)
            break;
        }
      if (__i > __max_iter)
        std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.")
                                                                   );
      _Tp __Jnul = __isign * __fp_min;
      _Tp __Jpnul = __h * __Jnul;
      _Tp __Jnul1 = __Jnul;
      _Tp __Jpnu1 = __Jpnul;
      _Tp __fact = __nu * __xi;
      for ( int __l = __nl; __l >= 1; --__l )
        {
          const _Tp __Jnutemp = __fact * __Jnul + __Jpnul;
          __fact -= __xi;
          __Jpnul = __fact * __Jnutemp - __Jnul;
          __Jnul = __Jnutemp;
        }
      if (__Jnul == _Tp(0))
        __Jnul = __eps;
      _Tp __f= __Jpnul / __Jnul;
      _Tp __Nmu, __Nnu1, __Npmu, __Jmu;
      if (__x < __x_min)
        {
          const _Tp __x2 = __x / _Tp(2);
          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
          _Tp __fact = (std::abs(__pimu) < __eps
                      ? _Tp(1) : __pimu / std::sin(__pimu));
          _Tp __d = -std::log(__x2);
          _Tp __e = __mu * __d;
          _Tp __fact2 = (std::abs(__e) < __eps
                       ? _Tp(1) : std::sinh(__e) / __e);
          _Tp __gam1, __gam2, __gampl, __gammi;
          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
          _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi())
                   * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
          __e = std::exp(__e);
          _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl);
          _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi);
          const _Tp __pimu2 = __pimu / _Tp(2);
          _Tp __fact3 = (std::abs(__pimu2) < __eps
                       ? _Tp(1) : std::sin(__pimu2) / __pimu2 );
          _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3;
          _Tp __c = _Tp(1);
          __d = -__x2 * __x2;
          _Tp __sum = __ff + __r * __q;
          _Tp __sum1 = __p;
          for (__i = 1; __i <= __max_iter; ++__i)
            {
              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
              __c *= __d / _Tp(__i);
              __p /= _Tp(__i) - __mu;
              __q /= _Tp(__i) + __mu;
              const _Tp __del = __c * (__ff + __r * __q);
              __sum += __del;
              const _Tp __del1 = __c * __p - __i * __del;
              __sum1 += __del1;
              if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) )
                break;
            }
          if ( __i > __max_iter )
            std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.")
                                                             );
          __Nmu = -__sum;
          __Nnu1 = -__sum1 * __xi2;
          __Npmu = __mu * __xi * __Nmu - __Nnu1;
          __Jmu = __w / (__Npmu - __f * __Nmu);
        }
      else
        {
          _Tp __a = _Tp(0.25L) - __mu2;
          _Tp __q = _Tp(1);
          _Tp __p = -__xi / _Tp(2);
          _Tp __br = _Tp(2) * __x;
          _Tp __bi = _Tp(2);
          _Tp __fact = __a * __xi / (__p * __p + __q * __q);
          _Tp __cr = __br + __q * __fact;
          _Tp __ci = __bi + __p * __fact;
          _Tp __den = __br * __br + __bi * __bi;
          _Tp __dr = __br / __den;
          _Tp __di = -__bi / __den;
          _Tp __dlr = __cr * __dr - __ci * __di;
          _Tp __dli = __cr * __di + __ci * __dr;
          _Tp __temp = __p * __dlr - __q * __dli;
          __q = __p * __dli + __q * __dlr;
          __p = __temp;
          int __i;
          for (__i = 2; __i <= __max_iter; ++__i)
            {
              __a += _Tp(2 * (__i - 1));
              __bi += _Tp(2);
              __dr = __a * __dr + __br;
              __di = __a * __di + __bi;
              if (std::abs(__dr) + std::abs(__di) < __fp_min)
                __dr = __fp_min;
              __fact = __a / (__cr * __cr + __ci * __ci);
              __cr = __br + __cr * __fact;
              __ci = __bi - __ci * __fact;
              if (std::abs(__cr) + std::abs(__ci) < __fp_min)
                __cr = __fp_min;
              __den = __dr * __dr + __di * __di;
              __dr /= __den;
              __di /= -__den;
              __dlr = __cr * __dr - __ci * __di;
              __dli = __cr * __di + __ci * __dr;
              __temp = __p * __dlr - __q * __dli;
              __q = __p * __dli + __q * __dlr;
              __p = __temp;
              if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps)
                break;
          }
          if (__i > __max_iter)
            std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.")
                                                             );
          const _Tp __gam = (__p - __f) / __q;
          __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));

          __Jmu = ::std::copysign(__Jmu, __Jnul);




          __Nmu = __gam * __Jmu;
          __Npmu = (__p + __q / __gam) * __Nmu;
          __Nnu1 = __mu * __xi * __Nmu - __Npmu;
      }
      __fact = __Jmu / __Jnul;
      __Jnu = __fact * __Jnul1;
      __Jpnu = __fact * __Jpnu1;
      for (__i = 1; __i <= __nl; ++__i)
        {
          const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu;
          __Nmu = __Nnu1;
          __Nnu1 = __Nnutemp;
        }
      __Nnu = __Nmu;
      __Npnu = __nu * __xi * __Nmu - __Nnu1;

      return;
    }
# 361 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu)
    {
      const _Tp __mu = _Tp(4) * __nu * __nu;
      const _Tp __8x = _Tp(8) * __x;

      _Tp __P = _Tp(0);
      _Tp __Q = _Tp(0);

      _Tp __k = _Tp(0);
      _Tp __term = _Tp(1);

      int __epsP = 0;
      int __epsQ = 0;

      _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      do
        {
          __term *= (__k == 0
                     ? _Tp(1)
                     : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x));

          __epsP = std::abs(__term) < __eps * std::abs(__P);
          __P += __term;

          __k++;

          __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x);
          __epsQ = std::abs(__term) < __eps * std::abs(__Q);
          __Q += __term;

          if (__epsP && __epsQ && __k > (__nu / 2.))
            break;

          __k++;
        }
      while (__k < 1000);

      const _Tp __chi = __x - (__nu + _Tp(0.5L))
                             * __numeric_constants<_Tp>::__pi_2();

      const _Tp __c = std::cos(__chi);
      const _Tp __s = std::sin(__chi);

      const _Tp __coef = std::sqrt(_Tp(2)
                             / (__numeric_constants<_Tp>::__pi() * __x));

      __Jnu = __coef * (__c * __P - __s * __Q);
      __Nnu = __coef * (__s * __P + __c * __Q);

      return;
    }
# 444 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    _Tp
    __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn,
                           unsigned int __max_iter)
    {
      if (__x == _Tp(0))
 return __nu == _Tp(0) ? _Tp(1) : _Tp(0);

      const _Tp __x2 = __x / _Tp(2);
      _Tp __fact = __nu * std::log(__x2);

      __fact -= ::std::lgamma(__nu + _Tp(1));



      __fact = std::exp(__fact);
      const _Tp __xx4 = __sgn * __x2 * __x2;
      _Tp __Jn = _Tp(1);
      _Tp __term = _Tp(1);

      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i)));
          __Jn += __term;
          if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon())
            break;
        }

      return __fact * __Jn;
    }
# 490 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_bessel_j(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.")
                                                           );
      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
        return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200);
      else if (__x > _Tp(1000))
        {
          _Tp __J_nu, __N_nu;
          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
          return __J_nu;
        }
      else
        {
          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          return __J_nu;
        }
    }
# 532 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_neumann_n(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.")
                                                            );
      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x > _Tp(1000))
        {
          _Tp __J_nu, __N_nu;
          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
          return __N_nu;
        }
      else
        {
          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          return __N_nu;
        }
    }
# 569 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __sph_bessel_jn(unsigned int __n, _Tp __x,
                    _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n)
    {
      const _Tp __nu = _Tp(__n) + _Tp(0.5L);

      _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
      __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);

      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
                         / std::sqrt(__x);

      __j_n = __factor * __J_nu;
      __n_n = __factor * __N_nu;
      __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x);
      __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x);

      return;
    }
# 604 "/usr/include/c++/10/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    _Tp
    __sph_bessel(unsigned int __n, _Tp __x)
    {
      if (__x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __sph_bessel.")
                                                         );
      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x == _Tp(0))
        {
          if (__n == 0)
            return _Tp(1);
          else
            return _Tp(0);
        }
      else
        {
          _Tp __j_n, __n_n, __jp_n, __np_n;
          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
          return __j_n;
        }
    }
# 642 "/usr/include/c++/10/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;
        }
    }
  }






}
# 51 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/beta_function.tcc" 1 3
# 49 "/usr/include/c++/10/tr1/beta_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 65 "/usr/include/c++/10/tr1/beta_function.tcc" 3
  namespace __detail
  {
# 79 "/usr/include/c++/10/tr1/beta_function.tcc" 3
    template<typename _Tp>
    _Tp
    __beta_gamma(_Tp __x, _Tp __y)
    {

      _Tp __bet;

      if (__x > __y)
        {
          __bet = ::std::tgamma(__x)
                / ::std::tgamma(__x + __y);
          __bet *= ::std::tgamma(__y);
        }
      else
        {
          __bet = ::std::tgamma(__y)
                / ::std::tgamma(__x + __y);
          __bet *= ::std::tgamma(__x);
        }
# 111 "/usr/include/c++/10/tr1/beta_function.tcc" 3
      return __bet;
    }
# 127 "/usr/include/c++/10/tr1/beta_function.tcc" 3
    template<typename _Tp>
    _Tp
    __beta_lgamma(_Tp __x, _Tp __y)
    {

      _Tp __bet = ::std::lgamma(__x)
                + ::std::lgamma(__y)
                - ::std::lgamma(__x + __y);





      __bet = std::exp(__bet);
      return __bet;
    }
# 158 "/usr/include/c++/10/tr1/beta_function.tcc" 3
    template<typename _Tp>
    _Tp
    __beta_product(_Tp __x, _Tp __y)
    {

      _Tp __bet = (__x + __y) / (__x * __y);

      unsigned int __max_iter = 1000000;
      for (unsigned int __k = 1; __k < __max_iter; ++__k)
        {
          _Tp __term = (_Tp(1) + (__x + __y) / __k)
                     / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k));
          __bet *= __term;
        }

      return __bet;
    }
# 189 "/usr/include/c++/10/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);
    }
  }






}
# 52 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/ell_integral.tcc" 1 3
# 45 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 59 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
  namespace __detail
  {
# 76 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rf(_Tp __x, _Tp __y, _Tp __z)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __max = std::numeric_limits<_Tp>::max();
      const _Tp __lolim = _Tp(5) * __min;
      const _Tp __uplim = __max / _Tp(5);

      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.")
                                                        );
      else if (__x + __y < __lolim || __x + __z < __lolim
            || __y + __z < __lolim)
        std::__throw_domain_error(("Argument too small in __ellint_rf"));
      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(1) / _Tp(24);
          const _Tp __c2 = _Tp(1) / _Tp(10);
          const _Tp __c3 = _Tp(3) / _Tp(44);
          const _Tp __c4 = _Tp(1) / _Tp(14);

          _Tp __xn = __x;
          _Tp __yn = __y;
          _Tp __zn = __z;

          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
          const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
          _Tp __mu;
          _Tp __xndev, __yndev, __zndev;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + __yn + __zn) / _Tp(3);
              __xndev = 2 - (__mu + __xn) / __mu;
              __yndev = 2 - (__mu + __yn) / __mu;
              __zndev = 2 - (__mu + __zn) / __mu;
              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
              __epsilon = std::max(__epsilon, std::abs(__zndev));
              if (__epsilon < __errtol)
                break;
              const _Tp __xnroot = std::sqrt(__xn);
              const _Tp __ynroot = std::sqrt(__yn);
              const _Tp __znroot = std::sqrt(__zn);
              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
                                 + __ynroot * __znroot;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
              __zn = __c0 * (__zn + __lambda);
            }

          const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
          const _Tp __e3 = __xndev * __yndev * __zndev;
          const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
                   + __c4 * __e3;

          return __s / std::sqrt(__mu);
        }
    }
# 155 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_1_series(_Tp __k)
    {

      const _Tp __kk = __k * __k;

      _Tp __term = __kk / _Tp(4);
      _Tp __sum = _Tp(1) + __term;

      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 2; __i < __max_iter; ++__i)
        {
          __term *= (2 * __i - 1) * __kk / (2 * __i);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term;
        }

      return __numeric_constants<_Tp>::__pi_2() * __sum;
    }
# 193 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_1(_Tp __k)
    {

      if (__isnan(__k))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) >= _Tp(1))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
    }
# 221 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_1(_Tp __k, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_1."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __s = std::sin(__phi_red);
          const _Tp __c = std::cos(__phi_red);

          const _Tp __F = __s
                        * __ellint_rf(__c * __c,
                                _Tp(1) - __k * __k * __s * __s, _Tp(1));

          if (__n == 0)
            return __F;
          else
            return __F + _Tp(2) * __n * __comp_ellint_1(__k);
        }
    }
# 268 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_2_series(_Tp __k)
    {

      const _Tp __kk = __k * __k;

      _Tp __term = __kk;
      _Tp __sum = __term;

      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 2; __i < __max_iter; ++__i)
        {
          const _Tp __i2m = 2 * __i - 1;
          const _Tp __i2 = 2 * __i;
          __term *= __i2m * __i2m * __kk / (__i2 * __i2);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term / __i2m;
        }

      return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
    }
# 316 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rd(_Tp __x, _Tp __y, _Tp __z)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __max = std::numeric_limits<_Tp>::max();
      const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));
      const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3));

      if (__x < _Tp(0) || __y < _Tp(0))
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.")
                                                        );
      else if (__x + __y < __lolim || __z < __lolim)
        std::__throw_domain_error(("Argument too small " "in __ellint_rd.")
                                                        );
      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(3) / _Tp(14);
          const _Tp __c2 = _Tp(1) / _Tp(6);
          const _Tp __c3 = _Tp(9) / _Tp(22);
          const _Tp __c4 = _Tp(3) / _Tp(26);

          _Tp __xn = __x;
          _Tp __yn = __y;
          _Tp __zn = __z;
          _Tp __sigma = _Tp(0);
          _Tp __power4 = _Tp(1);

          _Tp __mu;
          _Tp __xndev, __yndev, __zndev;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
              __xndev = (__mu - __xn) / __mu;
              __yndev = (__mu - __yn) / __mu;
              __zndev = (__mu - __zn) / __mu;
              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
              __epsilon = std::max(__epsilon, std::abs(__zndev));
              if (__epsilon < __errtol)
                break;
              _Tp __xnroot = std::sqrt(__xn);
              _Tp __ynroot = std::sqrt(__yn);
              _Tp __znroot = std::sqrt(__zn);
              _Tp __lambda = __xnroot * (__ynroot + __znroot)
                           + __ynroot * __znroot;
              __sigma += __power4 / (__znroot * (__zn + __lambda));
              __power4 *= __c0;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
              __zn = __c0 * (__zn + __lambda);
            }

          _Tp __ea = __xndev * __yndev;
          _Tp __eb = __zndev * __zndev;
          _Tp __ec = __ea - __eb;
          _Tp __ed = __ea - _Tp(6) * __eb;
          _Tp __ef = __ed + __ec + __ec;
          _Tp __s1 = __ed * (-__c1 + __c3 * __ed
                                   / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef
                                   / _Tp(2));
          _Tp __s2 = __zndev
                   * (__c2 * __ef
                    + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea));

          return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
                                        / (__mu * std::sqrt(__mu));
        }
    }
# 403 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_2(_Tp __k)
    {

      if (__isnan(__k))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) == 1)
        return _Tp(1);
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __comp_ellint_2."));
      else
        {
          const _Tp __kk = __k * __k;

          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
               - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
        }
    }
# 437 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_2(_Tp __k, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_2."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __kk = __k * __k;
          const _Tp __s = std::sin(__phi_red);
          const _Tp __ss = __s * __s;
          const _Tp __sss = __ss * __s;
          const _Tp __c = std::cos(__phi_red);
          const _Tp __cc = __c * __c;

          const _Tp __E = __s
                        * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                        - __kk * __sss
                        * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                        / _Tp(3);

          if (__n == 0)
            return __E;
          else
            return __E + _Tp(2) * __n * __comp_ellint_2(__k);
        }
    }
# 496 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rc(_Tp __x, _Tp __y)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __max = std::numeric_limits<_Tp>::max();
      const _Tp __lolim = _Tp(5) * __min;
      const _Tp __uplim = __max / _Tp(5);

      if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.")
                                                        );
      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(1) / _Tp(7);
          const _Tp __c2 = _Tp(9) / _Tp(22);
          const _Tp __c3 = _Tp(3) / _Tp(10);
          const _Tp __c4 = _Tp(3) / _Tp(8);

          _Tp __xn = __x;
          _Tp __yn = __y;

          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
          const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
          _Tp __mu;
          _Tp __sn;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + _Tp(2) * __yn) / _Tp(3);
              __sn = (__yn + __mu) / __mu - _Tp(2);
              if (std::abs(__sn) < __errtol)
                break;
              const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
                             + __yn;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
            }

          _Tp __s = __sn * __sn
                  * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));

          return (_Tp(1) + __s) / std::sqrt(__mu);
        }
    }
# 567 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __max = std::numeric_limits<_Tp>::max();
      const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));
      const _Tp __uplim = _Tp(0.3L)
                        * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3));

      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
        std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.")
                                                        );
      else if (__x + __y < __lolim || __x + __z < __lolim
            || __y + __z < __lolim || __p < __lolim)
        std::__throw_domain_error(("Argument too small " "in __ellint_rj")
                                                       );
      else
        {
          const _Tp __c0 = _Tp(1) / _Tp(4);
          const _Tp __c1 = _Tp(3) / _Tp(14);
          const _Tp __c2 = _Tp(1) / _Tp(3);
          const _Tp __c3 = _Tp(3) / _Tp(22);
          const _Tp __c4 = _Tp(3) / _Tp(26);

          _Tp __xn = __x;
          _Tp __yn = __y;
          _Tp __zn = __z;
          _Tp __pn = __p;
          _Tp __sigma = _Tp(0);
          _Tp __power4 = _Tp(1);

          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
          const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));

          _Tp __lambda, __mu;
          _Tp __xndev, __yndev, __zndev, __pndev;

          const unsigned int __max_iter = 100;
          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
            {
              __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
              __xndev = (__mu - __xn) / __mu;
              __yndev = (__mu - __yn) / __mu;
              __zndev = (__mu - __zn) / __mu;
              __pndev = (__mu - __pn) / __mu;
              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
              __epsilon = std::max(__epsilon, std::abs(__zndev));
              __epsilon = std::max(__epsilon, std::abs(__pndev));
              if (__epsilon < __errtol)
                break;
              const _Tp __xnroot = std::sqrt(__xn);
              const _Tp __ynroot = std::sqrt(__yn);
              const _Tp __znroot = std::sqrt(__zn);
              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
                                 + __ynroot * __znroot;
              const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
                                + __xnroot * __ynroot * __znroot;
              const _Tp __alpha2 = __alpha1 * __alpha1;
              const _Tp __beta = __pn * (__pn + __lambda)
                                      * (__pn + __lambda);
              __sigma += __power4 * __ellint_rc(__alpha2, __beta);
              __power4 *= __c0;
              __xn = __c0 * (__xn + __lambda);
              __yn = __c0 * (__yn + __lambda);
              __zn = __c0 * (__zn + __lambda);
              __pn = __c0 * (__pn + __lambda);
            }

          _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev;
          _Tp __eb = __xndev * __yndev * __zndev;
          _Tp __ec = __pndev * __pndev;
          _Tp __e2 = __ea - _Tp(3) * __ec;
          _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec);
          _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4)
                            - _Tp(3) * __c4 * __e3 / _Tp(2));
          _Tp __s2 = __eb * (__c2 / _Tp(2)
                   + __pndev * (-__c3 - __c3 + __pndev * __c4));
          _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3)
                   - __c2 * __pndev * __ec;

          return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
                                             / (__mu * std::sqrt(__mu));
        }
    }
# 670 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_3(_Tp __k, _Tp __nu)
    {

      if (__isnan(__k) || __isnan(__nu))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__nu == _Tp(1))
        return std::numeric_limits<_Tp>::infinity();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __comp_ellint_3."));
      else
        {
          const _Tp __kk = __k * __k;

          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
               + __nu
               * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu)
               / _Tp(3);
        }
    }
# 710 "/usr/include/c++/10/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_3."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __kk = __k * __k;
          const _Tp __s = std::sin(__phi_red);
          const _Tp __ss = __s * __s;
          const _Tp __sss = __ss * __s;
          const _Tp __c = std::cos(__phi_red);
          const _Tp __cc = __c * __c;

          const _Tp __Pi = __s
                         * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                         + __nu * __sss
                         * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
                                       _Tp(1) - __nu * __ss) / _Tp(3);

          if (__n == 0)
            return __Pi;
          else
            return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
        }
    }
  }





}
# 53 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/exp_integral.tcc" 1 3
# 50 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 64 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
  namespace __detail
  {
    template<typename _Tp> _Tp __expint_E1(_Tp);
# 81 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_E1_series(_Tp __x)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      _Tp __term = _Tp(1);
      _Tp __esum = _Tp(0);
      _Tp __osum = _Tp(0);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          __term *= - __x / __i;
          if (std::abs(__term) < __eps)
            break;
          if (__term >= _Tp(0))
            __esum += __term / __i;
          else
            __osum += __term / __i;
        }

      return - __esum - __osum
             - __numeric_constants<_Tp>::__gamma_e() - std::log(__x);
    }
# 118 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_E1_asymp(_Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __esum = _Tp(1);
      _Tp __osum = _Tp(0);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          _Tp __prev = __term;
          __term *= - __i / __x;
          if (std::abs(__term) > std::abs(__prev))
            break;
          if (__term >= _Tp(0))
            __esum += __term;
          else
            __osum += __term;
        }

      return std::exp(- __x) * (__esum + __osum) / __x;
    }
# 155 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_En_series(unsigned int __n, _Tp __x)
    {
      const unsigned int __max_iter = 1000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const int __nm1 = __n - 1;
      _Tp __ans = (__nm1 != 0
                ? _Tp(1) / __nm1 : -std::log(__x)
                                   - __numeric_constants<_Tp>::__gamma_e());
      _Tp __fact = _Tp(1);
      for (int __i = 1; __i <= __max_iter; ++__i)
        {
          __fact *= -__x / _Tp(__i);
          _Tp __del;
          if ( __i != __nm1 )
            __del = -__fact / _Tp(__i - __nm1);
          else
            {
              _Tp __psi = -__numeric_constants<_Tp>::gamma_e();
              for (int __ii = 1; __ii <= __nm1; ++__ii)
                __psi += _Tp(1) / _Tp(__ii);
              __del = __fact * (__psi - std::log(__x));
            }
          __ans += __del;
          if (std::abs(__del) < __eps * std::abs(__ans))
            return __ans;
        }
      std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.")
                                                              );
    }
# 201 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_En_cont_frac(unsigned int __n, _Tp __x)
    {
      const unsigned int __max_iter = 1000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __fp_min = std::numeric_limits<_Tp>::min();
      const int __nm1 = __n - 1;
      _Tp __b = __x + _Tp(__n);
      _Tp __c = _Tp(1) / __fp_min;
      _Tp __d = _Tp(1) / __b;
      _Tp __h = __d;
      for ( unsigned int __i = 1; __i <= __max_iter; ++__i )
        {
          _Tp __a = -_Tp(__i * (__nm1 + __i));
          __b += _Tp(2);
          __d = _Tp(1) / (__a * __d + __b);
          __c = __b + __a / __c;
          const _Tp __del = __c * __d;
          __h *= __del;
          if (std::abs(__del - _Tp(1)) < __eps)
            {
              const _Tp __ans = __h * std::exp(-__x);
              return __ans;
            }
        }
      std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.")
                                                                 );
    }
# 246 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_En_recursion(unsigned int __n, _Tp __x)
    {
      _Tp __En;
      _Tp __E1 = __expint_E1(__x);
      if (__x < _Tp(__n))
        {

          __En = __E1;
          for (unsigned int __j = 2; __j < __n; ++__j)
            __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1);
        }
      else
        {

          __En = _Tp(1);
          const int __N = __n + 20;
          _Tp __save = _Tp(0);
          for (int __j = __N; __j > 0; --__j)
            {
              __En = (std::exp(-__x) - __j * __En) / __x;
              if (__j == __n)
                __save = __En;
            }
            _Tp __norm = __En / __E1;
            __En /= __norm;
        }

      return __En;
    }
# 290 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_Ei_series(_Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(0);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          __term *= __x / __i;
          __sum += __term / __i;
          if (__term < std::numeric_limits<_Tp>::epsilon() * __sum)
            break;
        }

      return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x);
    }
# 321 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_Ei_asymp(_Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(1);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          _Tp __prev = __term;
          __term *= __i / __x;
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          if (__term >= __prev)
            break;
          __sum += __term;
        }

      return std::exp(__x) * __sum / __x;
    }
# 354 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_Ei(_Tp __x)
    {
      if (__x < _Tp(0))
        return -__expint_E1(-__x);
      else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon()))
        return __expint_Ei_series(__x);
      else
        return __expint_Ei_asymp(__x);
    }
# 378 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_E1(_Tp __x)
    {
      if (__x < _Tp(0))
        return -__expint_Ei(-__x);
      else if (__x < _Tp(1))
        return __expint_E1_series(__x);
      else if (__x < _Tp(100))
        return __expint_En_cont_frac(1, __x);
      else
        return __expint_E1_asymp(__x);
    }
# 408 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_asymp(unsigned int __n, _Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(1);
      for (unsigned int __i = 1; __i <= __n; ++__i)
        {
          _Tp __prev = __term;
          __term *= -(__n - __i + 1) / __x;
          if (std::abs(__term) > std::abs(__prev))
            break;
          __sum += __term;
        }

      return std::exp(-__x) * __sum / __x;
    }
# 442 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_large_n(unsigned int __n, _Tp __x)
    {
      const _Tp __xpn = __x + __n;
      const _Tp __xpn2 = __xpn * __xpn;
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(1);
      for (unsigned int __i = 1; __i <= __n; ++__i)
        {
          _Tp __prev = __term;
          __term *= (__n - 2 * (__i - 1) * __x) / __xpn2;
          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term;
        }

      return std::exp(-__x) * __sum / __xpn;
    }
# 476 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint(unsigned int __n, _Tp __x)
    {

      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__n <= 1 && __x == _Tp(0))
        return std::numeric_limits<_Tp>::infinity();
      else
        {
          _Tp __E0 = std::exp(__x) / __x;
          if (__n == 0)
            return __E0;

          _Tp __E1 = __expint_E1(__x);
          if (__n == 1)
            return __E1;

          if (__x == _Tp(0))
            return _Tp(1) / static_cast<_Tp>(__n - 1);

          _Tp __En = __expint_En_recursion(__n, __x);

          return __En;
        }
    }
# 516 "/usr/include/c++/10/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    inline _Tp
    __expint(_Tp __x)
    {
      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __expint_Ei(__x);
    }
  }





}
# 54 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/hypergeometric.tcc" 1 3
# 44 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 60 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3
  namespace __detail
  {
# 83 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      _Tp __term = _Tp(1);
      _Tp __Fac = _Tp(1);
      const unsigned int __max_iter = 100000;
      unsigned int __i;
      for (__i = 0; __i < __max_iter; ++__i)
        {
          __term *= (__a + _Tp(__i)) * __x
                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
          if (std::abs(__term) < __eps)
            {
              break;
            }
          __Fac += __term;
        }
      if (__i == __max_iter)
        std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.")
                                                                  );

      return __Fac;
    }
# 120 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin)
    {
      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
      const int __nmax = 20000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __x = -__xin;
      const _Tp __x3 = __x * __x * __x;
      const _Tp __t0 = __a / __c;
      const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c);
      const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1)));
      _Tp __F = _Tp(1);
      _Tp __prec;

      _Tp __Bnm3 = _Tp(1);
      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);

      _Tp __Anm3 = _Tp(1);
      _Tp __Anm2 = __Bnm2 - __t0 * __x;
      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;

      int __n = 3;
      while(1)
        {
          _Tp __npam1 = _Tp(__n - 1) + __a;
          _Tp __npcm1 = _Tp(__n - 1) + __c;
          _Tp __npam2 = _Tp(__n - 2) + __a;
          _Tp __npcm2 = _Tp(__n - 2) + __c;
          _Tp __tnm1 = _Tp(2 * __n - 1);
          _Tp __tnm3 = _Tp(2 * __n - 3);
          _Tp __tnm5 = _Tp(2 * __n - 5);
          _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1);
          _Tp __F2 = (_Tp(__n) + __a) * __npam1
                   / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
          _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a)
                   / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
                   * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
          _Tp __E = -__npam1 * (_Tp(__n - 1) - __c)
                   / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);

          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
          _Tp __r = __An / __Bn;

          __prec = std::abs((__F - __r) / __F);
          __F = __r;

          if (__prec < __eps || __n > __nmax)
            break;

          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
            {
              __An /= __big;
              __Bn /= __big;
              __Anm1 /= __big;
              __Bnm1 /= __big;
              __Anm2 /= __big;
              __Bnm2 /= __big;
              __Anm3 /= __big;
              __Bnm3 /= __big;
            }
          else if (std::abs(__An) < _Tp(1) / __big
                || std::abs(__Bn) < _Tp(1) / __big)
            {
              __An *= __big;
              __Bn *= __big;
              __Anm1 *= __big;
              __Bnm1 *= __big;
              __Anm2 *= __big;
              __Bnm2 *= __big;
              __Anm3 *= __big;
              __Bnm3 *= __big;
            }

          ++__n;
          __Bnm3 = __Bnm2;
          __Bnm2 = __Bnm1;
          __Bnm1 = __Bn;
          __Anm3 = __Anm2;
          __Anm2 = __Anm1;
          __Anm1 = __An;
        }

      if (__n >= __nmax)
        std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.")
                                                                );

      return __F;
    }
# 227 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __conf_hyperg(_Tp __a, _Tp __c, _Tp __x)
    {

      const _Tp __c_nint = ::std::nearbyint(__c);



      if (__isnan(__a) || __isnan(__c) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__c_nint == __c && __c_nint <= 0)
        return std::numeric_limits<_Tp>::infinity();
      else if (__a == _Tp(0))
        return _Tp(1);
      else if (__c == __a)
        return std::exp(__x);
      else if (__x < _Tp(0))
        return __conf_hyperg_luke(__a, __c, __x);
      else
        return __conf_hyperg_series(__a, __c, __x);
    }
# 271 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      _Tp __term = _Tp(1);
      _Tp __Fabc = _Tp(1);
      const unsigned int __max_iter = 100000;
      unsigned int __i;
      for (__i = 0; __i < __max_iter; ++__i)
        {
          __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x
                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
          if (std::abs(__term) < __eps)
            {
              break;
            }
          __Fabc += __term;
        }
      if (__i == __max_iter)
        std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.")
                                                             );

      return __Fabc;
    }







    template<typename _Tp>
    _Tp
    __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin)
    {
      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
      const int __nmax = 20000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __x = -__xin;
      const _Tp __x3 = __x * __x * __x;
      const _Tp __t0 = __a * __b / __c;
      const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c);
      const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2))
                     / (_Tp(2) * (__c + _Tp(1)));

      _Tp __F = _Tp(1);

      _Tp __Bnm3 = _Tp(1);
      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);

      _Tp __Anm3 = _Tp(1);
      _Tp __Anm2 = __Bnm2 - __t0 * __x;
      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;

      int __n = 3;
      while (1)
        {
          const _Tp __npam1 = _Tp(__n - 1) + __a;
          const _Tp __npbm1 = _Tp(__n - 1) + __b;
          const _Tp __npcm1 = _Tp(__n - 1) + __c;
          const _Tp __npam2 = _Tp(__n - 2) + __a;
          const _Tp __npbm2 = _Tp(__n - 2) + __b;
          const _Tp __npcm2 = _Tp(__n - 2) + __c;
          const _Tp __tnm1 = _Tp(2 * __n - 1);
          const _Tp __tnm3 = _Tp(2 * __n - 3);
          const _Tp __tnm5 = _Tp(2 * __n - 5);
          const _Tp __n2 = __n * __n;
          const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n
                         + _Tp(2) - __a * __b - _Tp(2) * (__a + __b))
                         / (_Tp(2) * __tnm3 * __npcm1);
          const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n
                         + _Tp(2) - __a * __b) * __npam1 * __npbm1
                         / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
          const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1
                         * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b))
                         / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
                         * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
          const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c)
                         / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);

          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
          const _Tp __r = __An / __Bn;

          const _Tp __prec = std::abs((__F - __r) / __F);
          __F = __r;

          if (__prec < __eps || __n > __nmax)
            break;

          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
            {
              __An /= __big;
              __Bn /= __big;
              __Anm1 /= __big;
              __Bnm1 /= __big;
              __Anm2 /= __big;
              __Bnm2 /= __big;
              __Anm3 /= __big;
              __Bnm3 /= __big;
            }
          else if (std::abs(__An) < _Tp(1) / __big
                || std::abs(__Bn) < _Tp(1) / __big)
            {
              __An *= __big;
              __Bn *= __big;
              __Anm1 *= __big;
              __Bnm1 *= __big;
              __Anm2 *= __big;
              __Bnm2 *= __big;
              __Anm3 *= __big;
              __Bnm3 *= __big;
            }

          ++__n;
          __Bnm3 = __Bnm2;
          __Bnm2 = __Bnm1;
          __Bnm1 = __Bn;
          __Anm3 = __Anm2;
          __Anm2 = __Anm1;
          __Anm1 = __An;
        }

      if (__n >= __nmax)
        std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.")
                                                           );

      return __F;
    }
# 438 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
    {
      const _Tp __d = __c - __a - __b;
      const int __intd = std::floor(__d + _Tp(0.5L));
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __toler = _Tp(1000) * __eps;
      const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max());
      const bool __d_integer = (std::abs(__d - __intd) < __toler);

      if (__d_integer)
        {
          const _Tp __ln_omx = std::log(_Tp(1) - __x);
          const _Tp __ad = std::abs(__d);
          _Tp __F1, __F2;

          _Tp __d1, __d2;
          if (__d >= _Tp(0))
            {
              __d1 = __d;
              __d2 = _Tp(0);
            }
          else
            {
              __d1 = _Tp(0);
              __d2 = __d;
            }

          const _Tp __lng_c = __log_gamma(__c);


          if (__ad < __eps)
            {

              __F1 = _Tp(0);
            }
          else
            {

              bool __ok_d1 = true;
              _Tp __lng_ad, __lng_ad1, __lng_bd1;
              try
                {
                  __lng_ad = __log_gamma(__ad);
                  __lng_ad1 = __log_gamma(__a + __d1);
                  __lng_bd1 = __log_gamma(__b + __d1);
                }
              catch(...)
                {
                  __ok_d1 = false;
                }

              if (__ok_d1)
                {



                  _Tp __sum1 = _Tp(1);
                  _Tp __term = _Tp(1);
                  _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx
                                - __lng_ad1 - __lng_bd1;



                  for (int __i = 1; __i < __ad; ++__i)
                    {
                      const int __j = __i - 1;
                      __term *= (__a + __d2 + __j) * (__b + __d2 + __j)
                              / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x);
                      __sum1 += __term;
                    }

                  if (__ln_pre1 > __log_max)
                    std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.")
                                                                        );
                  else
                    __F1 = std::exp(__ln_pre1) * __sum1;
                }
              else
                {


                  __F1 = _Tp(0);
                }
            }


          bool __ok_d2 = true;
          _Tp __lng_ad2, __lng_bd2;
          try
            {
              __lng_ad2 = __log_gamma(__a + __d2);
              __lng_bd2 = __log_gamma(__b + __d2);
            }
          catch(...)
            {
              __ok_d2 = false;
            }

          if (__ok_d2)
            {


              const int __maxiter = 2000;
              const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e();
              const _Tp __psi_1pd = __psi(_Tp(1) + __ad);
              const _Tp __psi_apd1 = __psi(__a + __d1);
              const _Tp __psi_bpd1 = __psi(__b + __d1);

              _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1
                             - __psi_bpd1 - __ln_omx;
              _Tp __fact = _Tp(1);
              _Tp __sum2 = __psi_term;
              _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx
                            - __lng_ad2 - __lng_bd2;


              int __j;
              for (__j = 1; __j < __maxiter; ++__j)
                {


                  const _Tp __term1 = _Tp(1) / _Tp(__j)
                                    + _Tp(1) / (__ad + __j);
                  const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1))
                                    + _Tp(1) / (__b + __d1 + _Tp(__j - 1));
                  __psi_term += __term1 - __term2;
                  __fact *= (__a + __d1 + _Tp(__j - 1))
                          * (__b + __d1 + _Tp(__j - 1))
                          / ((__ad + __j) * __j) * (_Tp(1) - __x);
                  const _Tp __delta = __fact * __psi_term;
                  __sum2 += __delta;
                  if (std::abs(__delta) < __eps * std::abs(__sum2))
                    break;
                }
              if (__j == __maxiter)
                std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect")
                                                                     );

              if (__sum2 == _Tp(0))
                __F2 = _Tp(0);
              else
                __F2 = std::exp(__ln_pre2) * __sum2;
            }
          else
            {


              __F2 = _Tp(0);
            }

          const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1));
          const _Tp __F = __F1 + __sgn_2 * __F2;

          return __F;
        }
      else
        {




          bool __ok1 = true;
          _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0);
          _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0);
          try
            {
              __sgn_g1ca = __log_gamma_sign(__c - __a);
              __ln_g1ca = __log_gamma(__c - __a);
              __sgn_g1cb = __log_gamma_sign(__c - __b);
              __ln_g1cb = __log_gamma(__c - __b);
            }
          catch(...)
            {
              __ok1 = false;
            }

          bool __ok2 = true;
          _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0);
          _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0);
          try
            {
              __sgn_g2a = __log_gamma_sign(__a);
              __ln_g2a = __log_gamma(__a);
              __sgn_g2b = __log_gamma_sign(__b);
              __ln_g2b = __log_gamma(__b);
            }
          catch(...)
            {
              __ok2 = false;
            }

          const _Tp __sgn_gc = __log_gamma_sign(__c);
          const _Tp __ln_gc = __log_gamma(__c);
          const _Tp __sgn_gd = __log_gamma_sign(__d);
          const _Tp __ln_gd = __log_gamma(__d);
          const _Tp __sgn_gmd = __log_gamma_sign(-__d);
          const _Tp __ln_gmd = __log_gamma(-__d);

          const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb;
          const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b;

          _Tp __pre1, __pre2;
          if (__ok1 && __ok2)
            {
              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
                            + __d * std::log(_Tp(1) - __x);
              if (__ln_pre1 < __log_max && __ln_pre2 < __log_max)
                {
                  __pre1 = std::exp(__ln_pre1);
                  __pre2 = std::exp(__ln_pre2);
                  __pre1 *= __sgn1;
                  __pre2 *= __sgn2;
                }
              else
                {
                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
                                                                       );
                }
            }
          else if (__ok1 && !__ok2)
            {
              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
              if (__ln_pre1 < __log_max)
                {
                  __pre1 = std::exp(__ln_pre1);
                  __pre1 *= __sgn1;
                  __pre2 = _Tp(0);
                }
              else
                {
                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
                                                                       );
                }
            }
          else if (!__ok1 && __ok2)
            {
              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
                            + __d * std::log(_Tp(1) - __x);
              if (__ln_pre2 < __log_max)
                {
                  __pre1 = _Tp(0);
                  __pre2 = std::exp(__ln_pre2);
                  __pre2 *= __sgn2;
                }
              else
                {
                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
                                                                       );
                }
            }
          else
            {
              __pre1 = _Tp(0);
              __pre2 = _Tp(0);
              std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect")
                                                                   );
            }

          const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d,
                                           _Tp(1) - __x);
          const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d,
                                           _Tp(1) - __x);

          const _Tp __F = __pre1 * __F1 + __pre2 * __F2;

          return __F;
        }
    }
# 728 "/usr/include/c++/10/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);
    }
  }






}
# 55 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/legendre_function.tcc" 1 3
# 49 "/usr/include/c++/10/tr1/legendre_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 65 "/usr/include/c++/10/tr1/legendre_function.tcc" 3
  namespace __detail
  {
# 80 "/usr/include/c++/10/tr1/legendre_function.tcc" 3
    template<typename _Tp>
    _Tp
    __poly_legendre_p(unsigned int __l, _Tp __x)
    {

      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x == +_Tp(1))
        return +_Tp(1);
      else if (__x == -_Tp(1))
        return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1));
      else
        {
          _Tp __p_lm2 = _Tp(1);
          if (__l == 0)
            return __p_lm2;

          _Tp __p_lm1 = __x;
          if (__l == 1)
            return __p_lm1;

          _Tp __p_l = 0;
          for (unsigned int __ll = 2; __ll <= __l; ++__ll)
            {


              __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2
                    - (__x * __p_lm1 - __p_lm2) / _Tp(__ll);
              __p_lm2 = __p_lm1;
              __p_lm1 = __p_l;
            }

          return __p_l;
        }
    }
# 136 "/usr/include/c++/10/tr1/legendre_function.tcc" 3
    template<typename _Tp>
    _Tp
    __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x,
         _Tp __phase = _Tp(+1))
    {

      if (__m > __l)
        return _Tp(0);
      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__m == 0)
        return __poly_legendre_p(__l, __x);
      else
        {
          _Tp __p_mm = _Tp(1);
          if (__m > 0)
            {


              _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x);
              _Tp __fact = _Tp(1);
              for (unsigned int __i = 1; __i <= __m; ++__i)
                {
                  __p_mm *= __phase * __fact * __root;
                  __fact += _Tp(2);
                }
            }
          if (__l == __m)
            return __p_mm;

          _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm;
          if (__l == __m + 1)
            return __p_mp1m;

          _Tp __p_lm2m = __p_mm;
          _Tp __P_lm1m = __p_mp1m;
          _Tp __p_lm = _Tp(0);
          for (unsigned int __j = __m + 2; __j <= __l; ++__j)
            {
              __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m
                      - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m);
              __p_lm2m = __P_lm1m;
              __P_lm1m = __p_lm;
            }

          return __p_lm;
        }
    }
# 214 "/usr/include/c++/10/tr1/legendre_function.tcc" 3
    template <typename _Tp>
    _Tp
    __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
    {
      if (__isnan(__theta))
        return std::numeric_limits<_Tp>::quiet_NaN();

      const _Tp __x = std::cos(__theta);

      if (__m > __l)
        return _Tp(0);
      else if (__m == 0)
        {
          _Tp __P = __poly_legendre_p(__l, __x);
          _Tp __fact = std::sqrt(_Tp(2 * __l + 1)
                     / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
          __P *= __fact;
          return __P;
        }
      else if (__x == _Tp(1) || __x == -_Tp(1))
        {

          return _Tp(0);
        }
      else
        {





          const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
          const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));

          const _Tp __lncirc = ::std::log1p(-__x * __x);





          const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L)))
                             - ::std::lgamma(_Tp(__m));




          const _Tp __lnpre_val =
                    -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
                    + _Tp(0.5L) * (__lnpoch + __m * __lncirc);
          const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
                         / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
          _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
          _Tp __y_mp1m = __y_mp1m_factor * __y_mm;

          if (__l == __m)
            return __y_mm;
          else if (__l == __m + 1)
            return __y_mp1m;
          else
            {
              _Tp __y_lm = _Tp(0);


              for (int __ll = __m + 2; __ll <= __l; ++__ll)
                {
                  const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
                  const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
                  const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
                                                       * _Tp(2 * __ll - 1));
                  const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
                                                                / _Tp(2 * __ll - 3));
                  __y_lm = (__x * __y_mp1m * __fact1
                         - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
                  __y_mm = __y_mp1m;
                  __y_mp1m = __y_lm;
                }

              return __y_lm;
            }
        }
    }
  }






}
# 56 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 1 3
# 51 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 65 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3
  namespace __detail
  {
# 83 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3
    template <typename _Tp>
    void
    __bessel_ik(_Tp __nu, _Tp __x,
                _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
    {
      if (__x == _Tp(0))
        {
          if (__nu == _Tp(0))
            {
              __Inu = _Tp(1);
              __Ipnu = _Tp(0);
            }
          else if (__nu == _Tp(1))
            {
              __Inu = _Tp(0);
              __Ipnu = _Tp(0.5L);
            }
          else
            {
              __Inu = _Tp(0);
              __Ipnu = _Tp(0);
            }
          __Knu = std::numeric_limits<_Tp>::infinity();
          __Kpnu = -std::numeric_limits<_Tp>::infinity();
          return;
        }

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
      const int __max_iter = 15000;
      const _Tp __x_min = _Tp(2);

      const int __nl = static_cast<int>(__nu + _Tp(0.5L));

      const _Tp __mu = __nu - __nl;
      const _Tp __mu2 = __mu * __mu;
      const _Tp __xi = _Tp(1) / __x;
      const _Tp __xi2 = _Tp(2) * __xi;
      _Tp __h = __nu * __xi;
      if ( __h < __fp_min )
        __h = __fp_min;
      _Tp __b = __xi2 * __nu;
      _Tp __d = _Tp(0);
      _Tp __c = __h;
      int __i;
      for ( __i = 1; __i <= __max_iter; ++__i )
        {
          __b += __xi2;
          __d = _Tp(1) / (__b + __d);
          __c = __b + _Tp(1) / __c;
          const _Tp __del = __c * __d;
          __h *= __del;
          if (std::abs(__del - _Tp(1)) < __eps)
            break;
        }
      if (__i > __max_iter)
        std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.")

                                                                   );
      _Tp __Inul = __fp_min;
      _Tp __Ipnul = __h * __Inul;
      _Tp __Inul1 = __Inul;
      _Tp __Ipnu1 = __Ipnul;
      _Tp __fact = __nu * __xi;
      for (int __l = __nl; __l >= 1; --__l)
        {
          const _Tp __Inutemp = __fact * __Inul + __Ipnul;
          __fact -= __xi;
          __Ipnul = __fact * __Inutemp + __Inul;
          __Inul = __Inutemp;
        }
      _Tp __f = __Ipnul / __Inul;
      _Tp __Kmu, __Knu1;
      if (__x < __x_min)
        {
          const _Tp __x2 = __x / _Tp(2);
          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
          const _Tp __fact = (std::abs(__pimu) < __eps
                            ? _Tp(1) : __pimu / std::sin(__pimu));
          _Tp __d = -std::log(__x2);
          _Tp __e = __mu * __d;
          const _Tp __fact2 = (std::abs(__e) < __eps
                            ? _Tp(1) : std::sinh(__e) / __e);
          _Tp __gam1, __gam2, __gampl, __gammi;
          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
          _Tp __ff = __fact
                   * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
          _Tp __sum = __ff;
          __e = std::exp(__e);
          _Tp __p = __e / (_Tp(2) * __gampl);
          _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
          _Tp __c = _Tp(1);
          __d = __x2 * __x2;
          _Tp __sum1 = __p;
          int __i;
          for (__i = 1; __i <= __max_iter; ++__i)
            {
              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
              __c *= __d / __i;
              __p /= __i - __mu;
              __q /= __i + __mu;
              const _Tp __del = __c * __ff;
              __sum += __del;
              const _Tp __del1 = __c * (__p - __i * __ff);
              __sum1 += __del1;
              if (std::abs(__del) < __eps * std::abs(__sum))
                break;
            }
          if (__i > __max_iter)
            std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.")
                                                             );
          __Kmu = __sum;
          __Knu1 = __sum1 * __xi2;
        }
      else
        {
          _Tp __b = _Tp(2) * (_Tp(1) + __x);
          _Tp __d = _Tp(1) / __b;
          _Tp __delh = __d;
          _Tp __h = __delh;
          _Tp __q1 = _Tp(0);
          _Tp __q2 = _Tp(1);
          _Tp __a1 = _Tp(0.25L) - __mu2;
          _Tp __q = __c = __a1;
          _Tp __a = -__a1;
          _Tp __s = _Tp(1) + __q * __delh;
          int __i;
          for (__i = 2; __i <= __max_iter; ++__i)
            {
              __a -= 2 * (__i - 1);
              __c = -__a * __c / __i;
              const _Tp __qnew = (__q1 - __b * __q2) / __a;
              __q1 = __q2;
              __q2 = __qnew;
              __q += __c * __qnew;
              __b += _Tp(2);
              __d = _Tp(1) / (__b + __a * __d);
              __delh = (__b * __d - _Tp(1)) * __delh;
              __h += __delh;
              const _Tp __dels = __q * __delh;
              __s += __dels;
              if ( std::abs(__dels / __s) < __eps )
                break;
            }
          if (__i > __max_iter)
            std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.")
                                                             );
          __h = __a1 * __h;
          __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
                * std::exp(-__x) / __s;
          __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
        }

      _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
      _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
      __Inu = __Inumu * __Inul1 / __Inul;
      __Ipnu = __Inumu * __Ipnu1 / __Inul;
      for ( __i = 1; __i <= __nl; ++__i )
        {
          const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
          __Kmu = __Knu1;
          __Knu1 = __Knutemp;
        }
      __Knu = __Kmu;
      __Kpnu = __nu * __xi * __Kmu - __Knu1;

      return;
    }
# 267 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_bessel_i(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.")
                                                           );
      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
        return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
      else
        {
          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          return __I_nu;
        }
    }
# 303 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_bessel_k(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.")
                                                           );
      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        {
          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          return __K_nu;
        }
    }
# 337 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3
    template <typename _Tp>
    void
    __sph_bessel_ik(unsigned int __n, _Tp __x,
                    _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
    {
      const _Tp __nu = _Tp(__n) + _Tp(0.5L);

      _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
      __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);

      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
                         / std::sqrt(__x);

      __i_n = __factor * __I_nu;
      __k_n = __factor * __K_nu;
      __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
      __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);

      return;
    }
# 373 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3
    template <typename _Tp>
    void
    __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
    {
      const _Tp __absx = std::abs(__x);
      const _Tp __rootx = std::sqrt(__absx);
      const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
      const _Tp _S_NaN = std::numeric_limits<_Tp>::quiet_NaN();
      const _Tp _S_inf = std::numeric_limits<_Tp>::infinity();

      if (__isnan(__x))
        __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN();
      else if (__z == _S_inf)
        {
   __Aip = __Ai = _Tp(0);
   __Bip = __Bi = _S_inf;
 }
      else if (__z == -_S_inf)
 __Bip = __Aip = __Bi = __Ai = _Tp(0);
      else if (__x > _Tp(0))
        {
          _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;

          __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          __Ai = __rootx * __K_nu
               / (__numeric_constants<_Tp>::__sqrt3()
                * __numeric_constants<_Tp>::__pi());
          __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
                 + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());

          __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          __Aip = -__x * __K_nu
                / (__numeric_constants<_Tp>::__sqrt3()
                 * __numeric_constants<_Tp>::__pi());
          __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
                      + _Tp(2) * __I_nu
                      / __numeric_constants<_Tp>::__sqrt3());
        }
      else if (__x < _Tp(0))
        {
          _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;

          __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          __Ai = __rootx * (__J_nu
                    - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
          __Bi = -__rootx * (__N_nu
                    + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);

          __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
                          + __J_nu) / _Tp(2);
          __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
                          - __N_nu) / _Tp(2);
        }
      else
        {



          __Ai = _Tp(0.35502805388781723926L);
          __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();




          __Aip = -_Tp(0.25881940379280679840L);
          __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
        }

      return;
    }
  }





}
# 57 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/poly_hermite.tcc" 1 3
# 42 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 56 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3
  namespace __detail
  {
# 72 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3
    template<typename _Tp>
    _Tp
    __poly_hermite_recursion(unsigned int __n, _Tp __x)
    {

      _Tp __H_0 = 1;
      if (__n == 0)
        return __H_0;


      _Tp __H_1 = 2 * __x;
      if (__n == 1)
        return __H_1;


      _Tp __H_n, __H_nm1, __H_nm2;
      unsigned int __i;
      for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
        {
          __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2);
          __H_nm2 = __H_nm1;
          __H_nm1 = __H_n;
        }

      return __H_n;
    }
# 114 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3
    template<typename _Tp>
    inline _Tp
    __poly_hermite(unsigned int __n, _Tp __x)
    {
      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __poly_hermite_recursion(__n, __x);
    }
  }





}
# 58 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 1 3
# 44 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 60 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3
  namespace __detail
  {
# 75 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x)
    {
      const _Tp __a = -_Tp(__n);
      const _Tp __b = _Tp(__alpha1) + _Tp(1);
      const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
      const _Tp __cos2th = __x / __eta;
      const _Tp __sin2th = _Tp(1) - __cos2th;
      const _Tp __th = std::acos(std::sqrt(__cos2th));
      const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
                        * __numeric_constants<_Tp>::__pi_2()
                        * __eta * __eta * __cos2th * __sin2th;


      const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b);
      const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1));





      _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
                      * std::log(_Tp(0.25L) * __x * __eta);
      _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
      _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
                      + __pre_term1 - __pre_term2;
      _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
      _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
                              * (_Tp(2) * __th
                               - std::sin(_Tp(2) * __th))
                               + __numeric_constants<_Tp>::__pi_4());
      _Tp __ser = __ser_term1 + __ser_term2;

      return std::exp(__lnpre) * __ser;
    }
# 129 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x)
    {
      const _Tp __b = _Tp(__alpha1) + _Tp(1);
      const _Tp __mx = -__x;
      const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
                         : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));

      _Tp __tc = _Tp(1);
      const _Tp __ax = std::abs(__x);
      for (unsigned int __k = 1; __k <= __n; ++__k)
        __tc *= (__ax / __k);

      _Tp __term = __tc * __tc_sgn;
      _Tp __sum = __term;
      for (int __k = int(__n) - 1; __k >= 0; --__k)
        {
          __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
                  * _Tp(__k + 1) / __mx;
          __sum += __term;
        }

      return __sum;
    }
# 185 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x)
    {

      _Tp __l_0 = _Tp(1);
      if (__n == 0)
        return __l_0;


      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
      if (__n == 1)
        return __l_1;


      _Tp __l_n2 = __l_0;
      _Tp __l_n1 = __l_1;
      _Tp __l_n = _Tp(0);
      for (unsigned int __nn = 2; __nn <= __n; ++__nn)
        {
            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
                  * __l_n1 / _Tp(__nn)
                  - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
            __l_n2 = __l_n1;
            __l_n1 = __l_n;
        }

      return __l_n;
    }
# 244 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x)
    {
      if (__x < _Tp(0))
        std::__throw_domain_error(("Negative argument " "in __poly_laguerre.")
                                                            );

      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__n == 0)
        return _Tp(1);
      else if (__n == 1)
        return _Tp(1) + _Tp(__alpha1) - __x;
      else if (__x == _Tp(0))
        {
          _Tp __prod = _Tp(__alpha1) + _Tp(1);
          for (unsigned int __k = 2; __k <= __n; ++__k)
            __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
          return __prod;
        }
      else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
            && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
        return __poly_laguerre_large_n(__n, __alpha1, __x);
      else if (_Tp(__alpha1) >= _Tp(0)
           || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
        return __poly_laguerre_recursion(__n, __alpha1, __x);
      else
        return __poly_laguerre_hyperg(__n, __alpha1, __x);
    }
# 296 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3
    template<typename _Tp>
    inline _Tp
    __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
    { return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x); }
# 316 "/usr/include/c++/10/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); }
  }






}
# 59 "/usr/include/c++/10/bits/specfun.h" 2 3
# 1 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 1 3
# 47 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 63 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
  namespace __detail
  {
# 78 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_sum(_Tp __s)
    {

      if (__s < _Tp(1))
        std::__throw_domain_error(("Bad argument in zeta sum."));

      const unsigned int max_iter = 10000;
      _Tp __zeta = _Tp(0);
      for (unsigned int __k = 1; __k < max_iter; ++__k)
        {
          _Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            {
              break;
            }
          __zeta += __term;
        }

      return __zeta;
    }
# 115 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_alt(_Tp __s)
    {
      _Tp __sgn = _Tp(1);
      _Tp __zeta = _Tp(0);
      for (unsigned int __i = 1; __i < 10000000; ++__i)
        {
          _Tp __term = __sgn / std::pow(__i, __s);
          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
            break;
          __zeta += __term;
          __sgn *= _Tp(-1);
        }
      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);

      return __zeta;
    }
# 157 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_glob(_Tp __s)
    {
      _Tp __zeta = _Tp(0);

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
                               * std::log(_Tp(10)) - _Tp(1);



      if (__s < _Tp(0))
        {

          if (::std::fmod(__s,_Tp(2)) == _Tp(0))
            return _Tp(0);
          else

            {
              _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
              __zeta *= std::pow(_Tp(2)
                     * __numeric_constants<_Tp>::__pi(), __s)
                     * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)

                     * std::exp(::std::lgamma(_Tp(1) - __s))



                     / __numeric_constants<_Tp>::__pi();
              return __zeta;
            }
        }

      _Tp __num = _Tp(0.5L);
      const unsigned int __maxit = 10000;
      for (unsigned int __i = 0; __i < __maxit; ++__i)
        {
          bool __punt = false;
          _Tp __sgn = _Tp(1);
          _Tp __term = _Tp(0);
          for (unsigned int __j = 0; __j <= __i; ++__j)
            {

              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
                              - ::std::lgamma(_Tp(1 + __j))
                              - ::std::lgamma(_Tp(1 + __i - __j));





              if (__bincoeff > __max_bincoeff)
                {

                  __punt = true;
                  break;
                }
              __bincoeff = std::exp(__bincoeff);
              __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
              __sgn *= _Tp(-1);
            }
          if (__punt)
            break;
          __term *= __num;
          __zeta += __term;
          if (std::abs(__term/__zeta) < __eps)
            break;
          __num *= _Tp(0.5L);
        }

      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);

      return __zeta;
    }
# 252 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_product(_Tp __s)
    {
      static const _Tp __prime[] = {
        _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
        _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
        _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
        _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
      };
      static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);

      _Tp __zeta = _Tp(1);
      for (unsigned int __i = 0; __i < __num_primes; ++__i)
        {
          const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
          __zeta *= __fact;
          if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
            break;
        }

      __zeta = _Tp(1) / __zeta;

      return __zeta;
    }
# 293 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta(_Tp __s)
    {
      if (__isnan(__s))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__s == _Tp(1))
        return std::numeric_limits<_Tp>::infinity();
      else if (__s < -_Tp(19))
        {
          _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
          __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
                 * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)

                 * std::exp(::std::lgamma(_Tp(1) - __s))



                 / __numeric_constants<_Tp>::__pi();
          return __zeta;
        }
      else if (__s < _Tp(20))
        {

          bool __glob = true;
          if (__glob)
            return __riemann_zeta_glob(__s);
          else
            {
              if (__s > _Tp(1))
                return __riemann_zeta_sum(__s);
              else
                {
                  _Tp __zeta = std::pow(_Tp(2)
                                * __numeric_constants<_Tp>::__pi(), __s)
                         * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)

                             * ::std::tgamma(_Tp(1) - __s)



                             * __riemann_zeta_sum(_Tp(1) - __s);
                  return __zeta;
                }
            }
        }
      else
        return __riemann_zeta_product(__s);
    }
# 365 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __hurwitz_zeta_glob(_Tp __a, _Tp __s)
    {
      _Tp __zeta = _Tp(0);

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
                               * std::log(_Tp(10)) - _Tp(1);

      const unsigned int __maxit = 10000;
      for (unsigned int __i = 0; __i < __maxit; ++__i)
        {
          bool __punt = false;
          _Tp __sgn = _Tp(1);
          _Tp __term = _Tp(0);
          for (unsigned int __j = 0; __j <= __i; ++__j)
            {

              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
                              - ::std::lgamma(_Tp(1 + __j))
                              - ::std::lgamma(_Tp(1 + __i - __j));





              if (__bincoeff > __max_bincoeff)
                {

                  __punt = true;
                  break;
                }
              __bincoeff = std::exp(__bincoeff);
              __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
              __sgn *= _Tp(-1);
            }
          if (__punt)
            break;
          __term /= _Tp(__i + 1);
          if (std::abs(__term / __zeta) < __eps)
            break;
          __zeta += __term;
        }

      __zeta /= __s - _Tp(1);

      return __zeta;
    }
# 430 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    inline _Tp
    __hurwitz_zeta(_Tp __a, _Tp __s)
    { return __hurwitz_zeta_glob(__a, __s); }
  }






}
# 60 "/usr/include/c++/10/bits/specfun.h" 2 3

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

# 205 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }







  inline long double
  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
  { return __detail::__assoc_laguerre<long double>(__n, __m, __x); }
# 250 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__assoc_laguerre<__type>(__n, __m, __x);
    }
# 266 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }






  inline long double
  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
# 296 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
    }
# 311 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  betaf(float __a, float __b)
  { return __detail::__beta<float>(__a, __b); }







  inline long double
  betal(long double __a, long double __b)
  { return __detail::__beta<long double>(__a, __b); }
# 341 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tpa, typename _Tpb>
    inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type
    beta(_Tpa __a, _Tpb __b)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type;
      return __detail::__beta<__type>(__a, __b);
    }
# 357 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  comp_ellint_1f(float __k)
  { return __detail::__comp_ellint_1<float>(__k); }







  inline long double
  comp_ellint_1l(long double __k)
  { return __detail::__comp_ellint_1<long double>(__k); }
# 389 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    comp_ellint_1(_Tp __k)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__comp_ellint_1<__type>(__k);
    }
# 405 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  comp_ellint_2f(float __k)
  { return __detail::__comp_ellint_2<float>(__k); }







  inline long double
  comp_ellint_2l(long double __k)
  { return __detail::__comp_ellint_2<long double>(__k); }
# 436 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    comp_ellint_2(_Tp __k)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__comp_ellint_2<__type>(__k);
    }
# 452 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  comp_ellint_3f(float __k, float __nu)
  { return __detail::__comp_ellint_3<float>(__k, __nu); }







  inline long double
  comp_ellint_3l(long double __k, long double __nu)
  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
# 487 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp, typename _Tpn>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
    comp_ellint_3(_Tp __k, _Tpn __nu)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
      return __detail::__comp_ellint_3<__type>(__k, __nu);
    }
# 503 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  cyl_bessel_if(float __nu, float __x)
  { return __detail::__cyl_bessel_i<float>(__nu, __x); }







  inline long double
  cyl_bessel_il(long double __nu, long double __x)
  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
# 533 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_i(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_i<__type>(__nu, __x);
    }
# 549 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  cyl_bessel_jf(float __nu, float __x)
  { return __detail::__cyl_bessel_j<float>(__nu, __x); }







  inline long double
  cyl_bessel_jl(long double __nu, long double __x)
  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
# 579 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_j(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_j<__type>(__nu, __x);
    }
# 595 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  cyl_bessel_kf(float __nu, float __x)
  { return __detail::__cyl_bessel_k<float>(__nu, __x); }







  inline long double
  cyl_bessel_kl(long double __nu, long double __x)
  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
# 631 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_k(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_k<__type>(__nu, __x);
    }
# 647 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  cyl_neumannf(float __nu, float __x)
  { return __detail::__cyl_neumann_n<float>(__nu, __x); }







  inline long double
  cyl_neumannl(long double __nu, long double __x)
  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
# 679 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_neumann(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_neumann_n<__type>(__nu, __x);
    }
# 695 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  ellint_1f(float __k, float __phi)
  { return __detail::__ellint_1<float>(__k, __phi); }







  inline long double
  ellint_1l(long double __k, long double __phi)
  { return __detail::__ellint_1<long double>(__k, __phi); }
# 727 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp, typename _Tpp>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
    ellint_1(_Tp __k, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
      return __detail::__ellint_1<__type>(__k, __phi);
    }
# 743 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  ellint_2f(float __k, float __phi)
  { return __detail::__ellint_2<float>(__k, __phi); }







  inline long double
  ellint_2l(long double __k, long double __phi)
  { return __detail::__ellint_2<long double>(__k, __phi); }
# 775 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp, typename _Tpp>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
    ellint_2(_Tp __k, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
      return __detail::__ellint_2<__type>(__k, __phi);
    }
# 791 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  ellint_3f(float __k, float __nu, float __phi)
  { return __detail::__ellint_3<float>(__k, __nu, __phi); }







  inline long double
  ellint_3l(long double __k, long double __nu, long double __phi)
  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
# 828 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp, typename _Tpn, typename _Tpp>
    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
    ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
      return __detail::__ellint_3<__type>(__k, __nu, __phi);
    }
# 843 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  expintf(float __x)
  { return __detail::__expint<float>(__x); }







  inline long double
  expintl(long double __x)
  { return __detail::__expint<long double>(__x); }
# 868 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    expint(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__expint<__type>(__x);
    }
# 884 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  hermitef(unsigned int __n, float __x)
  { return __detail::__poly_hermite<float>(__n, __x); }







  inline long double
  hermitel(unsigned int __n, long double __x)
  { return __detail::__poly_hermite<long double>(__n, __x); }
# 916 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    hermite(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__poly_hermite<__type>(__n, __x);
    }
# 932 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  laguerref(unsigned int __n, float __x)
  { return __detail::__laguerre<float>(__n, __x); }







  inline long double
  laguerrel(unsigned int __n, long double __x)
  { return __detail::__laguerre<long double>(__n, __x); }
# 960 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    laguerre(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__laguerre<__type>(__n, __x);
    }
# 976 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  legendref(unsigned int __l, float __x)
  { return __detail::__poly_legendre_p<float>(__l, __x); }







  inline long double
  legendrel(unsigned int __l, long double __x)
  { return __detail::__poly_legendre_p<long double>(__l, __x); }
# 1005 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    legendre(unsigned int __l, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__poly_legendre_p<__type>(__l, __x);
    }
# 1021 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  riemann_zetaf(float __s)
  { return __detail::__riemann_zeta<float>(__s); }







  inline long double
  riemann_zetal(long double __s)
  { return __detail::__riemann_zeta<long double>(__s); }
# 1056 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    riemann_zeta(_Tp __s)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__riemann_zeta<__type>(__s);
    }
# 1072 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  sph_besself(unsigned int __n, float __x)
  { return __detail::__sph_bessel<float>(__n, __x); }







  inline long double
  sph_bessell(unsigned int __n, long double __x)
  { return __detail::__sph_bessel<long double>(__n, __x); }
# 1100 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_bessel(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_bessel<__type>(__n, __x);
    }
# 1116 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
# 1127 "/usr/include/c++/10/bits/specfun.h" 3
  inline long double
  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
# 1147 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_legendre<__type>(__l, __m, __theta);
    }
# 1163 "/usr/include/c++/10/bits/specfun.h" 3
  inline float
  sph_neumannf(unsigned int __n, float __x)
  { return __detail::__sph_neumann<float>(__n, __x); }







  inline long double
  sph_neumannl(unsigned int __n, long double __x)
  { return __detail::__sph_neumann<long double>(__n, __x); }
# 1191 "/usr/include/c++/10/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_neumann(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_neumann<__type>(__n, __x);
    }




}
# 1388 "/usr/include/c++/10/bits/specfun.h" 3
#pragma GCC visibility pop
# 1928 "/usr/include/c++/10/cmath" 2 3


}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/no_tr1/cmath.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/float_functions.hpp" 2 3 4
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/float_functions.hpp" 3 4
namespace boost {
    namespace hash_detail {
        template <typename Float>
        struct call_ldexp {
            typedef Float float_type;
            inline Float operator()(Float x, int y) const {
                return std::ldexp(x, y);
            }
        };

        template <typename Float>
        struct call_frexp {
            typedef Float float_type;
            inline Float operator()(Float x, int* y) const {
                return std::frexp(x, y);
            }
        };

        template <typename Float>
        struct select_hash_type
        {
            typedef Float type;
        };
    }
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/limits.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/limits.hpp" 3 4
       
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/limits.hpp" 3 4
namespace boost
{
    namespace hash_detail
    {
        template <class T>
        struct limits : std::numeric_limits<T> {};
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/limits.hpp" 3 4
    }
}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/static_log2.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/static_log2.hpp" 3 4
namespace boost {

 namespace detail {

     namespace static_log2_impl {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/static_log2.hpp" 3 4
     typedef boost::static_log2_argument_type argument_type;
     typedef boost::static_log2_result_type result_type;

     template <result_type n>
     struct choose_initial_n {

         static const bool c = (argument_type(1) << n << n) != 0;
         static const result_type value = !c*n + choose_initial_n<2*c*n>::value


          ;

     };

     template <>
     struct choose_initial_n<0> {
         static const result_type value = 0;
     };




     const result_type n_zero = 16;
     const result_type initial_n = choose_initial_n<n_zero>::value;
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/static_log2.hpp" 3 4
     template <argument_type x, result_type n = initial_n>
     struct static_log2_impl {

         static const bool c = (x >> n) > 0;
         static const result_type value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)


          ;

     };

     template <>
     struct static_log2_impl<1, 0> {
        static const result_type value = 0;
     };

     }
 }







 template <static_log2_argument_type x>
 struct static_log2 {

     static const static_log2_result_type value = detail::static_log2_impl::static_log2_impl<x>::value


      ;

 };


 template <>
 struct static_log2<0> { };

}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 2 3 4

# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/detail/hash_float.hpp" 3 4
namespace boost
{
    namespace hash_detail
    {
        inline void hash_float_combine(std::size_t& seed, std::size_t value)
        {
            seed ^= value + (seed<<6) + (seed>>2);
        }







        inline std::size_t hash_binary(char* ptr, std::size_t length)
        {
            std::size_t seed = 0;

            if (length >= sizeof(std::size_t)) {
                std::memcpy(&seed, ptr, sizeof(std::size_t));
                length -= sizeof(std::size_t);
                ptr += sizeof(std::size_t);

                while(length >= sizeof(std::size_t)) {
                    std::size_t buffer = 0;
                    std::memcpy(&buffer, ptr, sizeof(std::size_t));
                    hash_float_combine(seed, buffer);
                    length -= sizeof(std::size_t);
                    ptr += sizeof(std::size_t);
                }
            }

            if (length > 0) {
                std::size_t buffer = 0;
                std::memcpy(&buffer, ptr, length);
                hash_float_combine(seed, buffer);
            }

            return seed;
        }

        template <typename Float, unsigned digits, unsigned max_exponent>
        struct enable_binary_hash
        {
            static const bool value = std::numeric_limits<Float>::is_iec559 && std::numeric_limits<Float>::digits == digits && std::numeric_limits<Float>::radix == 2 && std::numeric_limits<Float>::max_exponent == max_exponent



                                                                         ;
        };

        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                enable_binary_hash<Float, 24, 128>::value,
                std::size_t>::type)
        {
            return hash_binary((char*) &v, 4);
        }


        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                enable_binary_hash<Float, 53, 1024>::value,
                std::size_t>::type)
        {
            return hash_binary((char*) &v, 8);
        }

        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                enable_binary_hash<Float, 64, 16384>::value,
                std::size_t>::type)
        {
            return hash_binary((char*) &v, 10);
        }

        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                enable_binary_hash<Float, 113, 16384>::value,
                std::size_t>::type)
        {
            return hash_binary((char*) &v, 16);
        }






        template <class T>
        inline std::size_t float_hash_impl2(T v)
        {
            boost::hash_detail::call_frexp<T> frexp;
            boost::hash_detail::call_ldexp<T> ldexp;

            int exp = 0;

            v = frexp(v, &exp);



            if(v < 0) {
                v = -v;
                exp += limits<T>::max_exponent -
                    limits<T>::min_exponent;
            }

            v = ldexp(v, limits<std::size_t>::digits);
            std::size_t seed = static_cast<std::size_t>(v);
            v -= static_cast<T>(seed);


            std::size_t const length
                = (limits<T>::digits *
                        boost::static_log2<limits<T>::radix>::value
                        + limits<std::size_t>::digits - 1)
                / limits<std::size_t>::digits;

            for(std::size_t i = 0; i != length; ++i)
            {
                v = ldexp(v, limits<std::size_t>::digits);
                std::size_t part = static_cast<std::size_t>(v);
                v -= static_cast<T>(part);
                hash_float_combine(seed, part);
            }

            hash_float_combine(seed, static_cast<std::size_t>(exp));

            return seed;
        }


        template <class T>
        inline std::size_t float_hash_impl(T v, ...)
        {
            typedef typename select_hash_type<T>::type type;
            return float_hash_impl2(static_cast<type>(v));
        }

    }
}





namespace boost
{
    namespace hash_detail
    {
        template <class T>
        inline std::size_t float_hash_value(T v)
        {



            switch (std::fpclassify(v))




            {
            case 2:
                return 0;
            case 1:
                return (std::size_t)(v > 0 ? -1 : -2);
            case 0:
                return (std::size_t)(-3);
            case 4:
            case 3:
                return float_hash_impl(v, 0);
            default:
                (static_cast<void> (0));
                return 0;
            }
        }
    }
}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 2 3 4






# 1 "/usr/include/c++/10/typeindex" 1 3 4
# 32 "/usr/include/c++/10/typeindex" 3 4
       
# 33 "/usr/include/c++/10/typeindex" 3







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

# 52 "/usr/include/c++/10/typeindex" 3
  struct type_index
  {
    type_index(const type_info& __rhs) noexcept
    : _M_target(&__rhs) { }

    bool
    operator==(const type_index& __rhs) const noexcept
    { return *_M_target == *__rhs._M_target; }

    bool
    operator!=(const type_index& __rhs) const noexcept
    { return *_M_target != *__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); }

    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(); }
    };


}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 2 3 4
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
# 1 "/usr/include/c++/10/variant" 1 3 4
# 32 "/usr/include/c++/10/variant" 3 4
       
# 33 "/usr/include/c++/10/variant" 3
# 44 "/usr/include/c++/10/variant" 3
# 1 "/usr/include/c++/10/bits/parse_numbers.h" 1 3
# 33 "/usr/include/c++/10/bits/parse_numbers.h" 3
       
# 34 "/usr/include/c++/10/bits/parse_numbers.h" 3







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


namespace __parse_int
{
  template<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 <= std::numeric_limits<_IntType>::max()),
      integral_constant<_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;

}


}
# 45 "/usr/include/c++/10/variant" 2 3




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


namespace __detail
{
namespace __variant
{
  template<size_t _Np, typename... _Types>
    struct _Nth_type;

  template<size_t _Np, typename _First, typename... _Rest>
    struct _Nth_type<_Np, _First, _Rest...>
    : _Nth_type<_Np-1, _Rest...> { };

  template<typename _First, typename... _Rest>
    struct _Nth_type<0, _First, _Rest...>
    { using type = _First; };

}
}



  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<size_t _Np, typename _Variant>
    struct variant_alternative;

  template<size_t _Np, typename _First, typename... _Rest>
    struct variant_alternative<_Np, variant<_First, _Rest...>>
    : variant_alternative<_Np-1, variant<_Rest...>> {};

  template<typename _First, typename... _Rest>
    struct variant_alternative<0, variant<_First, _Rest...>>
    { using type = _First; };

  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 = add_const_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, volatile _Variant>
    { using type = add_volatile_t<variant_alternative_t<_Np, _Variant>>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const volatile _Variant>
    { using type = add_cv_t<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>
    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
{


  template<typename _Tp, typename... _Types>
    struct __index_of : std::integral_constant<size_t, 0> {};

  template<typename _Tp, typename... _Types>
    inline constexpr size_t __index_of_v = __index_of<_Tp, _Types...>::value;

  template<typename _Tp, typename _First, typename... _Rest>
    struct __index_of<_Tp, _First, _Rest...> :
      std::integral_constant<size_t, is_same_v<_Tp, _First>
 ? 0 : __index_of_v<_Tp, _Rest...> + 1> {};


  struct __variant_cookie {};

  struct __variant_idx_cookie { using type = __variant_idx_cookie; };

  template<typename> struct __deduce_visit_result { };


  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)...);
    }
# 210 "/usr/include/c++/10/variant" 3
  template<typename _Type, bool = std::is_literal_type_v<_Type>>
    struct _Uninitialized;

  template<typename _Type>
    struct _Uninitialized<_Type, true>
    {
      template<typename... _Args>
 constexpr
 _Uninitialized(in_place_index_t<0>, _Args&&... __args)
 : _M_storage(std::forward<_Args>(__args)...)
 { }

      constexpr const _Type& _M_get() const & noexcept
      { return _M_storage; }

      constexpr _Type& _M_get() & noexcept
      { return _M_storage; }

      constexpr const _Type&& _M_get() const && noexcept
      { return std::move(_M_storage); }

      constexpr _Type&& _M_get() && noexcept
      { return std::move(_M_storage); }

      _Type _M_storage;
    };

  template<typename _Type>
    struct _Uninitialized<_Type, false>
    {
      template<typename... _Args>
 constexpr
 _Uninitialized(in_place_index_t<0>, _Args&&... __args)
 {
   ::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<typename _Union>
    constexpr decltype(auto)
    __get(in_place_index_t<0>, _Union&& __u) noexcept
    { return std::forward<_Union>(__u)._M_first._M_get(); }

  template<size_t _Np, typename _Union>
    constexpr decltype(auto)
    __get(in_place_index_t<_Np>, _Union&& __u) noexcept
    {
      return __variant::__get(in_place_index<_Np-1>,
         std::forward<_Union>(__u)._M_rest);
    }


  template<size_t _Np, typename _Variant>
    constexpr decltype(auto)
    __get(_Variant&& __v) noexcept
    {
      return __variant::__get(std::in_place_index<_Np>,
         std::forward<_Variant>(__v)._M_u);
    }

  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<typename... _Types>
    union _Variadic_union { };

  template<typename _First, typename... _Rest>
    union _Variadic_union<_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)...)
 { }

      _Uninitialized<_First> _M_first;
      _Variadic_union<_Rest...> _M_rest;
    };






  template<typename _Tp>
    struct _Never_valueless_alt
    : __and_<bool_constant<sizeof(_Tp) <= 256>, is_trivially_copyable<_Tp>>
    { };
# 371 "/usr/include/c++/10/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(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)
 { }

      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 = variant_npos;
      }

      ~_Variant_storage()
      { _M_reset(); }

      void*
      _M_storage() const noexcept
      {
 return const_cast<void*>(static_cast<const void*>(
     std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
 if constexpr (__variant::__never_valueless<_Types...>())
   return true;
 return this->_M_index != __index_type(variant_npos);
      }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  template<typename... _Types>
    struct _Variant_storage<true, _Types...>
    {
      constexpr _Variant_storage() : _M_index(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)
 { }

      void _M_reset() noexcept
      { _M_index = variant_npos; }

      void*
      _M_storage() const noexcept
      {
 return const_cast<void*>(static_cast<const void*>(
     std::addressof(_M_u)));
      }

      constexpr bool
      _M_valid() const noexcept
      {
 if constexpr (__variant::__never_valueless<_Types...>())
   return true;
 return this->_M_index != __index_type(variant_npos);
      }

      _Variadic_union<_Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  template<typename... _Types>
    using _Variant_storage_alias =
 _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;

  template<typename _Tp, typename _Up>
    void __variant_construct_single(_Tp&& __lhs, _Up&& __rhs_mem)
    {
      void* __storage = std::addressof(__lhs._M_u);
      using _Type = remove_reference_t<decltype(__rhs_mem)>;
      if constexpr (!is_same_v<_Type, __variant_cookie>)
        ::new (__storage)
   _Type(std::forward<decltype(__rhs_mem)>(__rhs_mem));
    }

  template<typename... _Types, typename _Tp, typename _Up>
    void __variant_construct(_Tp&& __lhs, _Up&& __rhs)
    {
      __lhs._M_index = __rhs._M_index;
      __variant::__raw_visit([&__lhs](auto&& __rhs_mem) mutable
        {
   __variant_construct_single(std::forward<_Tp>(__lhs),
       std::forward<decltype(__rhs_mem)>(__rhs_mem));
 }, __variant_cast<_Types...>(std::forward<_Up>(__rhs)));
    }




  template<bool, typename... _Types>
    struct _Copy_ctor_base : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;

      _Copy_ctor_base(const _Copy_ctor_base& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
      {
 __variant_construct<_Types...>(*this, __rhs);
      }

      _Copy_ctor_base(_Copy_ctor_base&&) = default;
      _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default;
      _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default;
    };

  template<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;

      _Move_ctor_base(_Move_ctor_base&& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
      {
 __variant_construct<_Types...>(*this, std::move(__rhs));
      }

      template<typename _Up>
        void _M_destructive_move(unsigned short __rhs_index, _Up&& __rhs)
        {
   this->_M_reset();
   __variant_construct_single(*this, std::forward<_Up>(__rhs));
   this->_M_index = __rhs_index;
 }

      template<typename _Up>
        void _M_destructive_copy(unsigned short __rhs_index, const _Up& __rhs)
        {
   this->_M_reset();
   __variant_construct_single(*this, __rhs);
   this->_M_index = __rhs_index;
 }

      _Move_ctor_base(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(_Move_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      template<typename _Up>
        void _M_destructive_move(unsigned short __rhs_index, _Up&& __rhs)
        {
   this->_M_reset();
   __variant_construct_single(*this, std::forward<_Up>(__rhs));
   this->_M_index = __rhs_index;
 }

      template<typename _Up>
        void _M_destructive_copy(unsigned short __rhs_index, const _Up& __rhs)
        {
   this->_M_reset();
   __variant_construct_single(*this, __rhs);
   this->_M_index = __rhs_index;
 }
    };

  template<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;

      _Copy_assign_base&
      operator=(const _Copy_assign_base& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
      {
 __variant::__raw_idx_visit(
   [this](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     if constexpr (__rhs_index != variant_npos)
       {
  if (this->_M_index == __rhs_index)
    __variant::__get<__rhs_index>(*this) = __rhs_mem;
  else
    {
      using __rhs_type = __remove_cvref_t<decltype(__rhs_mem)>;
      if constexpr (is_nothrow_copy_constructible_v<__rhs_type>
   || !is_nothrow_move_constructible_v<__rhs_type>)







        this->_M_destructive_copy(__rhs_index, __rhs_mem);
      else
        __variant_cast<_Types...>(*this)
   = variant<_Types...>(__rhs_mem);
    }
       }
     else
       this->_M_reset();
   }, __variant_cast<_Types...>(__rhs));
 return *this;
      }

      _Copy_assign_base(const _Copy_assign_base&) = default;
      _Copy_assign_base(_Copy_assign_base&&) = default;
      _Copy_assign_base& operator=(_Copy_assign_base&&) = default;
    };

  template<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;

      _Move_assign_base&
      operator=(_Move_assign_base&& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
      {
 __variant::__raw_idx_visit(
   [this](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     if constexpr (__rhs_index != variant_npos)
       {
  if (this->_M_index == __rhs_index)
    __variant::__get<__rhs_index>(*this) = std::move(__rhs_mem);
  else
    __variant_cast<_Types...>(*this)
      .template emplace<__rhs_index>(std::move(__rhs_mem));
       }
     else
       this->_M_reset();
   }, __variant_cast<_Types...>(__rhs));
 return *this;
      }

      _Move_assign_base(const _Move_assign_base&) = default;
      _Move_assign_base(_Move_assign_base&&) = default;
      _Move_assign_base& operator=(const _Move_assign_base&) = default;
    };

  template<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 _Tuple>
    struct __tuple_count;

  template<typename _Tp, typename _Tuple>
    inline constexpr size_t __tuple_count_v =
      __tuple_count<_Tp, _Tuple>::value;

  template<typename _Tp, typename... _Types>
    struct __tuple_count<_Tp, tuple<_Types...>>
    : integral_constant<size_t, 0> { };

  template<typename _Tp, typename _First, typename... _Rest>
    struct __tuple_count<_Tp, tuple<_First, _Rest...>>
    : integral_constant<
 size_t,
 __tuple_count_v<_Tp, tuple<_Rest...>> + is_same_v<_Tp, _First>> { };


  template<typename _Tp, typename... _Types>
    inline constexpr bool __exactly_once =
      __tuple_count_v<_Tp, tuple<_Types...>> == 1;


  template<typename _Ti> struct _Arr { _Ti _M_x[1]; };


  template<size_t _Ind, typename _Tp, typename _Ti,
    bool _Ti_is_cv_bool = is_same_v<remove_cv_t<_Ti>, bool>,
    typename = void>
    struct _Build_FUN
    {


      void _S_fun();
    };


  template<size_t _Ind, typename _Tp, typename _Ti>
    struct _Build_FUN<_Ind, _Tp, _Ti, false,
        void_t<decltype(_Arr<_Ti>{{std::declval<_Tp>()}})>>
    {

      static integral_constant<size_t, _Ind> _S_fun(_Ti);
    };


  template<size_t _Ind, typename _Tp, typename _Ti>
    struct _Build_FUN<_Ind, _Tp, _Ti, true,
        enable_if_t<is_same_v<__remove_cvref_t<_Tp>, bool>>>
    {

      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>
    struct __accepted_index
    : integral_constant<size_t, variant_npos>
    { };

  template<typename _Tp, typename _Variant>
    struct __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>>
    : _FUN_type<_Tp, _Variant>
    { };


  template<typename _Variant>
    void* __get_storage(_Variant&& __v) noexcept
    { return __v._M_storage(); }

  template <typename _Maybe_variant_cookie, typename _Variant>
    struct _Extra_visit_slot_needed
    {
      template <typename> struct _Variant_never_valueless;

      template <typename... _Types>
 struct _Variant_never_valueless<variant<_Types...>>
 : bool_constant<__variant::__never_valueless<_Types...>()> {};

      static constexpr bool value =
 (is_same_v<_Maybe_variant_cookie, __variant_cookie>
  || is_same_v<_Maybe_variant_cookie, __variant_idx_cookie>)
 && !_Variant_never_valueless<__remove_cvref_t<_Variant>>::value;
    };


  template<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; };

      template <typename... _Args>
 struct __untag_result<const void(*)(_Args...)>
 : false_type
 { using element_type = void(*)(_Args...); };

      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>::value ? 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];
    };
# 907 "/usr/include/c++/10/variant" 3
  template<typename _Array_type, typename _Index_seq>
    struct __gen_vtable_impl;
# 917 "/usr/include/c++/10/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>::value)
     (_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
     {
       __element = __gen_vtable_impl<
  remove_reference_t<decltype(__element)>,
  std::index_sequence<__indices..., __index>>::_S_apply();
     }
 }
    };




  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()
      { 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... _Args>
    void __variant_construct_by_index(_Variant& __v, _Args&&... __args)
    {
      __v._M_index = _Np;
      auto&& __storage = __detail::__variant::__get<_Np>(__v);
      ::new ((void*)std::addressof(__storage))
        remove_reference_t<decltype(__storage)>
   (std::forward<_Args>(__args)...);
    }

  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() == __detail::__variant::__index_of_v<_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");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__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");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
 std::move(__v));
    }

  template<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");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__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");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
      return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(
 std::move(__v));
    }

  template<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");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
   __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");
      return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>(
   __ptr);
    }

  struct monostate { };
# 1189 "/usr/include/c++/10/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; } constexpr bool operator <(monostate, monostate) noexcept { return 0 < 0; }
  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 0 <= 0; }
  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 0 == 0; }
  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 0 != 0; }
  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 0 >= 0; }
  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 0 > 0; }



  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto) visit(_Visitor&&, _Variants&&...);

  template<typename... _Types>
    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_default_constructor<
 __detail::__variant::_Traits<_Types...>::_S_default_ctor,
   variant<_Types...>>,
      private _Enable_copy_move<
 __detail::__variant::_Traits<_Types...>::_S_copy_ctor,
 __detail::__variant::_Traits<_Types...>::_S_copy_assign,
 __detail::__variant::_Traits<_Types...>::_S_move_ctor,
 __detail::__variant::_Traits<_Types...>::_S_move_assign,
 variant<_Types...>>
    {
    private:
      template <typename... _UTypes, typename _Tp>
 friend decltype(auto) __variant_cast(_Tp&&);
      template<size_t _Np, typename _Variant, typename... _Args>
 friend void __variant_construct_by_index(_Variant& __v,
       _Args&&... __args);

      static_assert(sizeof...(_Types) > 0,
      "variant must have at least one alternative");
      static_assert(!(std::is_reference_v<_Types> || ...),
      "variant must have no reference alternative");
      static_assert(!(std::is_void_v<_Types> || ...),
      "variant must have no void alternative");

      using _Base = __detail::__variant::_Variant_base<_Types...>;
      using _Default_ctor_enabler =
 _Enable_default_constructor<
   __detail::__variant::_Traits<_Types...>::_S_default_ctor,
     variant<_Types...>>;

      template<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>::value;

      template<size_t _Np, typename = enable_if_t<(_Np < sizeof...(_Types))>>
 using __to_type = variant_alternative_t<_Np, variant>;

      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 =
   __detail::__variant::__index_of_v<_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_tag<__remove_cvref_t<_Tp>>::value;

    public:
      variant() = default;
      variant(const variant& __rhs) = default;
      variant(variant&&) = default;
      variant& operator=(const variant&) = default;
      variant& operator=(variant&&) = default;
      ~variant() = default;

      template<typename _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)...),
 _Default_ctor_enabler(_Enable_default_constructor_tag{})
 { }

      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)...),
 _Default_ctor_enabler(_Enable_default_constructor_tag{})
 { }

      template<typename _Tp>
 enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
      && is_constructible_v<__accepted_type<_Tp&&>, _Tp>
      && is_assignable_v<__accepted_type<_Tp&&>&, _Tp>,
      variant&>
 operator=(_Tp&& __rhs)
 noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp>
   && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>)
 {
   constexpr auto __index = __accepted_index<_Tp>;
   if (index() == __index)
     std::get<__index>(*this) = std::forward<_Tp>(__rhs);
   else
     {
       using _Tj = __accepted_type<_Tp&&>;
       if constexpr (is_nothrow_constructible_v<_Tj, _Tp>
       || !is_nothrow_move_constructible_v<_Tj>)
  this->emplace<__index>(std::forward<_Tp>(__rhs));
       else
  operator=(variant(std::forward<_Tp>(__rhs)));
     }
   return *this;
 }

      template<typename _Tp, typename... _Args>
 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>
 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>
 enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
           _Args...>,
      variant_alternative_t<_Np, variant>&>
 emplace(_Args&&... __args)
 {
   static_assert(_Np < sizeof...(_Types),
   "The index must be in [0, number of alternatives)");
   using type = variant_alternative_t<_Np, variant>;


   if constexpr (is_nothrow_constructible_v<type, _Args...>)
     {
       this->_M_reset();
       __variant_construct_by_index<_Np>(*this,
    std::forward<_Args>(__args)...);
     }
   else if constexpr (is_scalar_v<type>)
     {

       const type __tmp(std::forward<_Args>(__args)...);

       this->_M_reset();
       __variant_construct_by_index<_Np>(*this, __tmp);
     }
   else if constexpr (__detail::__variant::_Never_valueless_alt<type>()
       && _Traits::_S_move_assign)
     {

       variant __tmp(in_place_index<_Np>,
       std::forward<_Args>(__args)...);

       *this = std::move(__tmp);
     }
   else
     {


       this->_M_reset();
       try
  {
    __variant_construct_by_index<_Np>(*this,
      std::forward<_Args>(__args)...);
  }
       catch(...)
  {
    this->_M_index = variant_npos;
    throw;
  }
     }
   return std::get<_Np>(*this);
 }

      template<size_t _Np, typename _Up, typename... _Args>
 enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
           initializer_list<_Up>&, _Args...>,
      variant_alternative_t<_Np, variant>&>
 emplace(initializer_list<_Up> __il, _Args&&... __args)
 {
   static_assert(_Np < sizeof...(_Types),
   "The index must be in [0, number of alternatives)");
   using type = variant_alternative_t<_Np, variant>;


   if constexpr (is_nothrow_constructible_v<type,
         initializer_list<_Up>&,
         _Args...>)
     {
       this->_M_reset();
       __variant_construct_by_index<_Np>(*this, __il,
    std::forward<_Args>(__args)...);
     }
   else if constexpr (__detail::__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
     {


       this->_M_reset();
       try
  {
    __variant_construct_by_index<_Np>(*this, __il,
      std::forward<_Args>(__args)...);
  }
       catch(...)
  {
    this->_M_index = variant_npos;
    throw;
  }
     }
   return std::get<_Np>(*this);
 }

      constexpr bool valueless_by_exception() const noexcept
      { return !this->_M_valid(); }

      constexpr size_t index() const noexcept
      {
 using __index_type = typename _Base::__index_type;
 if constexpr (__detail::__variant::__never_valueless<_Types...>())
   return this->_M_index;
 else if constexpr (sizeof...(_Types) <= __index_type(-1) / 2)
   return make_signed_t<__index_type>(this->_M_index);
 else
   return size_t(__index_type(this->_M_index + 1)) - 1;
      }

      void
      swap(variant& __rhs)
      noexcept((__is_nothrow_swappable<_Types>::value && ...)
        && is_nothrow_move_constructible_v<variant>)
      {
 __detail::__variant::__raw_idx_visit(
   [this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     if constexpr (__rhs_index != variant_npos)
       {
  if (this->index() == __rhs_index)
    {
      auto& __this_mem =
        std::get<__rhs_index>(*this);
      using std::swap;
      swap(__this_mem, __rhs_mem);
    }
  else
    {
      if (!this->valueless_by_exception()) [[__likely__]]
        {
   auto __tmp(std::move(__rhs_mem));
   __rhs = std::move(*this);
   this->_M_destructive_move(__rhs_index,
        std::move(__tmp));
        }
      else
        {
   this->_M_destructive_move(__rhs_index,
        std::move(__rhs_mem));
   __rhs._M_reset();
        }
    }
       }
     else
       {
  if (!this->valueless_by_exception()) [[__likely__]]
    {
      __rhs = std::move(*this);
      this->_M_reset();
    }
       }
   }, __rhs);
      }

    private:







      template<size_t _Np, typename _Vp>
 friend constexpr decltype(auto)
 __detail::__variant::__get(_Vp&& __v) noexcept;

      template<typename _Vp>
 friend void*
 __detail::__variant::__get_storage(_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)
    {
      constexpr auto& __vtable = __detail::__variant::__gen_vtable<
 _Result_type, _Visitor&&, _Variants&&...>::_S_vtable;

      auto __func_ptr = __vtable._M_access(__variants.index()...);
      return (*__func_ptr)(std::forward<_Visitor>(__visitor),
      std::forward<_Variants>(__variants)...);
    }

  template<typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      if ((__variants.valueless_by_exception() || ...))
 __throw_bad_variant_access("std::visit: variant is valueless");

      using _Result_type = std::invoke_result_t<_Visitor,
 decltype(std::get<0>(std::declval<_Variants>()))...>;

      using _Tag = __detail::__variant::__deduce_visit_result<_Result_type>;

      return std::__do_visit<_Tag>(std::forward<_Visitor>(__visitor),
       std::forward<_Variants>(__variants)...);
    }
# 1693 "/usr/include/c++/10/variant" 3
  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 && ...)>
    { };


}
# 115 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 2 3 4


namespace boost
{
    namespace hash_detail
    {
# 129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
        template <typename T>
        struct hash_base : std::unary_function<T, std::size_t> {};


        struct enable_hash_value { typedef std::size_t type; };

        template <typename T> struct basic_numbers {};
        template <typename T> struct long_numbers;
        template <typename T> struct ulong_numbers;
        template <typename T> struct float_numbers {};

        template <> struct basic_numbers<bool> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<char> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned char> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<signed char> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<short> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned short> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<int> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned int> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<long> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned long> :
            boost::hash_detail::enable_hash_value {};


        template <> struct basic_numbers<wchar_t> :
            boost::hash_detail::enable_hash_value {};



        template <> struct basic_numbers<char16_t> :
            boost::hash_detail::enable_hash_value {};



        template <> struct basic_numbers<char32_t> :
            boost::hash_detail::enable_hash_value {};





        template <typename T> struct long_numbers2 {};
        template <typename T> struct ulong_numbers2 {};
        template <typename T> struct long_numbers : long_numbers2<T> {};
        template <typename T> struct ulong_numbers : ulong_numbers2<T> {};


        template <> struct long_numbers<boost::long_long_type> :
            boost::hash_detail::enable_hash_value {};
        template <> struct ulong_numbers<boost::ulong_long_type> :
            boost::hash_detail::enable_hash_value {};



        template <> struct long_numbers2<boost::int128_type> :
            boost::hash_detail::enable_hash_value {};
        template <> struct ulong_numbers2<boost::uint128_type> :
            boost::hash_detail::enable_hash_value {};


        template <> struct float_numbers<float> :
            boost::hash_detail::enable_hash_value {};
        template <> struct float_numbers<double> :
            boost::hash_detail::enable_hash_value {};
        template <> struct float_numbers<long double> :
            boost::hash_detail::enable_hash_value {};
    }

    template <typename T>
    typename boost::hash_detail::basic_numbers<T>::type hash_value(T);
    template <typename T>
    typename boost::hash_detail::long_numbers<T>::type hash_value(T);
    template <typename T>
    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);

    template <typename T>
    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
        hash_value(T);


    template <class T> std::size_t hash_value(T* const&);





    template< class T, unsigned N >
    std::size_t hash_value(const T (&x)[N]);

    template< class T, unsigned N >
    std::size_t hash_value(T (&x)[N]);


    template <class Ch, class A>
    std::size_t hash_value(
        std::basic_string<Ch, std::char_traits<Ch>, A> const&);


    template <class Ch>
    std::size_t hash_value(
        std::basic_string_view<Ch, std::char_traits<Ch> > const&);


    template <typename T>
    typename boost::hash_detail::float_numbers<T>::type hash_value(T);


    template <typename T>
    std::size_t hash_value(std::optional<T> const&);



    std::size_t hash_value(std::monostate);
    template <typename... Types>
    std::size_t hash_value(std::variant<Types...> const&);



    std::size_t hash_value(std::type_index);



    std::size_t hash_value(std::error_code const&);
    std::size_t hash_value(std::error_condition const&);




    namespace hash_detail
    {
        template <class T>
        inline std::size_t hash_value_signed(T val)
        {
             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;

             const int length = (std::numeric_limits<T>::digits - 1)
                 / static_cast<int>(size_t_bits);

             std::size_t seed = 0;
             T positive = val < 0 ? -1 - val : val;


             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
             {
                 seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2);
             }
             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);

             return seed;
        }

        template <class T>
        inline std::size_t hash_value_unsigned(T val)
        {
             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;

             const int length = (std::numeric_limits<T>::digits - 1)
                 / static_cast<int>(size_t_bits);

             std::size_t seed = 0;


             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
             {
                 seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2);
             }
             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);

             return seed;
        }

        template <typename SizeT>
        inline void hash_combine_impl(SizeT& seed, SizeT value)
        {
            seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
        }

        inline void hash_combine_impl(boost::uint32_t& h1,
                boost::uint32_t k1)
        {
            const uint32_t c1 = 0xcc9e2d51;
            const uint32_t c2 = 0x1b873593;

            k1 *= c1;
            k1 = (k1 << 15) | (k1 >> (32 - 15));
            k1 *= c2;

            h1 ^= k1;
            h1 = (h1 << 13) | (h1 >> (32 - 13));
            h1 = h1*5+0xe6546b64;
        }







        inline void hash_combine_impl(boost::uint64_t& h,
                boost::uint64_t k)
        {
            const boost::uint64_t m = 0xc6a4a7935bd1e995UL;
            const int r = 47;

            k *= m;
            k ^= k >> r;
            k *= m;

            h ^= k;
            h *= m;



            h += 0xe6546b64;
        }


    }

    template <typename T>
    typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
    {
        return static_cast<std::size_t>(v);
    }

    template <typename T>
    typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
    {
        return hash_detail::hash_value_signed(v);
    }

    template <typename T>
    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
    {
        return hash_detail::hash_value_unsigned(v);
    }

    template <typename T>
    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
        hash_value(T v)
    {
        return static_cast<std::size_t>(v);
    }



    template <class T> std::size_t hash_value(T* const& v)



    {






        std::size_t x = static_cast<std::size_t>(
           reinterpret_cast<std::ptrdiff_t>(v));

        return x + (x >> 3);
    }
# 411 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
    template <class T>
    inline void hash_combine(std::size_t& seed, T const& v)
    {
        boost::hash<T> hasher;
        return boost::hash_detail::hash_combine_impl(seed, hasher(v));
    }





    template <class It>
    inline std::size_t hash_range(It first, It last)
    {
        std::size_t seed = 0;

        for(; first != last; ++first)
        {
            hash_combine(seed, *first);
        }

        return seed;
    }

    template <class It>
    inline void hash_range(std::size_t& seed, It first, It last)
    {
        for(; first != last; ++first)
        {
            hash_combine(seed, *first);
        }
    }
# 471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
    template< class T, unsigned N >
    inline std::size_t hash_value(const T (&x)[N])
    {
        return hash_range(x, x + N);
    }

    template< class T, unsigned N >
    inline std::size_t hash_value(T (&x)[N])
    {
        return hash_range(x, x + N);
    }


    template <class Ch, class A>
    inline std::size_t hash_value(
        std::basic_string<Ch, std::char_traits<Ch>, A> const& v)
    {
        return hash_range(v.begin(), v.end());
    }


    template <class Ch>
    inline std::size_t hash_value(
        std::basic_string_view<Ch, std::char_traits<Ch> > const& v)
    {
        return hash_range(v.begin(), v.end());
    }


    template <typename T>
    typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
    {
        return boost::hash_detail::float_hash_value(v);
    }


    template <typename T>
    inline std::size_t hash_value(std::optional<T> const& v) {
        if (!v) {

            return 0x12345678;
        } else {
            boost::hash<T> hf;
            return hf(*v);
        }
    }



    inline std::size_t hash_value(std::monostate) {
        return 0x87654321;
    }

    template <typename... Types>
    inline 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;
    }




    inline std::size_t hash_value(std::type_index v)
    {
        return v.hash_code();
    }



    inline std::size_t hash_value(std::error_code const& v) {
        std::size_t seed = 0;
        hash_combine(seed, v.value());
        hash_combine(seed, &v.category());
        return seed;
    }

    inline std::size_t hash_value(std::error_condition const& v) {
        std::size_t seed = 0;
        hash_combine(seed, v.value());
        hash_combine(seed, &v.category());
        return seed;
    }
# 603 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
    template <> struct hash<bool> : public boost::hash_detail::hash_base<bool> { std::size_t operator()(bool v) const { return boost::hash_value(v); } };
    template <> struct hash<char> : public boost::hash_detail::hash_base<char> { std::size_t operator()(char v) const { return boost::hash_value(v); } };
    template <> struct hash<signed char> : public boost::hash_detail::hash_base<signed char> { std::size_t operator()(signed char v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned char> : public boost::hash_detail::hash_base<unsigned char> { std::size_t operator()(unsigned char v) const { return boost::hash_value(v); } };

    template <> struct hash<wchar_t> : public boost::hash_detail::hash_base<wchar_t> { std::size_t operator()(wchar_t v) const { return boost::hash_value(v); } };


    template <> struct hash<char16_t> : public boost::hash_detail::hash_base<char16_t> { std::size_t operator()(char16_t v) const { return boost::hash_value(v); } };


    template <> struct hash<char32_t> : public boost::hash_detail::hash_base<char32_t> { std::size_t operator()(char32_t v) const { return boost::hash_value(v); } };

    template <> struct hash<short> : public boost::hash_detail::hash_base<short> { std::size_t operator()(short v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned short> : public boost::hash_detail::hash_base<unsigned short> { std::size_t operator()(unsigned short v) const { return boost::hash_value(v); } };
    template <> struct hash<int> : public boost::hash_detail::hash_base<int> { std::size_t operator()(int v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned int> : public boost::hash_detail::hash_base<unsigned int> { std::size_t operator()(unsigned int v) const { return boost::hash_value(v); } };
    template <> struct hash<long> : public boost::hash_detail::hash_base<long> { std::size_t operator()(long v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned long> : public boost::hash_detail::hash_base<unsigned long> { std::size_t operator()(unsigned long v) const { return boost::hash_value(v); } };

    template <> struct hash<float> : public boost::hash_detail::hash_base<float> { std::size_t operator()(float v) const { return boost::hash_value(v); } };
    template <> struct hash<double> : public boost::hash_detail::hash_base<double> { std::size_t operator()(double v) const { return boost::hash_value(v); } };
    template <> struct hash<long double> : public boost::hash_detail::hash_base<long double> { std::size_t operator()(long double v) const { return boost::hash_value(v); } };

    template <> struct hash<std::string> : public boost::hash_detail::hash_base<std::string> { std::size_t operator()(std::string const& v) const { return boost::hash_value(v); } };

    template <> struct hash<std::wstring> : public boost::hash_detail::hash_base<std::wstring> { std::size_t operator()(std::wstring const& v) const { return boost::hash_value(v); } };


    template <> struct hash<std::basic_string<char16_t> > : public boost::hash_detail::hash_base<std::basic_string<char16_t> > { std::size_t operator()(std::basic_string<char16_t> const& v) const { return boost::hash_value(v); } };


    template <> struct hash<std::basic_string<char32_t> > : public boost::hash_detail::hash_base<std::basic_string<char32_t> > { std::size_t operator()(std::basic_string<char32_t> const& v) const { return boost::hash_value(v); } };



    template <> struct hash<std::string_view> : public boost::hash_detail::hash_base<std::string_view> { std::size_t operator()(std::string_view const& v) const { return boost::hash_value(v); } };

    template <> struct hash<std::wstring_view> : public boost::hash_detail::hash_base<std::wstring_view> { std::size_t operator()(std::wstring_view const& v) const { return boost::hash_value(v); } };


    template <> struct hash<std::basic_string_view<char16_t> > : public boost::hash_detail::hash_base<std::basic_string_view<char16_t> > { std::size_t operator()(std::basic_string_view<char16_t> const& v) const { return boost::hash_value(v); } };


    template <> struct hash<std::basic_string_view<char32_t> > : public boost::hash_detail::hash_base<std::basic_string_view<char32_t> > { std::size_t operator()(std::basic_string_view<char32_t> const& v) const { return boost::hash_value(v); } };




    template <> struct hash<boost::long_long_type> : public boost::hash_detail::hash_base<boost::long_long_type> { std::size_t operator()(boost::long_long_type v) const { return boost::hash_value(v); } };
    template <> struct hash<boost::ulong_long_type> : public boost::hash_detail::hash_base<boost::ulong_long_type> { std::size_t operator()(boost::ulong_long_type v) const { return boost::hash_value(v); } };



    template <> struct hash<boost::int128_type> : public boost::hash_detail::hash_base<boost::int128_type> { std::size_t operator()(boost::int128_type v) const { return boost::hash_value(v); } };
    template <> struct hash<boost::uint128_type> : public boost::hash_detail::hash_base<boost::uint128_type> { std::size_t operator()(boost::uint128_type v) const { return boost::hash_value(v); } };



    template <typename T>
    struct hash<std::optional<T> > : public boost::hash_detail::hash_base<std::optional<T> > { std::size_t operator()(std::optional<T> const& v) const { return boost::hash_value(v); } };
# 673 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
    template <> struct hash<std::type_index> : public boost::hash_detail::hash_base<std::type_index> { std::size_t operator()(std::type_index v) const { return boost::hash_value(v); } };
# 684 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
    template <class T>
    struct hash<T*>
        : public boost::hash_detail::hash_base<T*>
    {
        std::size_t operator()(T* v) const
        {

            return boost::hash_value(v);






        }
    };
# 743 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
}
# 760 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 3 4
       


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/container_fwd.hpp" 1 3 4
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/container_fwd.hpp" 3 4
# 1 "/usr/include/c++/10/deque" 1 3 4
# 58 "/usr/include/c++/10/deque" 3 4
       
# 59 "/usr/include/c++/10/deque" 3
# 67 "/usr/include/c++/10/deque" 3
# 1 "/usr/include/c++/10/bits/stl_deque.h" 1 3
# 69 "/usr/include/c++/10/bits/stl_deque.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


# 92 "/usr/include/c++/10/bits/stl_deque.h" 3
  constexpr inline size_t
  __deque_buf_size(size_t __size)
  { return (__size < 512
     ? size_t(512 / __size) : size_t(1)); }
# 109 "/usr/include/c++/10/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() { }
# 158 "/usr/include/c++/10/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); }

      reference
      operator*() const noexcept
      { return *_M_cur; }

      pointer
      operator->() const noexcept
      { return _M_cur; }

      _Self&
      operator++() noexcept
      {
 ++_M_cur;
 if (_M_cur == _M_last)
   {
     _M_set_node(_M_node + 1);
     _M_cur = _M_first;
   }
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 ++*this;
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 if (_M_cur == _M_first)
   {
     _M_set_node(_M_node - 1);
     _M_cur = _M_last;
   }
 --_M_cur;
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 --*this;
 return __tmp;
      }

      _Self&
      operator+=(difference_type __n) noexcept
      {
 const difference_type __offset = __n + (_M_cur - _M_first);
 if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
   _M_cur += __n;
 else
   {
     const difference_type __node_offset =
       __offset > 0 ? __offset / difference_type(_S_buffer_size())
      : -difference_type((-__offset - 1)
           / _S_buffer_size()) - 1;
     _M_set_node(_M_node + __node_offset);
     _M_cur = _M_first + (__offset - __node_offset
     * difference_type(_S_buffer_size()));
   }
 return *this;
      }

      _Self&
      operator-=(difference_type __n) noexcept
      { return *this += -__n; }

      reference
      operator[](difference_type __n) const noexcept
      { return *(*this + __n); }






      void
      _M_set_node(_Map_pointer __new_node) noexcept
      {
 _M_node = __new_node;
 _M_first = *__new_node;
 _M_last = _M_first + difference_type(_S_buffer_size());
      }

      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_cur == __y._M_cur; }




      template<typename _RefR, typename _PtrR>
 friend bool
 operator==(const _Self& __x,
     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
 { return __x._M_cur == __y._M_cur; }

      friend bool
      operator!=(const _Self& __x, const _Self& __y) noexcept
      { return !(__x == __y); }

      template<typename _RefR, typename _PtrR>
 friend bool
 operator!=(const _Self& __x,
     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
 { return !(__x == __y); }

      friend bool
      operator<(const _Self& __x, const _Self& __y) noexcept
      {
 return (__x._M_node == __y._M_node)
   ? (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
      }

      template<typename _RefR, typename _PtrR>
 friend bool
 operator<(const _Self& __x,
    const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
 {
   return (__x._M_node == __y._M_node)
     ? (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
 }

      friend bool
      operator>(const _Self& __x, const _Self& __y) noexcept
      { return __y < __x; }

      template<typename _RefR, typename _PtrR>
 friend bool
 operator>(const _Self& __x,
    const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
 { return __y < __x; }

      friend bool
      operator<=(const _Self& __x, const _Self& __y) noexcept
      { return !(__y < __x); }

      template<typename _RefR, typename _PtrR>
 friend bool
 operator<=(const _Self& __x,
     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
 { return !(__y < __x); }

      friend bool
      operator>=(const _Self& __x, const _Self& __y) noexcept
      { return !(__x < __y); }

      template<typename _RefR, typename _PtrR>
 friend bool
 operator>=(const _Self& __x,
     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
 { return !(__x < __y); }

      friend difference_type
      operator-(const _Self& __x, const _Self& __y) noexcept
      {
 return difference_type(_S_buffer_size())
   * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
   + (__y._M_last - __y._M_cur);
      }





      template<typename _RefR, typename _PtrR>
 friend difference_type
 operator-(const _Self& __x,
    const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
 {
   return difference_type(_S_buffer_size())
     * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
     + (__y._M_last - __y._M_cur);
 }

      friend _Self
      operator+(const _Self& __x, difference_type __n) noexcept
      {
 _Self __tmp = __x;
 __tmp += __n;
 return __tmp;
      }

      friend _Self
      operator-(const _Self& __x, difference_type __n) noexcept
      {
 _Self __tmp = __x;
 __tmp -= __n;
 return __tmp;
      }

      friend _Self
      operator+(difference_type __n, const _Self& __x) noexcept
      { return __x + __n; }
    };
# 386 "/usr/include/c++/10/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);
 }
    }
# 593 "/usr/include/c++/10/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);
    }
# 744 "/usr/include/c++/10/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class deque : protected _Deque_base<_Tp, _Alloc>
    {
# 757 "/usr/include/c++/10/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;
# 821 "/usr/include/c++/10/bits/stl_deque.h" 3
      explicit
      deque(const allocator_type& __a)
      : _Base(__a, 0) { }
# 834 "/usr/include/c++/10/bits/stl_deque.h" 3
      explicit
      deque(size_type __n, const allocator_type& __a = allocator_type())
      : _Base(__a, _S_check_init_len(__n, __a))
      { _M_default_initialize(); }
# 847 "/usr/include/c++/10/bits/stl_deque.h" 3
      deque(size_type __n, const value_type& __value,
     const allocator_type& __a = allocator_type())
      : _Base(__a, _S_check_init_len(__n, __a))
      { _M_fill_initialize(__value); }
# 874 "/usr/include/c++/10/bits/stl_deque.h" 3
      deque(const deque& __x)
      : _Base(_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()),
       __x.size())
      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
        this->_M_impl._M_start,
        _M_get_Tp_allocator()); }
# 890 "/usr/include/c++/10/bits/stl_deque.h" 3
      deque(deque&&) = default;


      deque(const deque& __x, const allocator_type& __a)
      : _Base(__a, __x.size())
      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
        this->_M_impl._M_start,
        _M_get_Tp_allocator()); }


      deque(deque&& __x, const allocator_type& __a)
      : deque(std::move(__x), __a, typename _Alloc_traits::is_always_equal{})
      { }

    private:
      deque(deque&& __x, const allocator_type& __a, true_type)
      : _Base(std::move(__x), __a)
      { }

      deque(deque&& __x, const allocator_type& __a, false_type)
      : _Base(std::move(__x), __a, __x.size())
      {
 if (__x.get_allocator() != __a && !__x.empty())
   {
     std::__uninitialized_move_a(__x.begin(), __x.end(),
     this->_M_impl._M_start,
     _M_get_Tp_allocator());
     __x.clear();
   }
      }

    public:
# 933 "/usr/include/c++/10/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());
      }
# 958 "/usr/include/c++/10/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));
 }
# 984 "/usr/include/c++/10/bits/stl_deque.h" 3
      ~deque()
      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
# 996 "/usr/include/c++/10/bits/stl_deque.h" 3
      deque&
      operator=(const deque& __x);
# 1008 "/usr/include/c++/10/bits/stl_deque.h" 3
      deque&
      operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal())
      {
 using __always_equal = typename _Alloc_traits::is_always_equal;
 _M_move_assign1(std::move(__x), __always_equal{});
 return *this;
      }
# 1027 "/usr/include/c++/10/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;
      }
# 1046 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 1063 "/usr/include/c++/10/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)); }
# 1090 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      assign(initializer_list<value_type> __l)
      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }



      allocator_type
      get_allocator() const noexcept
      { return _Base::get_allocator(); }






      iterator
      begin() noexcept
      { return this->_M_impl._M_start; }





      const_iterator
      begin() const noexcept
      { return this->_M_impl._M_start; }






      iterator
      end() noexcept
      { return this->_M_impl._M_finish; }






      const_iterator
      end() const noexcept
      { return this->_M_impl._M_finish; }






      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(this->_M_impl._M_finish); }






      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_finish); }






      reverse_iterator
      rend() noexcept
      { return reverse_iterator(this->_M_impl._M_start); }






      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_start); }






      const_iterator
      cbegin() const noexcept
      { return this->_M_impl._M_start; }






      const_iterator
      cend() const noexcept
      { return this->_M_impl._M_finish; }






      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_finish); }






      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_start); }




      size_type
      size() const noexcept
      { return this->_M_impl._M_finish - this->_M_impl._M_start; }


      size_type
      max_size() const noexcept
      { return _S_max_size(_M_get_Tp_allocator()); }
# 1229 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      resize(size_type __new_size)
      {
 const size_type __len = size();
 if (__new_size > __len)
   _M_default_append(__new_size - __len);
 else if (__new_size < __len)
   _M_erase_at_end(this->_M_impl._M_start
     + difference_type(__new_size));
      }
# 1251 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      resize(size_type __new_size, const value_type& __x)
# 1268 "/usr/include/c++/10/bits/stl_deque.h" 3
      {
 const size_type __len = size();
 if (__new_size > __len)
   _M_fill_insert(this->_M_impl._M_finish, __new_size - __len, __x);
 else if (__new_size < __len)
   _M_erase_at_end(this->_M_impl._M_start
     + difference_type(__new_size));
      }



      void
      shrink_to_fit() noexcept
      { _M_shrink_to_fit(); }






      [[__nodiscard__]] bool
      empty() const noexcept
      { return this->_M_impl._M_finish == this->_M_impl._M_start; }
# 1304 "/usr/include/c++/10/bits/stl_deque.h" 3
      reference
      operator[](size_type __n) noexcept
      {
 do { if (! (__builtin_expect(__n < this->size(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1307, __PRETTY_FUNCTION__, "__builtin_expect(__n < this->size(), true)"); } while (false);
 return this->_M_impl._M_start[difference_type(__n)];
      }
# 1322 "/usr/include/c++/10/bits/stl_deque.h" 3
      const_reference
      operator[](size_type __n) const noexcept
      {
 do { if (! (__builtin_expect(__n < this->size(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1325, __PRETTY_FUNCTION__, "__builtin_expect(__n < this->size(), true)"); } while (false);
 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:
# 1353 "/usr/include/c++/10/bits/stl_deque.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1371 "/usr/include/c++/10/bits/stl_deque.h" 3
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }





      reference
      front() noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1385, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return *begin();
      }





      const_reference
      front() const noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1396, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return *begin();
      }





      reference
      back() noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1407, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }





      const_reference
      back() const noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1420, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 const_iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }
# 1436 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      push_front(const value_type& __x)
      {
 if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
   {
     _Alloc_traits::construct(this->_M_impl,
         this->_M_impl._M_start._M_cur - 1,
         __x);
     --this->_M_impl._M_start._M_cur;
   }
 else
   _M_push_front_aux(__x);
      }


      void
      push_front(value_type&& __x)
      { emplace_front(std::move(__x)); }

      template<typename... _Args>

 reference



 emplace_front(_Args&&... __args);
# 1473 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      push_back(const value_type& __x)
      {
 if (this->_M_impl._M_finish._M_cur
     != this->_M_impl._M_finish._M_last - 1)
   {
     _Alloc_traits::construct(this->_M_impl,
         this->_M_impl._M_finish._M_cur, __x);
     ++this->_M_impl._M_finish._M_cur;
   }
 else
   _M_push_back_aux(__x);
      }


      void
      push_back(value_type&& __x)
      { emplace_back(std::move(__x)); }

      template<typename... _Args>

 reference



 emplace_back(_Args&&... __args);
# 1509 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      pop_front() noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1512, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 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();
      }
# 1532 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      pop_back() noexcept
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1535, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 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();
      }
# 1557 "/usr/include/c++/10/bits/stl_deque.h" 3
      template<typename... _Args>
 iterator
 emplace(const_iterator __position, _Args&&... __args);
# 1570 "/usr/include/c++/10/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1596 "/usr/include/c++/10/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return emplace(__position, std::move(__x)); }
# 1610 "/usr/include/c++/10/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;
      }
# 1629 "/usr/include/c++/10/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __position, size_type __n, const value_type& __x)
      {
 difference_type __offset = __position - cbegin();
 _M_fill_insert(__position._M_const_cast(), __n, __x);
 return begin() + __offset;
      }
# 1663 "/usr/include/c++/10/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;
 }
# 1709 "/usr/include/c++/10/bits/stl_deque.h" 3
      iterator

      erase(const_iterator __position)



      { return _M_erase(__position._M_const_cast()); }
# 1733 "/usr/include/c++/10/bits/stl_deque.h" 3
      iterator

      erase(const_iterator __first, const_iterator __last)



      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
# 1752 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      swap(deque& __x) noexcept
      {

 do { if (! (_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) std::__replacement_assert("/usr/include/c++/10/bits/stl_deque.h", 1756, __PRETTY_FUNCTION__, "_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator()"); } 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:
# 1802 "/usr/include/c++/10/bits/stl_deque.h" 3
      static size_t
      _S_check_init_len(size_t __n, const allocator_type& __a)
      {
 if (__n > _S_max_size(__a))
   __throw_length_error(
       ("cannot create std::deque larger than max_size()"));
 return __n;
      }

      static size_type
      _S_max_size(const _Tp_alloc_type& __a) noexcept
      {
 const size_t __diffmax = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max;
 const size_t __allocmax = _Alloc_traits::max_size(__a);
 return (std::min)(__diffmax, __allocmax);
      }
# 1831 "/usr/include/c++/10/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);
# 1853 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      _M_fill_initialize(const value_type& __value);



      void
      _M_default_initialize();
# 1884 "/usr/include/c++/10/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);
   }
      }
# 1932 "/usr/include/c++/10/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();
# 1971 "/usr/include/c++/10/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);
# 2103 "/usr/include/c++/10/bits/stl_deque.h" 3
      void
      _M_reserve_map_at_back(size_type __nodes_to_add = 1)
      {
 if (__nodes_to_add + 1 > this->_M_impl._M_map_size
     - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
   _M_reallocate_map(__nodes_to_add, false);
      }

      void
      _M_reserve_map_at_front(size_type __nodes_to_add = 1)
      {
 if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
           - this->_M_impl._M_map))
   _M_reallocate_map(__nodes_to_add, true);
      }

      void
      _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);





      void
      _M_move_assign1(deque&& __x, true_type) noexcept
      {
 this->_M_impl._M_swap_data(__x._M_impl);
 __x.clear();
 std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
      }




      void
      _M_move_assign1(deque&& __x, false_type)
      {
 constexpr bool __move_storage =
   _Alloc_traits::_S_propagate_on_move_assign();
 _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
      }



      template<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>;
# 2220 "/usr/include/c++/10/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    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()); }
# 2237 "/usr/include/c++/10/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
    { return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end()); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator<=(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Alloc>
    inline bool
    operator>=(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Alloc>
    inline void
    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }








  template<class _Tp>
    struct __is_bitwise_relocatable<std::deque<_Tp>>
    : true_type { };



}
# 68 "/usr/include/c++/10/deque" 2 3

# 1 "/usr/include/c++/10/bits/deque.tcc" 1 3
# 61 "/usr/include/c++/10/bits/deque.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template <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 (&__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)
       {
  _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 _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;
    }


}
# 70 "/usr/include/c++/10/deque" 2 3






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

  namespace pmr
  {
    template<typename _Tp> class polymorphic_allocator;
    template<typename _Tp>
      using deque = std::deque<_Tp, polymorphic_allocator<_Tp>>;
  }

}
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/container_fwd.hpp" 2 3 4


# 1 "/usr/include/c++/10/map" 1 3 4
# 58 "/usr/include/c++/10/map" 3 4
       
# 59 "/usr/include/c++/10/map" 3

# 1 "/usr/include/c++/10/bits/stl_tree.h" 1 3
# 61 "/usr/include/c++/10/bits/stl_tree.h" 3
       
# 62 "/usr/include/c++/10/bits/stl_tree.h" 3
# 75 "/usr/include/c++/10/bits/stl_tree.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 99 "/usr/include/c++/10/bits/stl_tree.h" 3
  enum _Rb_tree_color { _S_red = false, _S_black = true };

  struct _Rb_tree_node_base
  {
    typedef _Rb_tree_node_base* _Base_ptr;
    typedef const _Rb_tree_node_base* _Const_Base_ptr;

    _Rb_tree_color _M_color;
    _Base_ptr _M_parent;
    _Base_ptr _M_left;
    _Base_ptr _M_right;

    static _Base_ptr
    _S_minimum(_Base_ptr __x) noexcept
    {
      while (__x->_M_left != 0) __x = __x->_M_left;
      return __x;
    }

    static _Const_Base_ptr
    _S_minimum(_Const_Base_ptr __x) noexcept
    {
      while (__x->_M_left != 0) __x = __x->_M_left;
      return __x;
    }

    static _Base_ptr
    _S_maximum(_Base_ptr __x) noexcept
    {
      while (__x->_M_right != 0) __x = __x->_M_right;
      return __x;
    }

    static _Const_Base_ptr
    _S_maximum(_Const_Base_ptr __x) noexcept
    {
      while (__x->_M_right != 0) __x = __x->_M_right;
      return __x;
    }
  };


  template<typename _Key_compare>
    struct _Rb_tree_key_compare
    {
      _Key_compare _M_key_compare;

      _Rb_tree_key_compare()
      noexcept(is_nothrow_default_constructible<_Key_compare>::value)

      : _M_key_compare()
      { }

      _Rb_tree_key_compare(const _Key_compare& __comp)
      : _M_key_compare(__comp)
      { }



      _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default;

      _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
 noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
      : _M_key_compare(__x._M_key_compare)
      { }

    };


  struct _Rb_tree_header
  {
    _Rb_tree_node_base _M_header;
    size_t _M_node_count;

    _Rb_tree_header() noexcept
    {
      _M_header._M_color = _S_red;
      _M_reset();
    }


    _Rb_tree_header(_Rb_tree_header&& __x) noexcept
    {
      if (__x._M_header._M_parent != nullptr)
 _M_move_data(__x);
      else
 {
   _M_header._M_color = _S_red;
   _M_reset();
 }
    }


    void
    _M_move_data(_Rb_tree_header& __from)
    {
      _M_header._M_color = __from._M_header._M_color;
      _M_header._M_parent = __from._M_header._M_parent;
      _M_header._M_left = __from._M_header._M_left;
      _M_header._M_right = __from._M_header._M_right;
      _M_header._M_parent->_M_parent = &_M_header;
      _M_node_count = __from._M_node_count;

      __from._M_reset();
    }

    void
    _M_reset()
    {
      _M_header._M_parent = 0;
      _M_header._M_left = &_M_header;
      _M_header._M_right = &_M_header;
      _M_node_count = 0;
    }
  };

  template<typename _Val>
    struct _Rb_tree_node : public _Rb_tree_node_base
    {
      typedef _Rb_tree_node<_Val>* _Link_type;
# 231 "/usr/include/c++/10/bits/stl_tree.h" 3
      __gnu_cxx::__aligned_membuf<_Val> _M_storage;

      _Val*
      _M_valptr()
      { return _M_storage._M_ptr(); }

      const _Val*
      _M_valptr() const
      { return _M_storage._M_ptr(); }

    };

  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) const _Rb_tree_node_base*
  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) const _Rb_tree_node_base*
  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();

  template<typename _Tp>
    struct _Rb_tree_iterator
    {
      typedef _Tp value_type;
      typedef _Tp& reference;
      typedef _Tp* pointer;

      typedef bidirectional_iterator_tag iterator_category;
      typedef ptrdiff_t difference_type;

      typedef _Rb_tree_iterator<_Tp> _Self;
      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
      typedef _Rb_tree_node<_Tp>* _Link_type;

      _Rb_tree_iterator() noexcept
      : _M_node() { }

      explicit
      _Rb_tree_iterator(_Base_ptr __x) noexcept
      : _M_node(__x) { }

      reference
      operator*() const noexcept
      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Link_type> (_M_node)->_M_valptr(); }

      _Self&
      operator++() noexcept
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }

      friend bool
      operator!=(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node != __y._M_node; }

      _Base_ptr _M_node;
  };

  template<typename _Tp>
    struct _Rb_tree_const_iterator
    {
      typedef _Tp value_type;
      typedef const _Tp& reference;
      typedef const _Tp* pointer;

      typedef _Rb_tree_iterator<_Tp> iterator;

      typedef bidirectional_iterator_tag iterator_category;
      typedef ptrdiff_t difference_type;

      typedef _Rb_tree_const_iterator<_Tp> _Self;
      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
      typedef const _Rb_tree_node<_Tp>* _Link_type;

      _Rb_tree_const_iterator() noexcept
      : _M_node() { }

      explicit
      _Rb_tree_const_iterator(_Base_ptr __x) noexcept
      : _M_node(__x) { }

      _Rb_tree_const_iterator(const iterator& __it) noexcept
      : _M_node(__it._M_node) { }

      iterator
      _M_const_cast() const noexcept
      { return iterator(const_cast<typename iterator::_Base_ptr>(_M_node)); }

      reference
      operator*() const noexcept
      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Link_type>(_M_node)->_M_valptr(); }

      _Self&
      operator++() noexcept
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }

      friend bool
      operator!=(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node != __y._M_node; }

      _Base_ptr _M_node;
    };

  void
  _Rb_tree_insert_and_rebalance(const bool __insert_left,
    _Rb_tree_node_base* __x,
    _Rb_tree_node_base* __p,
    _Rb_tree_node_base& __header) throw ();

  _Rb_tree_node_base*
  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
          _Rb_tree_node_base& __header) throw ();


  template<typename _Cmp, typename _SfinaeType, typename = __void_t<>>
    struct __has_is_transparent
    { };

  template<typename _Cmp, typename _SfinaeType>
    struct __has_is_transparent<_Cmp, _SfinaeType,
    __void_t<typename _Cmp::is_transparent>>
    { typedef void type; };

  template<typename _Cmp, typename _SfinaeType>
    using __has_is_transparent_t
      = typename __has_is_transparent<_Cmp, _SfinaeType>::type;



  template<typename _Tree1, typename _Cmp2>
    struct _Rb_tree_merge_helper { };


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc = allocator<_Val> >
    class _Rb_tree
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Rb_tree_node<_Val> >::other _Node_allocator;

      typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;

    protected:
      typedef _Rb_tree_node_base* _Base_ptr;
      typedef const _Rb_tree_node_base* _Const_Base_ptr;
      typedef _Rb_tree_node<_Val>* _Link_type;
      typedef const _Rb_tree_node<_Val>* _Const_Link_type;

    private:


      struct _Reuse_or_alloc_node
      {
 _Reuse_or_alloc_node(_Rb_tree& __t)
 : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
 {
   if (_M_root)
     {
       _M_root->_M_parent = 0;

       if (_M_nodes->_M_left)
  _M_nodes = _M_nodes->_M_left;
     }
   else
     _M_nodes = 0;
 }


 _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;


 ~_Reuse_or_alloc_node()
 { _M_t._M_erase(static_cast<_Link_type>(_M_root)); }

 template<typename _Arg>
   _Link_type



   operator()(_Arg&& __arg)

   {
     _Link_type __node = static_cast<_Link_type>(_M_extract());
     if (__node)
       {
  _M_t._M_destroy_node(__node);
  _M_t._M_construct_node(__node, std::forward<_Arg>(__arg));
  return __node;
       }

     return _M_t._M_create_node(std::forward<_Arg>(__arg));
   }

      private:
 _Base_ptr
 _M_extract()
 {
   if (!_M_nodes)
     return _M_nodes;

   _Base_ptr __node = _M_nodes;
   _M_nodes = _M_nodes->_M_parent;
   if (_M_nodes)
     {
       if (_M_nodes->_M_right == __node)
  {
    _M_nodes->_M_right = 0;

    if (_M_nodes->_M_left)
      {
        _M_nodes = _M_nodes->_M_left;

        while (_M_nodes->_M_right)
   _M_nodes = _M_nodes->_M_right;

        if (_M_nodes->_M_left)
   _M_nodes = _M_nodes->_M_left;
      }
  }
       else
  _M_nodes->_M_left = 0;
     }
   else
     _M_root = 0;

   return __node;
 }

 _Base_ptr _M_root;
 _Base_ptr _M_nodes;
 _Rb_tree& _M_t;
      };



      struct _Alloc_node
      {
 _Alloc_node(_Rb_tree& __t)
 : _M_t(__t) { }

 template<typename _Arg>
   _Link_type



   operator()(_Arg&& __arg) const

   { return _M_t._M_create_node(std::forward<_Arg>(__arg)); }

      private:
 _Rb_tree& _M_t;
      };

    public:
      typedef _Key key_type;
      typedef _Val value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

      _Node_allocator&
      _M_get_Node_allocator() noexcept
      { return this->_M_impl; }

      const _Node_allocator&
      _M_get_Node_allocator() const noexcept
      { return this->_M_impl; }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Node_allocator()); }

    protected:
      _Link_type
      _M_get_node()
      { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }

      void
      _M_put_node(_Link_type __p) noexcept
      { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }
# 607 "/usr/include/c++/10/bits/stl_tree.h" 3
      template<typename... _Args>
 void
 _M_construct_node(_Link_type __node, _Args&&... __args)
 {
   try
     {
       ::new(__node) _Rb_tree_node<_Val>;
       _Alloc_traits::construct(_M_get_Node_allocator(),
           __node->_M_valptr(),
           std::forward<_Args>(__args)...);
     }
   catch(...)
     {
       __node->~_Rb_tree_node<_Val>();
       _M_put_node(__node);
       throw;
     }
 }

      template<typename... _Args>
 _Link_type
 _M_create_node(_Args&&... __args)
 {
   _Link_type __tmp = _M_get_node();
   _M_construct_node(__tmp, std::forward<_Args>(__args)...);
   return __tmp;
 }


      void
      _M_destroy_node(_Link_type __p) noexcept
      {



 _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
 __p->~_Rb_tree_node<_Val>();

      }

      void
      _M_drop_node(_Link_type __p) noexcept
      {
 _M_destroy_node(__p);
 _M_put_node(__p);
      }

      template<typename _NodeGen>
 _Link_type
 _M_clone_node(_Const_Link_type __x, _NodeGen& __node_gen)
 {
   _Link_type __tmp = __node_gen(*__x->_M_valptr());
   __tmp->_M_color = __x->_M_color;
   __tmp->_M_left = 0;
   __tmp->_M_right = 0;
   return __tmp;
 }

    protected:




      template<typename _Key_compare,
        bool = __is_pod(_Key_compare)>

 struct _Rb_tree_impl
 : public _Node_allocator
 , public _Rb_tree_key_compare<_Key_compare>
 , public _Rb_tree_header
 {
   typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare;

   _Rb_tree_impl()
     noexcept(is_nothrow_default_constructible<_Node_allocator>::value && is_nothrow_default_constructible<_Base_key_compare>::value)


   : _Node_allocator()
   { }

   _Rb_tree_impl(const _Rb_tree_impl& __x)
   : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x))
   , _Base_key_compare(__x._M_key_compare)
   { }






   _Rb_tree_impl(_Rb_tree_impl&&) = default;

   explicit
   _Rb_tree_impl(_Node_allocator&& __a)
   : _Node_allocator(std::move(__a))
   { }

   _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a)
   : _Node_allocator(std::move(__a)),
     _Base_key_compare(std::move(__x)),
     _Rb_tree_header(std::move(__x))
   { }

   _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
   : _Node_allocator(std::move(__a)), _Base_key_compare(__comp)
   { }

 };

      _Rb_tree_impl<_Compare> _M_impl;

    protected:
      _Base_ptr&
      _M_root() noexcept
      { return this->_M_impl._M_header._M_parent; }

      _Const_Base_ptr
      _M_root() const noexcept
      { return this->_M_impl._M_header._M_parent; }

      _Base_ptr&
      _M_leftmost() noexcept
      { return this->_M_impl._M_header._M_left; }

      _Const_Base_ptr
      _M_leftmost() const noexcept
      { return this->_M_impl._M_header._M_left; }

      _Base_ptr&
      _M_rightmost() noexcept
      { return this->_M_impl._M_header._M_right; }

      _Const_Base_ptr
      _M_rightmost() const noexcept
      { return this->_M_impl._M_header._M_right; }

      _Link_type
      _M_begin() noexcept
      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }

      _Const_Link_type
      _M_begin() const noexcept
      {
 return static_cast<_Const_Link_type>
   (this->_M_impl._M_header._M_parent);
      }

      _Base_ptr
      _M_end() noexcept
      { return &this->_M_impl._M_header; }

      _Const_Base_ptr
      _M_end() const noexcept
      { return &this->_M_impl._M_header; }

      static const _Key&
      _S_key(_Const_Link_type __x)
      {



 static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{},
        "comparison object must be invocable "
        "with two arguments of key type");



 if constexpr (__is_invocable<_Compare&, const _Key&, const _Key&>{})
   static_assert(
       is_invocable_v<const _Compare&, const _Key&, const _Key&>,
       "comparison object must be invocable as const");



 return _KeyOfValue()(*__x->_M_valptr());
      }

      static _Link_type
      _S_left(_Base_ptr __x) noexcept
      { return static_cast<_Link_type>(__x->_M_left); }

      static _Const_Link_type
      _S_left(_Const_Base_ptr __x) noexcept
      { return static_cast<_Const_Link_type>(__x->_M_left); }

      static _Link_type
      _S_right(_Base_ptr __x) noexcept
      { return static_cast<_Link_type>(__x->_M_right); }

      static _Const_Link_type
      _S_right(_Const_Base_ptr __x) noexcept
      { return static_cast<_Const_Link_type>(__x->_M_right); }

      static const _Key&
      _S_key(_Const_Base_ptr __x)
      { return _S_key(static_cast<_Const_Link_type>(__x)); }

      static _Base_ptr
      _S_minimum(_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Const_Base_ptr
      _S_minimum(_Const_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Base_ptr
      _S_maximum(_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_maximum(__x); }

      static _Const_Base_ptr
      _S_maximum(_Const_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_maximum(__x); }

    public:
      typedef _Rb_tree_iterator<value_type> iterator;
      typedef _Rb_tree_const_iterator<value_type> const_iterator;

      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;


      using node_type = _Node_handle<_Key, _Val, _Node_allocator>;
      using insert_return_type = _Node_insert_return<
 conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
 node_type>;


      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_unique_pos(const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_equal_pos(const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_hint_unique_pos(const_iterator __pos,
        const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_hint_equal_pos(const_iterator __pos,
       const key_type& __k);

    private:

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);

      iterator
      _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);

      template<typename _Arg>
 iterator
 _M_insert_lower(_Base_ptr __y, _Arg&& __v);

      template<typename _Arg>
 iterator
 _M_insert_equal_lower(_Arg&& __x);

      iterator
      _M_insert_lower_node(_Base_ptr __p, _Link_type __z);

      iterator
      _M_insert_equal_lower_node(_Link_type __z);
# 885 "/usr/include/c++/10/bits/stl_tree.h" 3
      template<typename _NodeGen>
 _Link_type
 _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen&);

      template<typename _NodeGen>
 _Link_type
 _M_copy(const _Rb_tree& __x, _NodeGen& __gen)
 {
   _Link_type __root = _M_copy(__x._M_begin(), _M_end(), __gen);
   _M_leftmost() = _S_minimum(__root);
   _M_rightmost() = _S_maximum(__root);
   _M_impl._M_node_count = __x._M_impl._M_node_count;
   return __root;
 }

      _Link_type
      _M_copy(const _Rb_tree& __x)
      {
 _Alloc_node __an(*this);
 return _M_copy(__x, __an);
      }

      void
      _M_erase(_Link_type __x);

      iterator
      _M_lower_bound(_Link_type __x, _Base_ptr __y,
       const _Key& __k);

      const_iterator
      _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
       const _Key& __k) const;

      iterator
      _M_upper_bound(_Link_type __x, _Base_ptr __y,
       const _Key& __k);

      const_iterator
      _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
       const _Key& __k) const;

    public:




      _Rb_tree() = default;


      _Rb_tree(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_impl(__comp, _Node_allocator(__a)) { }

      _Rb_tree(const _Rb_tree& __x)
      : _M_impl(__x._M_impl)
      {
 if (__x._M_root() != 0)
   _M_root() = _M_copy(__x);
      }


      _Rb_tree(const allocator_type& __a)
      : _M_impl(_Node_allocator(__a))
      { }

      _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
      : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
      {
 if (__x._M_root() != nullptr)
   _M_root() = _M_copy(__x);
      }

      _Rb_tree(_Rb_tree&&) = default;

      _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
      : _Rb_tree(std::move(__x), _Node_allocator(__a))
      { }

    private:
      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type)
      noexcept(is_nothrow_default_constructible<_Compare>::value)
      : _M_impl(std::move(__x._M_impl), std::move(__a))
      { }

      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type)
      : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
      {
 if (__x._M_root() != nullptr)
   _M_move_data(__x, false_type{});
      }

    public:
      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
      noexcept( noexcept(
 _Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(),
   std::declval<typename _Alloc_traits::is_always_equal>())) )
      : _Rb_tree(std::move(__x), std::move(__a),
   typename _Alloc_traits::is_always_equal{})
      { }


      ~_Rb_tree() noexcept
      { _M_erase(_M_begin()); }

      _Rb_tree&
      operator=(const _Rb_tree& __x);


      _Compare
      key_comp() const
      { return _M_impl._M_key_compare; }

      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_header._M_left); }

      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_header._M_left); }

      iterator
      end() noexcept
      { return iterator(&this->_M_impl._M_header); }

      const_iterator
      end() const noexcept
      { return const_iterator(&this->_M_impl._M_header); }

      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }

      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_impl._M_node_count == 0; }

      size_type
      size() const noexcept
      { return _M_impl._M_node_count; }

      size_type
      max_size() const noexcept
      { return _Alloc_traits::max_size(_M_get_Node_allocator()); }

      void
      swap(_Rb_tree& __t)
      noexcept(__is_nothrow_swappable<_Compare>::value);



      template<typename _Arg>
 pair<iterator, bool>
 _M_insert_unique(_Arg&& __x);

      template<typename _Arg>
 iterator
 _M_insert_equal(_Arg&& __x);

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);

      template<typename _Arg>
 iterator
 _M_insert_unique_(const_iterator __pos, _Arg&& __x)
 {
   _Alloc_node __an(*this);
   return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
 }

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);

      template<typename _Arg>
 iterator
 _M_insert_equal_(const_iterator __pos, _Arg&& __x)
 {
   _Alloc_node __an(*this);
   return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
 }

      template<typename... _Args>
 pair<iterator, bool>
 _M_emplace_unique(_Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_equal(_Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);

      template<typename _Iter>
 using __same_value_type
   = is_same<value_type, typename iterator_traits<_Iter>::value_type>;

      template<typename _InputIterator>
 __enable_if_t<__same_value_type<_InputIterator>::value>
 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
 {
   _Alloc_node __an(*this);
   for (; __first != __last; ++__first)
     _M_insert_unique_(end(), *__first, __an);
 }

      template<typename _InputIterator>
 __enable_if_t<!__same_value_type<_InputIterator>::value>
 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
 {
   for (; __first != __last; ++__first)
     _M_emplace_unique(*__first);
 }

      template<typename _InputIterator>
 __enable_if_t<__same_value_type<_InputIterator>::value>
 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
 {
   _Alloc_node __an(*this);
   for (; __first != __last; ++__first)
     _M_insert_equal_(end(), *__first, __an);
 }

      template<typename _InputIterator>
 __enable_if_t<!__same_value_type<_InputIterator>::value>
 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
 {
   _Alloc_node __an(*this);
   for (; __first != __last; ++__first)
     _M_emplace_equal(*__first);
 }
# 1182 "/usr/include/c++/10/bits/stl_tree.h" 3
    private:
      void
      _M_erase_aux(const_iterator __position);

      void
      _M_erase_aux(const_iterator __first, const_iterator __last);

    public:



      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      {
 do { if (! (__position != end())) std::__replacement_assert("/usr/include/c++/10/bits/stl_tree.h", 1197, __PRETTY_FUNCTION__, "__position != end()"); } 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 (! (__position != end())) std::__replacement_assert("/usr/include/c++/10/bits/stl_tree.h", 1209, __PRETTY_FUNCTION__, "__position != end()"); } while (false);
 iterator __result = __position;
 ++__result;
 _M_erase_aux(__position);
 return __result;
      }
# 1231 "/usr/include/c++/10/bits/stl_tree.h" 3
      size_type
      erase(const key_type& __x);




      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __first, const_iterator __last)
      {
 _M_erase_aux(__first, __last);
 return __last._M_const_cast();
      }
# 1254 "/usr/include/c++/10/bits/stl_tree.h" 3
      void
      clear() noexcept
      {
 _M_erase(_M_begin());
 _M_impl._M_reset();
      }


      iterator
      find(const key_type& __k);

      const_iterator
      find(const key_type& __k) const;

      size_type
      count(const key_type& __k) const;

      iterator
      lower_bound(const key_type& __k)
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      lower_bound(const key_type& __k) const
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      iterator
      upper_bound(const key_type& __k)
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      upper_bound(const key_type& __k) const
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      pair<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 (! (_M_get_Node_allocator() == *__nh._M_alloc)) std::__replacement_assert("/usr/include/c++/10/bits/stl_tree.h", 1451, __PRETTY_FUNCTION__, "_M_get_Node_allocator() == *__nh._M_alloc"); } 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._M_ptr = nullptr;
  __ret.inserted = true;
       }
     else
       {
  __ret.node = std::move(__nh);
  __ret.position = iterator(__res.first);
  __ret.inserted = false;
       }
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_equal(node_type&& __nh)
      {
 iterator __ret;
 if (__nh.empty())
   __ret = end();
 else
   {
     do { if (! (_M_get_Node_allocator() == *__nh._M_alloc)) std::__replacement_assert("/usr/include/c++/10/bits/stl_tree.h", 1480, __PRETTY_FUNCTION__, "_M_get_Node_allocator() == *__nh._M_alloc"); } 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._M_ptr = nullptr;
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh)
      {
 iterator __ret;
 if (__nh.empty())
   __ret = end();
 else
   {
     do { if (! (_M_get_Node_allocator() == *__nh._M_alloc)) std::__replacement_assert("/usr/include/c++/10/bits/stl_tree.h", 1500, __PRETTY_FUNCTION__, "_M_get_Node_allocator() == *__nh._M_alloc"); } 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._M_ptr = nullptr;
       }
     else
       __ret = iterator(__res.first);
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh)
      {
 iterator __ret;
 if (__nh.empty())
   __ret = end();
 else
   {
     do { if (! (_M_get_Node_allocator() == *__nh._M_alloc)) std::__replacement_assert("/usr/include/c++/10/bits/stl_tree.h", 1522, __PRETTY_FUNCTION__, "_M_get_Node_allocator() == *__nh._M_alloc"); } 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._M_ptr = nullptr;
   }
 return __ret;
      }


      node_type
      extract(const_iterator __pos)
      {
 auto __ptr = _Rb_tree_rebalance_for_erase(
     __pos._M_const_cast()._M_node, _M_impl._M_header);
 --_M_impl._M_node_count;
 return { static_cast<_Link_type>(__ptr), _M_get_Node_allocator() };
      }


      node_type
      extract(const key_type& __k)
      {
 node_type __nh;
 auto __pos = find(__k);
 if (__pos != end())
   __nh = extract(const_iterator(__pos));
 return __nh;
      }

      template<typename _Compare2>
 using _Compatible_tree
   = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>;

      template<typename, typename>
 friend class _Rb_tree_merge_helper;


      template<typename _Compare2>
 void
 _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept
 {
   using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
     {
       auto __pos = __i++;
       auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos));
       if (__res.second)
  {
    auto& __src_impl = _Merge_helper::_S_get_impl(__src);
    auto __ptr = _Rb_tree_rebalance_for_erase(
        __pos._M_node, __src_impl._M_header);
    --__src_impl._M_node_count;
    _M_insert_node(__res.first, __res.second,
     static_cast<_Link_type>(__ptr));
  }
     }
 }


      template<typename _Compare2>
 void
 _M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept
 {
   using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
     {
       auto __pos = __i++;
       auto __res = _M_get_insert_equal_pos(_KeyOfValue()(*__pos));
       if (__res.second)
  {
    auto& __src_impl = _Merge_helper::_S_get_impl(__src);
    auto __ptr = _Rb_tree_rebalance_for_erase(
        __pos._M_node, __src_impl._M_header);
    --__src_impl._M_node_count;
    _M_insert_node(__res.first, __res.second,
     static_cast<_Link_type>(__ptr));
  }
     }
 }


      friend bool
      operator==(const _Rb_tree& __x, const _Rb_tree& __y)
      {
 return __x.size() == __y.size()
   && std::equal(__x.begin(), __x.end(), __y.begin());
      }

      friend bool
      operator<(const _Rb_tree& __x, const _Rb_tree& __y)
      {
 return std::lexicographical_compare(__x.begin(), __x.end(),
         __y.begin(), __y.end());
      }

      friend bool __attribute__ ((__deprecated__))
      operator!=(const _Rb_tree& __x, const _Rb_tree& __y)
      { return !(__x == __y); }

      friend bool __attribute__ ((__deprecated__))
      operator>(const _Rb_tree& __x, const _Rb_tree& __y)
      { return __y < __x; }

      friend bool __attribute__ ((__deprecated__))
      operator<=(const _Rb_tree& __x, const _Rb_tree& __y)
      { return !(__y < __x); }

      friend bool __attribute__ ((__deprecated__))
      operator>=(const _Rb_tree& __x, const _Rb_tree& __y)
      { return !(__x < __y); }
    };

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline void
    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { __x.swap(__y); }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_data(_Rb_tree& __x, false_type)
    {
      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
 _M_move_data(__x, true_type());
      else
 {
   _Alloc_node __an(*this);
   auto __lbd =
     [&__an](const value_type& __cval)
     {
       auto& __val = const_cast<value_type&>(__cval);
       return __an(std::move_if_noexcept(__val));
     };
   _M_root() = _M_copy(__x, __lbd);
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_assign(_Rb_tree& __x, true_type)
    {
      clear();
      if (__x._M_root() != nullptr)
 _M_move_data(__x, true_type());
      std::__alloc_on_move(_M_get_Node_allocator(),
      __x._M_get_Node_allocator());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_assign(_Rb_tree& __x, false_type)
    {
      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
 return _M_move_assign(__x, true_type{});



      _Reuse_or_alloc_node __roan(*this);
      _M_impl._M_reset();
      if (__x._M_root() != nullptr)
 {
   auto __lbd =
     [&__roan](const value_type& __cval)
     {
       auto& __val = const_cast<value_type&>(__cval);
       return __roan(std::move(__val));
     };
   _M_root() = _M_copy(__x, __lbd);
   __x.clear();
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(_Rb_tree&& __x)
    noexcept(_Alloc_traits::_S_nothrow_move()
      && is_nothrow_move_assignable<_Compare>::value)
    {
      _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
      _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()>());
      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename _Iterator>
      void
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_assign_unique(_Iterator __first, _Iterator __last)
      {
 _Reuse_or_alloc_node __roan(*this);
 _M_impl._M_reset();
 for (; __first != __last; ++__first)
   _M_insert_unique_(end(), *__first, __roan);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename _Iterator>
      void
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_assign_equal(_Iterator __first, _Iterator __last)
      {
 _Reuse_or_alloc_node __roan(*this);
 _M_impl._M_reset();
 for (; __first != __last; ++__first)
   _M_insert_equal_(end(), *__first, __roan);
      }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(const _Rb_tree& __x)
    {
      if (this != &__x)
 {


   if (_Alloc_traits::_S_propagate_on_copy_assign())
     {
       auto& __this_alloc = this->_M_get_Node_allocator();
       auto& __that_alloc = __x._M_get_Node_allocator();
       if (!_Alloc_traits::_S_always_equal()
    && __this_alloc != __that_alloc)
  {


    clear();
    std::__alloc_on_copy(__this_alloc, __that_alloc);
  }
     }


   _Reuse_or_alloc_node __roan(*this);
   _M_impl._M_reset();
   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
   if (__x._M_root() != 0)
     _M_root() = _M_copy(__x, __roan);
 }

      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_(_Base_ptr __x, _Base_ptr __p,

   _Arg&& __v,



   _NodeGen& __node_gen)
      {
 bool __insert_left = (__x != 0 || __p == _M_end()
         || _M_impl._M_key_compare(_KeyOfValue()(__v),
       _S_key(__p)));

 _Link_type __z = __node_gen(std::forward<_Arg>(__v));

 _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
          this->_M_impl._M_header);
 ++_M_impl._M_node_count;
 return iterator(__z);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_lower(_Base_ptr __p, _Arg&& __v)



    {
      bool __insert_left = (__p == _M_end()
       || !_M_impl._M_key_compare(_S_key(__p),
             _KeyOfValue()(__v)));

      _Link_type __z = _M_create_node(std::forward<_Arg>(__v));

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_equal_lower(_Arg&& __v)



    {
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower(__y, std::forward<_Arg>(__v));
    }

  template<typename _Key, typename _Val, typename _KoV,
    typename _Compare, typename _Alloc>
    template<typename _NodeGen>
      typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
      _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
      _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen& __node_gen)
      {

 _Link_type __top = _M_clone_node(__x, __node_gen);
 __top->_M_parent = __p;

 try
   {
     if (__x->_M_right)
       __top->_M_right = _M_copy(_S_right(__x), __top, __node_gen);
     __p = __top;
     __x = _S_left(__x);

     while (__x != 0)
       {
  _Link_type __y = _M_clone_node(__x, __node_gen);
  __p->_M_left = __y;
  __y->_M_parent = __p;
  if (__x->_M_right)
    __y->_M_right = _M_copy(_S_right(__x), __y, __node_gen);
  __p = __y;
  __x = _S_left(__x);
       }
   }
 catch(...)
   {
     _M_erase(__top);
     throw;
   }
 return __top;
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase(_Link_type __x)
    {

      while (__x != 0)
 {
   _M_erase(_S_right(__x));
   _Link_type __y = _S_left(__x);
   _M_drop_node(__x);
   __x = __y;
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Link_type __x, _Base_ptr __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Link_type __x, _Base_ptr __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k)
    {
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Link_type __xu(__x);
       _Base_ptr __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<iterator,
     iterator>(_M_lower_bound(__x, __y, __k),
        _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<iterator, iterator>(iterator(__y),
          iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k) const
    {
      _Const_Link_type __x = _M_begin();
      _Const_Base_ptr __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Const_Link_type __xu(__x);
       _Const_Base_ptr __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<const_iterator,
     const_iterator>(_M_lower_bound(__x, __y, __k),
       _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<const_iterator, const_iterator>(const_iterator(__y),
        const_iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    swap(_Rb_tree& __t)
    noexcept(__is_nothrow_swappable<_Compare>::value)
    {
      if (_M_root() == 0)
 {
   if (__t._M_root() != 0)
     _M_impl._M_move_data(__t._M_impl);
 }
      else if (__t._M_root() == 0)
 __t._M_impl._M_move_data(_M_impl);
      else
 {
   std::swap(_M_root(),__t._M_root());
   std::swap(_M_leftmost(),__t._M_leftmost());
   std::swap(_M_rightmost(),__t._M_rightmost());

   _M_root()->_M_parent = _M_end();
   __t._M_root()->_M_parent = __t._M_end();
   std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
 }

      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);

      _Alloc_traits::_S_on_swap(_M_get_Node_allocator(),
    __t._M_get_Node_allocator());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_unique_pos(const key_type& __k)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      bool __comp = true;
      while (__x != 0)
 {
   __y = __x;
   __comp = _M_impl._M_key_compare(__k, _S_key(__x));
   __x = __comp ? _S_left(__x) : _S_right(__x);
 }
      iterator __j = iterator(__y);
      if (__comp)
 {
   if (__j == begin())
     return _Res(__x, __y);
   else
     --__j;
 }
      if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
 return _Res(__x, __y);
      return _Res(__j._M_node, 0);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_equal_pos(const key_type& __k)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _Res(__x, __y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator, bool>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_unique(_Arg&& __v)



    {
      typedef pair<iterator, bool> _Res;
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_unique_pos(_KeyOfValue()(__v));

      if (__res.second)
 {
   _Alloc_node __an(*this);
   return _Res(_M_insert_(__res.first, __res.second,
     std::forward<_Arg>(__v), __an),
        true);
 }

      return _Res(iterator(__res.first), false);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_equal(_Arg&& __v)



    {
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_equal_pos(_KeyOfValue()(__v));
      _Alloc_node __an(*this);
      return _M_insert_(__res.first, __res.second,
   std::forward<_Arg>(__v), __an);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_hint_unique_pos(const_iterator __position,
      const key_type& __k)
    {
      iterator __pos = __position._M_const_cast();
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__pos._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
     return _Res(0, _M_rightmost());
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
 {

   iterator __before = __pos;
   if (__pos._M_node == _M_leftmost())
     return _Res(_M_leftmost(), _M_leftmost());
   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
     {
       if (_S_right(__before._M_node) == 0)
  return _Res(0, __before._M_node);
       else
  return _Res(__pos._M_node, __pos._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
 {

   iterator __after = __pos;
   if (__pos._M_node == _M_rightmost())
     return _Res(0, _M_rightmost());
   else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
     {
       if (_S_right(__pos._M_node) == 0)
  return _Res(0, __pos._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else

 return _Res(__pos._M_node, 0);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_unique_(const_iterator __position,

   _Arg&& __v,



   _NodeGen& __node_gen)
    {
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));

      if (__res.second)
 return _M_insert_(__res.first, __res.second,
     std::forward<_Arg>(__v),
     __node_gen);
      return iterator(__res.first);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
    {
      iterator __pos = __position._M_const_cast();
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__pos._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
     return _Res(0, _M_rightmost());
   else
     return _M_get_insert_equal_pos(__k);
 }
      else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
 {

   iterator __before = __pos;
   if (__pos._M_node == _M_leftmost())
     return _Res(_M_leftmost(), _M_leftmost());
   else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
     {
       if (_S_right(__before._M_node) == 0)
  return _Res(0, __before._M_node);
       else
  return _Res(__pos._M_node, __pos._M_node);
     }
   else
     return _M_get_insert_equal_pos(__k);
 }
      else
 {

   iterator __after = __pos;
   if (__pos._M_node == _M_rightmost())
     return _Res(0, _M_rightmost());
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
     {
       if (_S_right(__pos._M_node) == 0)
  return _Res(0, __pos._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _Res(0, 0);
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_equal_(const_iterator __position,

         _Arg&& __v,



         _NodeGen& __node_gen)
      {
 pair<_Base_ptr, _Base_ptr> __res
   = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));

 if (__res.second)
   return _M_insert_(__res.first, __res.second,
       std::forward<_Arg>(__v),
       __node_gen);

 return _M_insert_equal_lower(std::forward<_Arg>(__v));
      }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
    {
      bool __insert_left = (__x != 0 || __p == _M_end()
       || _M_impl._M_key_compare(_S_key(__z),
            _S_key(__p)));

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
    {
      bool __insert_left = (__p == _M_end()
       || !_M_impl._M_key_compare(_S_key(__p),
             _S_key(__z)));

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_lower_node(_Link_type __z)
    {
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower_node(__y, __z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator, bool>
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_unique(_Args&&... __args)
      {
 _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

 try
   {
     typedef pair<iterator, bool> _Res;
     auto __res = _M_get_insert_unique_pos(_S_key(__z));
     if (__res.second)
       return _Res(_M_insert_node(__res.first, __res.second, __z), true);

     _M_drop_node(__z);
     return _Res(iterator(__res.first), false);
   }
 catch(...)
   {
     _M_drop_node(__z);
     throw;
   }
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_equal(_Args&&... __args)
      {
 _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

 try
   {
     auto __res = _M_get_insert_equal_pos(_S_key(__z));
     return _M_insert_node(__res.first, __res.second, __z);
   }
 catch(...)
   {
     _M_drop_node(__z);
     throw;
   }
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
      {
 _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

 try
   {
     auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z));

     if (__res.second)
       return _M_insert_node(__res.first, __res.second, __z);

     _M_drop_node(__z);
     return iterator(__res.first);
   }
 catch(...)
   {
     _M_drop_node(__z);
     throw;
   }
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
      {
 _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);

 try
   {
     auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z));

     if (__res.second)
       return _M_insert_node(__res.first, __res.second, __z);

     return _M_insert_equal_lower_node(__z);
   }
 catch(...)
   {
     _M_drop_node(__z);
     throw;
   }
      }



  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase_aux(const_iterator __position)
    {
      _Link_type __y =
 static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
    (const_cast<_Base_ptr>(__position._M_node),
     this->_M_impl._M_header));
      _M_drop_node(__y);
      --_M_impl._M_node_count;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase_aux(const_iterator __first, const_iterator __last)
    {
      if (__first == begin() && __last == end())
 clear();
      else
 while (__first != __last)
   _M_erase_aux(__first++);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(const _Key& __x)
    {
      pair<iterator, iterator> __p = equal_range(__x);
      const size_type __old_size = size();
      _M_erase_aux(__p.first, __p.second);
      return __old_size - size();
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    find(const _Key& __k)
    {
      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    find(const _Key& __k) const
    {
      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    count(const _Key& __k) const
    {
      pair<const_iterator, const_iterator> __p = equal_range(__k);
      const size_type __n = std::distance(__p.first, __p.second);
      return __n;
    }

  __attribute__ ((__pure__)) unsigned int
  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
         const _Rb_tree_node_base* __root) throw ();

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    bool
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
    {
      if (_M_impl._M_node_count == 0 || begin() == end())
 return _M_impl._M_node_count == 0 && begin() == end()
        && this->_M_impl._M_header._M_left == _M_end()
        && this->_M_impl._M_header._M_right == _M_end();

      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
      for (const_iterator __it = begin(); __it != end(); ++__it)
 {
   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
   _Const_Link_type __L = _S_left(__x);
   _Const_Link_type __R = _S_right(__x);

   if (__x->_M_color == _S_red)
     if ((__L && __L->_M_color == _S_red)
  || (__R && __R->_M_color == _S_red))
       return false;

   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
     return false;
   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
     return false;

   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
     return false;
 }

      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
 return false;
      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
 return false;
      return true;
    }



  template<typename _Key, typename _Val, typename _Sel, typename _Cmp1,
    typename _Alloc, typename _Cmp2>
    struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>;

      static auto&
      _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree)
      { return __tree._M_impl; }
    };



}
# 61 "/usr/include/c++/10/map" 2 3
# 1 "/usr/include/c++/10/bits/stl_map.h" 1 3
# 66 "/usr/include/c++/10/bits/stl_map.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class multimap;
# 98 "/usr/include/c++/10/bits/stl_map.h" 3
  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class map
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:
# 123 "/usr/include/c++/10/bits/stl_map.h" 3
      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
   "std::map must have the same value_type as its allocator");



    public:
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class map<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<value_type>::other _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;


      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;

    public:


      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;


      using node_type = typename _Rep_type::node_type;
      using insert_return_type = typename _Rep_type::insert_return_type;
# 185 "/usr/include/c++/10/bits/stl_map.h" 3
      map() = default;







      explicit
      map(const _Compare& __comp,
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a)) { }
# 207 "/usr/include/c++/10/bits/stl_map.h" 3
      map(const map&) = default;







      map(map&&) = default;
# 228 "/usr/include/c++/10/bits/stl_map.h" 3
      map(initializer_list<value_type> __l,
   const _Compare& __comp = _Compare(),
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      explicit
      map(const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a)) { }


      map(const map& __m, const allocator_type& __a)
      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }


      map(map&& __m, const allocator_type& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }


      map(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last,
     const allocator_type& __a)
 : _M_t(_Pair_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }
# 272 "/usr/include/c++/10/bits/stl_map.h" 3
      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_unique(__first, __last); }
# 289 "/usr/include/c++/10/bits/stl_map.h" 3
      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Pair_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }







      ~map() = default;
# 318 "/usr/include/c++/10/bits/stl_map.h" 3
      map&
      operator=(const map&) = default;


      map&
      operator=(map&&) = default;
# 336 "/usr/include/c++/10/bits/stl_map.h" 3
      map&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_unique(__l.begin(), __l.end());
 return *this;
      }



      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }







      iterator
      begin() noexcept
      { return _M_t.begin(); }






      const_iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() noexcept
      { return _M_t.end(); }






      const_iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() noexcept
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      const_iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      const_iterator
      cend() const noexcept
      { return _M_t.end(); }






      const_reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }






      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 491 "/usr/include/c++/10/bits/stl_map.h" 3
      mapped_type&
      operator[](const key_type& __k)
      {



 iterator __i = lower_bound(__k);

 if (__i == end() || key_comp()(__k, (*__i).first))

   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
         std::tuple<const key_type&>(__k),
         std::tuple<>());



 return (*__i).second;
      }


      mapped_type&
      operator[](key_type&& __k)
      {



 iterator __i = lower_bound(__k);

 if (__i == end() || key_comp()(__k, (*__i).first))
   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
     std::forward_as_tuple(std::move(__k)),
     std::tuple<>());
 return (*__i).second;
      }
# 536 "/usr/include/c++/10/bits/stl_map.h" 3
      mapped_type&
      at(const key_type& __k)
      {
 iterator __i = lower_bound(__k);
 if (__i == end() || key_comp()(__k, (*__i).first))
   __throw_out_of_range(("map::at"));
 return (*__i).second;
      }

      const mapped_type&
      at(const key_type& __k) const
      {
 const_iterator __i = lower_bound(__k);
 if (__i == end() || key_comp()(__k, (*__i).first))
   __throw_out_of_range(("map::at"));
 return (*__i).second;
      }
# 574 "/usr/include/c++/10/bits/stl_map.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
# 604 "/usr/include/c++/10/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 (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/stl_map.h", 618, __PRETTY_FUNCTION__, "__pos != end()"); } 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 class std::_Rb_tree_merge_helper;

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }
# 689 "/usr/include/c++/10/bits/stl_map.h" 3
      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(const key_type& __k, _Args&&... __args)
 {
   iterator __i = lower_bound(__k);
   if (__i == end() || key_comp()(__k, (*__i).first))
     {
       __i = emplace_hint(__i, std::piecewise_construct,
     std::forward_as_tuple(__k),
     std::forward_as_tuple(
       std::forward<_Args>(__args)...));
       return {__i, true};
     }
   return {__i, false};
 }


      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(key_type&& __k, _Args&&... __args)
 {
   iterator __i = lower_bound(__k);
   if (__i == end() || key_comp()(__k, (*__i).first))
     {
       __i = emplace_hint(__i, std::piecewise_construct,
     std::forward_as_tuple(std::move(__k)),
     std::forward_as_tuple(
       std::forward<_Args>(__args)...));
       return {__i, true};
     }
   return {__i, false};
 }
# 749 "/usr/include/c++/10/bits/stl_map.h" 3
      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, const key_type& __k,
      _Args&&... __args)
 {
   iterator __i;
   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
   if (__true_hint.second)
     __i = emplace_hint(iterator(__true_hint.second),
          std::piecewise_construct,
          std::forward_as_tuple(__k),
          std::forward_as_tuple(
     std::forward<_Args>(__args)...));
   else
     __i = iterator(__true_hint.first);
   return __i;
 }


      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
 {
   iterator __i;
   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
   if (__true_hint.second)
     __i = emplace_hint(iterator(__true_hint.second),
          std::piecewise_construct,
          std::forward_as_tuple(std::move(__k)),
          std::forward_as_tuple(
     std::forward<_Args>(__args)...));
   else
     __i = iterator(__true_hint.first);
   return __i;
 }
# 802 "/usr/include/c++/10/bits/stl_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_t._M_insert_unique(__x); }




      std::pair<iterator, bool>
      insert(value_type&& __x)
      { return _M_t._M_insert_unique(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair>::value,
        pair<iterator, bool>>
 insert(_Pair&& __x)
 { return _M_t._M_emplace_unique(std::forward<_Pair>(__x)); }
# 829 "/usr/include/c++/10/bits/stl_map.h" 3
      void
      insert(std::initializer_list<value_type> __list)
      { insert(__list.begin(), __list.end()); }
# 858 "/usr/include/c++/10/bits/stl_map.h" 3
      iterator

      insert(const_iterator __position, const value_type& __x)



      { return _M_t._M_insert_unique_(__position, __x); }




      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_t._M_insert_unique_(__position, std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
 insert(const_iterator __position, _Pair&& __x)
 {
   return _M_t._M_emplace_hint_unique(__position,
          std::forward<_Pair>(__x));
 }
# 891 "/usr/include/c++/10/bits/stl_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_unique(__first, __last); }
# 917 "/usr/include/c++/10/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};
 }
# 972 "/usr/include/c++/10/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;
 }
# 1031 "/usr/include/c++/10/bits/stl_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }


      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(iterator __position)
      { return _M_t.erase(__position); }
# 1068 "/usr/include/c++/10/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 1088 "/usr/include/c++/10/bits/stl_map.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 1122 "/usr/include/c++/10/bits/stl_map.h" 3
      void
      swap(map& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }







      void
      clear() noexcept
      { _M_t.clear(); }






      key_compare
      key_comp() const
      { return _M_t.key_comp(); }





      value_compare
      value_comp() const
      { return value_compare(_M_t.key_comp()); }
# 1169 "/usr/include/c++/10/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); }
# 1194 "/usr/include/c++/10/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); }
# 1215 "/usr/include/c++/10/bits/stl_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 1258 "/usr/include/c++/10/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)); }
# 1283 "/usr/include/c++/10/bits/stl_map.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<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)); }
# 1303 "/usr/include/c++/10/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)); }
# 1323 "/usr/include/c++/10/bits/stl_map.h" 3
      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<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)); }
# 1352 "/usr/include/c++/10/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)); }
# 1381 "/usr/include/c++/10/bits/stl_map.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x)))
 {
   return pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x));
 }



      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator==(const map<_K1, _T1, _C1, _A1>&,
     const map<_K1, _T1, _C1, _A1>&);

      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator<(const map<_K1, _T1, _C1, _A1>&,
    const map<_K1, _T1, _C1, _A1>&);
    };




  template<typename _InputIterator,
    typename _Compare = less<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    map(_InputIterator, _InputIterator,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
    _Compare, _Allocator>;

  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    map(initializer_list<pair<_Key, _Tp>>,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> map<_Key, _Tp, _Compare, _Allocator>;

  template <typename _InputIterator, typename _Allocator,
     typename = _RequireInputIter<_InputIterator>,
     typename = _RequireAllocator<_Allocator>>
    map(_InputIterator, _InputIterator, _Allocator)
    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
    less<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    map(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> map<_Key, _Tp, less<_Key>, _Allocator>;
# 1455 "/usr/include/c++/10/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; }
# 1472 "/usr/include/c++/10/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
       const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
        const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
       const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
        const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
        const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
  map<_Key, _Tp, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
    typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::map<_Key, _Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::map<_Key, _Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }

      static auto&
      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }
    };



}
# 62 "/usr/include/c++/10/map" 2 3
# 1 "/usr/include/c++/10/bits/stl_multimap.h" 1 3
# 64 "/usr/include/c++/10/bits/stl_multimap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class map;
# 96 "/usr/include/c++/10/bits/stl_multimap.h" 3
  template <typename _Key, typename _Tp,
     typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class multimap
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:
# 122 "/usr/include/c++/10/bits/stl_multimap.h" 3
      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
   "std::multimap must have the same value_type as its allocator");



    public:
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class multimap<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<value_type>::other _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;

      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;

    public:


      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;


      using node_type = typename _Rep_type::node_type;
# 182 "/usr/include/c++/10/bits/stl_multimap.h" 3
      multimap() = default;







      explicit
      multimap(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a)) { }
# 204 "/usr/include/c++/10/bits/stl_multimap.h" 3
      multimap(const multimap&) = default;
# 213 "/usr/include/c++/10/bits/stl_multimap.h" 3
      multimap(multimap&&) = default;
# 225 "/usr/include/c++/10/bits/stl_multimap.h" 3
      multimap(initializer_list<value_type> __l,
        const _Compare& __comp = _Compare(),
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      explicit
      multimap(const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a)) { }


      multimap(const multimap& __m, const allocator_type& __a)
      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }


      multimap(multimap&& __m, const allocator_type& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }


      multimap(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last,
   const allocator_type& __a)
 : _M_t(_Pair_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }
# 268 "/usr/include/c++/10/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_equal(__first, __last); }
# 284 "/usr/include/c++/10/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Pair_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }







      ~multimap() = default;
# 313 "/usr/include/c++/10/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap&) = default;


      multimap&
      operator=(multimap&&) = default;
# 331 "/usr/include/c++/10/bits/stl_multimap.h" 3
      multimap&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_equal(__l.begin(), __l.end());
 return *this;
      }



      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }







      iterator
      begin() noexcept
      { return _M_t.begin(); }






      const_iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() noexcept
      { return _M_t.end(); }






      const_iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() noexcept
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      const_iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      const_iterator
      cend() const noexcept
      { return _M_t.end(); }






      const_reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }




      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 489 "/usr/include/c++/10/bits/stl_multimap.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
# 516 "/usr/include/c++/10/bits/stl_multimap.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_equal(__pos,
         std::forward<_Args>(__args)...);
 }
# 538 "/usr/include/c++/10/bits/stl_multimap.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }




      iterator
      insert(value_type&& __x)
      { return _M_t._M_insert_equal(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
 insert(_Pair&& __x)
 { return _M_t._M_emplace_equal(std::forward<_Pair>(__x)); }
# 577 "/usr/include/c++/10/bits/stl_multimap.h" 3
      iterator

      insert(const_iterator __position, const value_type& __x)



      { return _M_t._M_insert_equal_(__position, __x); }




      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_t._M_insert_equal_(__position, std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
 insert(const_iterator __position, _Pair&& __x)
 {
   return _M_t._M_emplace_hint_equal(__position,
         std::forward<_Pair>(__x));
 }
# 611 "/usr/include/c++/10/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_equal(__first, __last); }
# 624 "/usr/include/c++/10/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 (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/stl_multimap.h", 634, __PRETTY_FUNCTION__, "__pos != end()"); } 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 class std::_Rb_tree_merge_helper;

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }
# 701 "/usr/include/c++/10/bits/stl_multimap.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }


      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(iterator __position)
      { return _M_t.erase(__position); }
# 738 "/usr/include/c++/10/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 759 "/usr/include/c++/10/bits/stl_multimap.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 796 "/usr/include/c++/10/bits/stl_multimap.h" 3
      void
      swap(multimap& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }







      void
      clear() noexcept
      { _M_t.clear(); }






      key_compare
      key_comp() const
      { return _M_t.key_comp(); }





      value_compare
      value_comp() const
      { return value_compare(_M_t.key_comp()); }
# 842 "/usr/include/c++/10/bits/stl_multimap.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
 { return _M_t._M_find_tr(__x); }
# 866 "/usr/include/c++/10/bits/stl_multimap.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
 { return _M_t._M_find_tr(__x); }
# 884 "/usr/include/c++/10/bits/stl_multimap.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 927 "/usr/include/c++/10/bits/stl_multimap.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }
# 952 "/usr/include/c++/10/bits/stl_multimap.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x)))
 { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
# 972 "/usr/include/c++/10/bits/stl_multimap.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }
# 992 "/usr/include/c++/10/bits/stl_multimap.h" 3
      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x)))
 { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
# 1019 "/usr/include/c++/10/bits/stl_multimap.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
# 1046 "/usr/include/c++/10/bits/stl_multimap.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x)))
 {
   return pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x));
 }



      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator==(const multimap<_K1, _T1, _C1, _A1>&,
     const multimap<_K1, _T1, _C1, _A1>&);

      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator<(const multimap<_K1, _T1, _C1, _A1>&,
    const multimap<_K1, _T1, _C1, _A1>&);
  };



  template<typename _InputIterator,
    typename _Compare = less<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multimap(_InputIterator, _InputIterator,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
  _Compare, _Allocator>;

  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multimap(initializer_list<pair<_Key, _Tp>>,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multimap<_Key, _Tp, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    multimap(_InputIterator, _InputIterator, _Allocator)
    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
  less<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> multimap<_Key, _Tp, less<_Key>, _Allocator>;
# 1119 "/usr/include/c++/10/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; }
# 1136 "/usr/include/c++/10/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
       const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
       const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
  multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
    typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::multimap<_Key, _Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::multimap<_Key, _Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }

      static auto&
      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }
    };



}
# 63 "/usr/include/c++/10/map" 2 3
# 71 "/usr/include/c++/10/map" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Tp> class polymorphic_allocator;
    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
      using map
 = std::map<_Key, _Tp, _Cmp,
     polymorphic_allocator<pair<const _Key, _Tp>>>;
    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
      using multimap
 = std::multimap<_Key, _Tp, _Cmp,
   polymorphic_allocator<pair<const _Key, _Tp>>>;
  }

}
# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/container_fwd.hpp" 2 3 4
# 1 "/usr/include/c++/10/set" 1 3 4
# 58 "/usr/include/c++/10/set" 3 4
       
# 59 "/usr/include/c++/10/set" 3


# 1 "/usr/include/c++/10/bits/stl_set.h" 1 3
# 64 "/usr/include/c++/10/bits/stl_set.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Compare, typename _Alloc>
    class multiset;
# 92 "/usr/include/c++/10/bits/stl_set.h" 3
  template<typename _Key, typename _Compare = std::less<_Key>,
    typename _Alloc = std::allocator<_Key> >
    class set
    {
# 108 "/usr/include/c++/10/bits/stl_set.h" 3
      static_assert(is_same<typename remove_cv<_Key>::type, _Key>::value,
   "std::set must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Key>::value,
   "std::set must have the same value_type as its allocator");



    public:



      typedef _Key key_type;
      typedef _Key value_type;
      typedef _Compare key_compare;
      typedef _Compare value_compare;
      typedef _Alloc allocator_type;


    private:
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Key>::other _Key_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
         key_compare, _Key_alloc_type> _Rep_type;
      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;

    public:


      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;



      typedef typename _Rep_type::const_iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;



      using node_type = typename _Rep_type::node_type;
      using insert_return_type = typename _Rep_type::insert_return_type;
# 167 "/usr/include/c++/10/bits/stl_set.h" 3
      set() = default;







      explicit
      set(const _Compare& __comp,
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a)) { }
# 190 "/usr/include/c++/10/bits/stl_set.h" 3
      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_unique(__first, __last); }
# 207 "/usr/include/c++/10/bits/stl_set.h" 3
      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Key_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }
# 223 "/usr/include/c++/10/bits/stl_set.h" 3
      set(const set&) = default;







      set(set&&) = default;
# 243 "/usr/include/c++/10/bits/stl_set.h" 3
      set(initializer_list<value_type> __l,
   const _Compare& __comp = _Compare(),
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      explicit
      set(const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a)) { }


      set(const set& __x, const allocator_type& __a)
      : _M_t(__x._M_t, _Key_alloc_type(__a)) { }


      set(set&& __x, const allocator_type& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { }


      set(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last,
     const allocator_type& __a)
 : _M_t(_Key_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }






      ~set() = default;
# 297 "/usr/include/c++/10/bits/stl_set.h" 3
      set&
      operator=(const set&) = default;


      set&
      operator=(set&&) = default;
# 315 "/usr/include/c++/10/bits/stl_set.h" 3
      set&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_unique(__l.begin(), __l.end());
 return *this;
      }





      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }






      iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      iterator
      cend() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }



      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 440 "/usr/include/c++/10/bits/stl_set.h" 3
      void
      swap(set& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }
# 460 "/usr/include/c++/10/bits/stl_set.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
# 486 "/usr/include/c++/10/bits/stl_set.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_unique(__pos,
          std::forward<_Args>(__args)...);
 }
# 508 "/usr/include/c++/10/bits/stl_set.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      {
 std::pair<typename _Rep_type::iterator, bool> __p =
   _M_t._M_insert_unique(__x);
 return std::pair<iterator, bool>(__p.first, __p.second);
      }


      std::pair<iterator, bool>
      insert(value_type&& __x)
      {
 std::pair<typename _Rep_type::iterator, bool> __p =
   _M_t._M_insert_unique(std::move(__x));
 return std::pair<iterator, bool>(__p.first, __p.second);
      }
# 545 "/usr/include/c++/10/bits/stl_set.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x)
      { return _M_t._M_insert_unique_(__position, __x); }


      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_t._M_insert_unique_(__position, std::move(__x)); }
# 564 "/usr/include/c++/10/bits/stl_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_unique(__first, __last); }
# 577 "/usr/include/c++/10/bits/stl_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }




      node_type
      extract(const_iterator __pos)
      {
 do { if (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/stl_set.h", 587, __PRETTY_FUNCTION__, "__pos != end()"); } 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 class std::_Rb_tree_merge_helper;

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }
# 652 "/usr/include/c++/10/bits/stl_set.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }
# 683 "/usr/include/c++/10/bits/stl_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 704 "/usr/include/c++/10/bits/stl_set.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 732 "/usr/include/c++/10/bits/stl_set.h" 3
      void
      clear() noexcept
      { _M_t.clear(); }
# 747 "/usr/include/c++/10/bits/stl_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const
 -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 793 "/usr/include/c++/10/bits/stl_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x)
 -> decltype(iterator{_M_t._M_find_tr(__x)})
 { return iterator{_M_t._M_find_tr(__x)}; }

      template<typename _Kt>
 auto
 find(const _Kt& __x) const
 -> decltype(const_iterator{_M_t._M_find_tr(__x)})
 { return const_iterator{_M_t._M_find_tr(__x)}; }
# 828 "/usr/include/c++/10/bits/stl_set.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }

      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }

      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x)))
 { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
# 858 "/usr/include/c++/10/bits/stl_set.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }

      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }

      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x) const
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
# 897 "/usr/include/c++/10/bits/stl_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }

      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }



      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);

      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
    };



  template<typename _InputIterator,
    typename _Compare =
      less<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> set<typename iterator_traits<_InputIterator>::value_type,
   _Compare, _Allocator>;

  template<typename _Key, typename _Compare = less<_Key>,
    typename _Allocator = allocator<_Key>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> set<_Key, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator, _Allocator)
    -> set<typename iterator_traits<_InputIterator>::value_type,
    less<typename iterator_traits<_InputIterator>::value_type>,
    _Allocator>;

  template<typename _Key, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>, _Allocator)
    -> set<_Key, less<_Key>, _Allocator>;
# 977 "/usr/include/c++/10/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; }
# 994 "/usr/include/c++/10/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<(const set<_Key, _Compare, _Alloc>& __x,
       const set<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>(const set<_Key, _Compare, _Alloc>& __x,
       const set<_Key, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::set<_Val, _Cmp1, _Alloc>, _Cmp2>
    {
    private:
      friend class std::set<_Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }

      static auto&
      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }
    };
# 1065 "/usr/include/c++/10/bits/stl_set.h" 3

}
# 62 "/usr/include/c++/10/set" 2 3
# 1 "/usr/include/c++/10/bits/stl_multiset.h" 1 3
# 64 "/usr/include/c++/10/bits/stl_multiset.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Compare, typename _Alloc>
    class set;
# 94 "/usr/include/c++/10/bits/stl_multiset.h" 3
  template <typename _Key, typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<_Key> >
    class multiset
    {
# 110 "/usr/include/c++/10/bits/stl_multiset.h" 3
      static_assert(is_same<typename remove_cv<_Key>::type, _Key>::value,
   "std::multiset must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Key>::value,
   "std::multiset must have the same value_type as its allocator");



    public:

      typedef _Key key_type;
      typedef _Key value_type;
      typedef _Compare key_compare;
      typedef _Compare value_compare;
      typedef _Alloc allocator_type;

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Key>::other _Key_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
         key_compare, _Key_alloc_type> _Rep_type;

      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;

    public:
      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;



      typedef typename _Rep_type::const_iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;


      using node_type = typename _Rep_type::node_type;
# 164 "/usr/include/c++/10/bits/stl_multiset.h" 3
      multiset() = default;







      explicit
      multiset(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a)) { }
# 186 "/usr/include/c++/10/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_equal(__first, __last); }
# 202 "/usr/include/c++/10/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Key_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }
# 218 "/usr/include/c++/10/bits/stl_multiset.h" 3
      multiset(const multiset&) = default;
# 227 "/usr/include/c++/10/bits/stl_multiset.h" 3
      multiset(multiset&&) = default;
# 239 "/usr/include/c++/10/bits/stl_multiset.h" 3
      multiset(initializer_list<value_type> __l,
        const _Compare& __comp = _Compare(),
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      explicit
      multiset(const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a)) { }


      multiset(const multiset& __m, const allocator_type& __a)
      : _M_t(__m._M_t, _Key_alloc_type(__a)) { }


      multiset(multiset&& __m, const allocator_type& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { }


      multiset(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last,
   const allocator_type& __a)
 : _M_t(_Key_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }






      ~multiset() = default;
# 293 "/usr/include/c++/10/bits/stl_multiset.h" 3
      multiset&
      operator=(const multiset&) = default;


      multiset&
      operator=(multiset&&) = default;
# 311 "/usr/include/c++/10/bits/stl_multiset.h" 3
      multiset&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_equal(__l.begin(), __l.end());
 return *this;
      }





      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }






      iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      iterator
      cend() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }



      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 436 "/usr/include/c++/10/bits/stl_multiset.h" 3
      void
      swap(multiset& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }
# 455 "/usr/include/c++/10/bits/stl_multiset.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
# 481 "/usr/include/c++/10/bits/stl_multiset.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_equal(__pos,
         std::forward<_Args>(__args)...);
 }
# 501 "/usr/include/c++/10/bits/stl_multiset.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }


      iterator
      insert(value_type&& __x)
      { return _M_t._M_insert_equal(std::move(__x)); }
# 531 "/usr/include/c++/10/bits/stl_multiset.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x)
      { return _M_t._M_insert_equal_(__position, __x); }


      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_t._M_insert_equal_(__position, std::move(__x)); }
# 549 "/usr/include/c++/10/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_equal(__first, __last); }
# 562 "/usr/include/c++/10/bits/stl_multiset.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }




      node_type
      extract(const_iterator __pos)
      {
 do { if (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/stl_multiset.h", 572, __PRETTY_FUNCTION__, "__pos != end()"); } 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 class std::_Rb_tree_merge_helper;

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }
# 637 "/usr/include/c++/10/bits/stl_multiset.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }
# 668 "/usr/include/c++/10/bits/stl_multiset.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 689 "/usr/include/c++/10/bits/stl_multiset.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 717 "/usr/include/c++/10/bits/stl_multiset.h" 3
      void
      clear() noexcept
      { _M_t.clear(); }
# 729 "/usr/include/c++/10/bits/stl_multiset.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 774 "/usr/include/c++/10/bits/stl_multiset.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x)
 -> decltype(iterator{_M_t._M_find_tr(__x)})
 { return iterator{_M_t._M_find_tr(__x)}; }

      template<typename _Kt>
 auto
 find(const _Kt& __x) const
 -> decltype(const_iterator{_M_t._M_find_tr(__x)})
 { return const_iterator{_M_t._M_find_tr(__x)}; }
# 809 "/usr/include/c++/10/bits/stl_multiset.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }

      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }

      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x) const
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }
# 839 "/usr/include/c++/10/bits/stl_multiset.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }

      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }

      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x) const
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }
# 878 "/usr/include/c++/10/bits/stl_multiset.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }

      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }



      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator==(const multiset<_K1, _C1, _A1>&,
     const multiset<_K1, _C1, _A1>&);

      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator< (const multiset<_K1, _C1, _A1>&,
     const multiset<_K1, _C1, _A1>&);
    };



  template<typename _InputIterator,
    typename _Compare =
      less<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multiset(_InputIterator, _InputIterator,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multiset<typename iterator_traits<_InputIterator>::value_type,
  _Compare, _Allocator>;

  template<typename _Key,
    typename _Compare = less<_Key>,
    typename _Allocator = allocator<_Key>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multiset(initializer_list<_Key>,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multiset<_Key, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    multiset(_InputIterator, _InputIterator, _Allocator)
    -> multiset<typename iterator_traits<_InputIterator>::value_type,
         less<typename iterator_traits<_InputIterator>::value_type>,
         _Allocator>;

  template<typename _Key, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    multiset(initializer_list<_Key>, _Allocator)
    -> multiset<_Key, less<_Key>, _Allocator>;
# 962 "/usr/include/c++/10/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; }
# 979 "/usr/include/c++/10/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
       const multiset<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>(const multiset<_Key,_Compare,_Alloc>& __x,
       const multiset<_Key,_Compare,_Alloc>& __y)
    { return __y < __x; }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(multiset<_Key, _Compare, _Alloc>& __x,
  multiset<_Key, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::multiset<_Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::multiset<_Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }

      static auto&
      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }
    };
# 1054 "/usr/include/c++/10/bits/stl_multiset.h" 3

}
# 63 "/usr/include/c++/10/set" 2 3
# 71 "/usr/include/c++/10/set" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Tp> class polymorphic_allocator;
    template<typename _Key, typename _Cmp = std::less<_Key>>
      using set = std::set<_Key, _Cmp, polymorphic_allocator<_Key>>;
    template<typename _Key, typename _Cmp = std::less<_Key>>
      using multiset = std::multiset<_Key, _Cmp, polymorphic_allocator<_Key>>;
  }

}
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/container_fwd.hpp" 2 3 4
# 1 "/usr/include/c++/10/bitset" 1 3 4
# 45 "/usr/include/c++/10/bitset" 3 4
       
# 46 "/usr/include/c++/10/bitset" 3
# 64 "/usr/include/c++/10/bitset" 3
namespace std __attribute__ ((__visibility__ ("default")))
{








  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); }

      _WordT&
      _M_getword(size_t __pos) noexcept
      { return _M_w[_S_whichword(__pos)]; }

      constexpr _WordT
      _M_getword(size_t __pos) const noexcept
      { return _M_w[_S_whichword(__pos)]; }


      const _WordT*
      _M_getdata() const noexcept
      { return _M_w; }


      _WordT&
      _M_hiword() noexcept
      { return _M_w[_Nw - 1]; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return _M_w[_Nw - 1]; }

      void
      _M_do_and(const _Base_bitset<_Nw>& __x) noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] &= __x._M_w[__i];
      }

      void
      _M_do_or(const _Base_bitset<_Nw>& __x) noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] |= __x._M_w[__i];
      }

      void
      _M_do_xor(const _Base_bitset<_Nw>& __x) noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] ^= __x._M_w[__i];
      }

      void
      _M_do_left_shift(size_t __shift) noexcept;

      void
      _M_do_right_shift(size_t __shift) noexcept;

      void
      _M_do_flip() noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] = ~_M_w[__i];
      }

      void
      _M_do_set() noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] = ~static_cast<_WordT>(0);
      }

      void
      _M_do_reset() noexcept
      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }

      bool
      _M_is_equal(const _Base_bitset<_Nw>& __x) const noexcept
      {
 for (size_t __i = 0; __i < _Nw; ++__i)
   if (_M_w[__i] != __x._M_w[__i])
     return false;
 return true;
      }

      template<size_t _Nb>
        bool
        _M_are_all() const noexcept
        {
   for (size_t __i = 0; __i < _Nw - 1; __i++)
     if (_M_w[__i] != ~static_cast<_WordT>(0))
       return false;
   return _M_hiword() == (~static_cast<_WordT>(0)
     >> (_Nw * (8 * 8)
         - _Nb));
 }

      bool
      _M_is_any() const noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   if (_M_w[__i] != static_cast<_WordT>(0))
     return true;
 return false;
      }

      size_t
      _M_do_count() const noexcept
      {
 size_t __result = 0;
 for (size_t __i = 0; __i < _Nw; __i++)
   __result += __builtin_popcountl(_M_w[__i]);
 return __result;
      }

      unsigned long
      _M_do_to_ulong() const;


      unsigned long long
      _M_do_to_ullong() const;



      size_t
      _M_do_find_first(size_t) const noexcept;


      size_t
      _M_do_find_next(size_t, size_t) const noexcept;
    };


  template<size_t _Nw>
    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>
    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>
    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>
    unsigned long long
    _Base_bitset<_Nw>::_M_do_to_ullong() const
    {
      const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long);
      for (size_t __i = 1 + __dw; __i < _Nw; ++__i)
 if (_M_w[__i])
   __throw_overflow_error(("_Base_bitset::_M_do_to_ullong"));

      if (__dw)
 return _M_w[0] + (static_cast<unsigned long long>(_M_w[1])
     << (8 * 8));
      return _M_w[0];
    }


  template<size_t _Nw>
    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>
    size_t
    _Base_bitset<_Nw>::
    _M_do_find_next(size_t __prev, size_t __not_found) const noexcept
    {

      ++__prev;


      if (__prev >= _Nw * (8 * 8))
 return __not_found;


      size_t __i = _S_whichword(__prev);
      _WordT __thisword = _M_w[__i];


      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);

      if (__thisword != static_cast<_WordT>(0))
 return (__i * (8 * 8)
  + __builtin_ctzl(__thisword));


      __i++;
      for (; __i < _Nw; __i++)
 {
   __thisword = _M_w[__i];
   if (__thisword != static_cast<_WordT>(0))
     return (__i * (8 * 8)
      + __builtin_ctzl(__thisword));
 }

      return __not_found;
    }






  template<>
    struct _Base_bitset<1>
    {
      typedef unsigned long _WordT;
      _WordT _M_w;

      constexpr _Base_bitset() noexcept
      : _M_w(0)
      { }


      constexpr _Base_bitset(unsigned long long __val) noexcept



      : _M_w(__val)
      { }

      static constexpr size_t
      _S_whichword(size_t __pos) noexcept
      { return __pos / (8 * 8); }

      static constexpr size_t
      _S_whichbyte(size_t __pos) noexcept
      { return (__pos % (8 * 8)) / 8; }

      static constexpr size_t
      _S_whichbit(size_t __pos) noexcept
      { return __pos % (8 * 8); }

      static constexpr _WordT
      _S_maskbit(size_t __pos) noexcept
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      _WordT&
      _M_getword(size_t) noexcept
      { return _M_w; }

      constexpr _WordT
      _M_getword(size_t) const noexcept
      { return _M_w; }


      const _WordT*
      _M_getdata() const noexcept
      { return &_M_w; }


      _WordT&
      _M_hiword() noexcept
      { return _M_w; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return _M_w; }

      void
      _M_do_and(const _Base_bitset<1>& __x) noexcept
      { _M_w &= __x._M_w; }

      void
      _M_do_or(const _Base_bitset<1>& __x) noexcept
      { _M_w |= __x._M_w; }

      void
      _M_do_xor(const _Base_bitset<1>& __x) noexcept
      { _M_w ^= __x._M_w; }

      void
      _M_do_left_shift(size_t __shift) noexcept
      { _M_w <<= __shift; }

      void
      _M_do_right_shift(size_t __shift) noexcept
      { _M_w >>= __shift; }

      void
      _M_do_flip() noexcept
      { _M_w = ~_M_w; }

      void
      _M_do_set() noexcept
      { _M_w = ~static_cast<_WordT>(0); }

      void
      _M_do_reset() noexcept
      { _M_w = 0; }

      bool
      _M_is_equal(const _Base_bitset<1>& __x) const noexcept
      { return _M_w == __x._M_w; }

      template<size_t _Nb>
        bool
        _M_are_all() const noexcept
        { return _M_w == (~static_cast<_WordT>(0)
     >> ((8 * 8) - _Nb)); }

      bool
      _M_is_any() const noexcept
      { return _M_w != 0; }

      size_t
      _M_do_count() const noexcept
      { return __builtin_popcountl(_M_w); }

      unsigned long
      _M_do_to_ulong() const noexcept
      { return _M_w; }


      unsigned long long
      _M_do_to_ullong() const noexcept
      { return _M_w; }


      size_t
      _M_do_find_first(size_t __not_found) const noexcept
      {
        if (_M_w != 0)
          return __builtin_ctzl(_M_w);
        else
          return __not_found;
      }


      size_t
      _M_do_find_next(size_t __prev, size_t __not_found) const
 noexcept
      {
 ++__prev;
 if (__prev >= ((size_t) (8 * 8)))
   return __not_found;

 _WordT __x = _M_w >> __prev;
 if (__x != 0)
   return __builtin_ctzl(__x) + __prev;
 else
   return __not_found;
      }
    };






  template<>
    struct _Base_bitset<0>
    {
      typedef unsigned long _WordT;

      constexpr _Base_bitset() noexcept
      { }


      constexpr _Base_bitset(unsigned long long) noexcept



      { }

      static constexpr size_t
      _S_whichword(size_t __pos) noexcept
      { return __pos / (8 * 8); }

      static constexpr size_t
      _S_whichbyte(size_t __pos) noexcept
      { return (__pos % (8 * 8)) / 8; }

      static constexpr size_t
      _S_whichbit(size_t __pos) noexcept
      { return __pos % (8 * 8); }

      static constexpr _WordT
      _S_maskbit(size_t __pos) noexcept
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
# 560 "/usr/include/c++/10/bitset" 3
      _WordT&
      _M_getword(size_t) noexcept
      {
 __throw_out_of_range(("_Base_bitset::_M_getword"));
 return *new _WordT;
      }

      constexpr _WordT
      _M_getword(size_t) const noexcept
      { return 0; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return 0; }

      void
      _M_do_and(const _Base_bitset<0>&) noexcept
      { }

      void
      _M_do_or(const _Base_bitset<0>&) noexcept
      { }

      void
      _M_do_xor(const _Base_bitset<0>&) noexcept
      { }

      void
      _M_do_left_shift(size_t) noexcept
      { }

      void
      _M_do_right_shift(size_t) noexcept
      { }

      void
      _M_do_flip() noexcept
      { }

      void
      _M_do_set() noexcept
      { }

      void
      _M_do_reset() noexcept
      { }




      bool
      _M_is_equal(const _Base_bitset<0>&) const noexcept
      { return true; }

      template<size_t _Nb>
        bool
        _M_are_all() const noexcept
        { return true; }

      bool
      _M_is_any() const noexcept
      { return false; }

      size_t
      _M_do_count() const noexcept
      { return 0; }

      unsigned long
      _M_do_to_ulong() const noexcept
      { return 0; }


      unsigned long long
      _M_do_to_ullong() const noexcept
      { return 0; }




      size_t
      _M_do_find_first(size_t) const noexcept
      { return 0; }

      size_t
      _M_do_find_next(size_t, size_t) const noexcept
      { return 0; }
    };



  template<size_t _Extrabits>
    struct _Sanitize
    {
      typedef unsigned long _WordT;

      static void
      _S_do_sanitize(_WordT& __val) noexcept
      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
    };

  template<>
    struct _Sanitize<0>
    {
      typedef unsigned long _WordT;

      static void
      _S_do_sanitize(_WordT) noexcept { }
    };


  template<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); }
    };
# 750 "/usr/include/c++/10/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>
      void
      _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
    size_t __position) const
      {
 if (__position > __s.size())
   __throw_out_of_range_fmt(("bitset::bitset: __position " "(which is %zu) > __s.size() " "(which is %zu)")

                            ,
       __position, __s.size());
      }

      void _M_check(size_t __position, const char *__s) const
      {
 if (__position >= _Nb)
   __throw_out_of_range_fmt(("%s: __position (which is %zu) " ">= _Nb (which is %zu)")
                                   ,
       __s, __position, _Nb);
      }

      void
      _M_do_sanitize() noexcept
      {
 typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
 __sanitize_type::_S_do_sanitize(this->_M_hiword());
      }


      friend struct std::hash<bitset>;


    public:
# 802 "/usr/include/c++/10/bitset" 3
      class reference
      {
 friend class bitset;

 _WordT* _M_wp;
 size_t _M_bpos;


 reference();

      public:
 reference(bitset& __b, size_t __pos) noexcept
 {
   _M_wp = &__b._M_getword(__pos);
   _M_bpos = _Base::_S_whichbit(__pos);
 }


 reference(const reference&) = default;


 ~reference() noexcept
 { }


 reference&
 operator=(bool __x) noexcept
 {
   if (__x)
     *_M_wp |= _Base::_S_maskbit(_M_bpos);
   else
     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
   return *this;
 }


 reference&
 operator=(const reference& __j) noexcept
 {
   if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
     *_M_wp |= _Base::_S_maskbit(_M_bpos);
   else
     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
   return *this;
 }


 bool
 operator~() const noexcept
 { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }


 operator bool() const noexcept
 { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }


 reference&
 flip() noexcept
 {
   *_M_wp ^= _Base::_S_maskbit(_M_bpos);
   return *this;
 }
      };
      friend class reference;



      constexpr bitset() noexcept
      { }



      constexpr bitset(unsigned long long __val) noexcept
      : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }
# 891 "/usr/include/c++/10/bitset" 3
      template<class _CharT, class _Traits, class _Alloc>
 explicit
 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
        size_t __position = 0)
 : _Base()
 {
   _M_check_initial_position(__s, __position);
   _M_copy_from_string(__s, __position,
         std::basic_string<_CharT, _Traits, _Alloc>::npos,
         _CharT('0'), _CharT('1'));
 }
# 913 "/usr/include/c++/10/bitset" 3
      template<class _CharT, class _Traits, class _Alloc>
 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>
 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
        size_t __position, size_t __n,
        _CharT __zero, _CharT __one = _CharT('1'))
 : _Base()
 {
   _M_check_initial_position(__s, __position);
   _M_copy_from_string(__s, __position, __n, __zero, __one);
 }
# 944 "/usr/include/c++/10/bitset" 3
      template<typename _CharT>
        explicit
        bitset(const _CharT* __str,
        typename std::basic_string<_CharT>::size_type __n
        = std::basic_string<_CharT>::npos,
        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
        : _Base()
        {
   if (!__str)
     __throw_logic_error(("bitset::bitset(const _CharT*, ...)"));

   if (__n == std::basic_string<_CharT>::npos)
     __n = std::char_traits<_CharT>::length(__str);
   _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
            __n, __zero,
            __one);
 }
# 971 "/usr/include/c++/10/bitset" 3
      bitset<_Nb>&
      operator&=(const bitset<_Nb>& __rhs) noexcept
      {
 this->_M_do_and(__rhs);
 return *this;
      }

      bitset<_Nb>&
      operator|=(const bitset<_Nb>& __rhs) noexcept
      {
 this->_M_do_or(__rhs);
 return *this;
      }

      bitset<_Nb>&
      operator^=(const bitset<_Nb>& __rhs) noexcept
      {
 this->_M_do_xor(__rhs);
 return *this;
      }
# 1000 "/usr/include/c++/10/bitset" 3
      bitset<_Nb>&
      operator<<=(size_t __position) noexcept
      {
 if (__builtin_expect(__position < _Nb, 1))
   {
     this->_M_do_left_shift(__position);
     this->_M_do_sanitize();
   }
 else
   this->_M_do_reset();
 return *this;
      }

      bitset<_Nb>&
      operator>>=(size_t __position) noexcept
      {
 if (__builtin_expect(__position < _Nb, 1))
   {
     this->_M_do_right_shift(__position);
     this->_M_do_sanitize();
   }
 else
   this->_M_do_reset();
 return *this;
      }
# 1033 "/usr/include/c++/10/bitset" 3
      bitset<_Nb>&
      _Unchecked_set(size_t __pos) noexcept
      {
 this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
 return *this;
      }

      bitset<_Nb>&
      _Unchecked_set(size_t __pos, int __val) noexcept
      {
 if (__val)
   this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
 else
   this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
 return *this;
      }

      bitset<_Nb>&
      _Unchecked_reset(size_t __pos) noexcept
      {
 this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
 return *this;
      }

      bitset<_Nb>&
      _Unchecked_flip(size_t __pos) noexcept
      {
 this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
 return *this;
      }

      constexpr bool
      _Unchecked_test(size_t __pos) const noexcept
      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
  != static_cast<_WordT>(0)); }






      bitset<_Nb>&
      set() noexcept
      {
 this->_M_do_set();
 this->_M_do_sanitize();
 return *this;
      }







      bitset<_Nb>&
      set(size_t __position, bool __val = true)
      {
 this->_M_check(__position, ("bitset::set"));
 return _Unchecked_set(__position, __val);
      }




      bitset<_Nb>&
      reset() noexcept
      {
 this->_M_do_reset();
 return *this;
      }
# 1112 "/usr/include/c++/10/bitset" 3
      bitset<_Nb>&
      reset(size_t __position)
      {
 this->_M_check(__position, ("bitset::reset"));
 return _Unchecked_reset(__position);
      }




      bitset<_Nb>&
      flip() noexcept
      {
 this->_M_do_flip();
 this->_M_do_sanitize();
 return *this;
      }






      bitset<_Nb>&
      flip(size_t __position)
      {
 this->_M_check(__position, ("bitset::flip"));
 return _Unchecked_flip(__position);
      }


      bitset<_Nb>
      operator~() const noexcept
      { return bitset<_Nb>(*this).flip(); }
# 1162 "/usr/include/c++/10/bitset" 3
      reference
      operator[](size_t __position)
      { return reference(*this, __position); }

      constexpr bool
      operator[](size_t __position) const
      { return _Unchecked_test(__position); }
# 1177 "/usr/include/c++/10/bitset" 3
      unsigned long
      to_ulong() const
      { return this->_M_do_to_ulong(); }


      unsigned long long
      to_ullong() const
      { return this->_M_do_to_ullong(); }
# 1195 "/usr/include/c++/10/bitset" 3
      template<class _CharT, class _Traits, class _Alloc>
 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>
 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>
 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
 to_string() const
 { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }



      template<class _CharT, class _Traits>
 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>
 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>
 std::basic_string<_CharT, std::char_traits<_CharT>,
                   std::allocator<_CharT> >
 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
 {
   return to_string<_CharT, std::char_traits<_CharT>,
                    std::allocator<_CharT> >(__zero, __one);
 }

      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
      to_string() const
      {
 return to_string<char, std::char_traits<char>,
                  std::allocator<char> >();
      }

      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);
      }


      template<class _CharT, class _Traits>
        void
        _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
    _CharT, _CharT);

      template<class _CharT, class _Traits, class _Alloc>
 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>
 void
        _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
     _CharT, _CharT) const;


      template<class _CharT, class _Traits, class _Alloc>
 void
 _M_copy_from_string(const std::basic_string<_CharT,
       _Traits, _Alloc>& __s, size_t __pos, size_t __n)
 { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); }

      template<class _CharT, class _Traits, class _Alloc>
 void
        _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
 { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); }


      size_t
      count() const noexcept
      { return this->_M_do_count(); }


      constexpr size_t
      size() const noexcept
      { return _Nb; }



      bool
      operator==(const bitset<_Nb>& __rhs) const noexcept
      { return this->_M_is_equal(__rhs); }

      bool
      operator!=(const bitset<_Nb>& __rhs) const noexcept
      { return !this->_M_is_equal(__rhs); }
# 1320 "/usr/include/c++/10/bitset" 3
      bool
      test(size_t __position) const
      {
 this->_M_check(__position, ("bitset::test"));
 return _Unchecked_test(__position);
      }







      bool
      all() const noexcept
      { return this->template _M_are_all<_Nb>(); }





      bool
      any() const noexcept
      { return this->_M_is_any(); }





      bool
      none() const noexcept
      { return !this->_M_is_any(); }



      bitset<_Nb>
      operator<<(size_t __position) const noexcept
      { return bitset<_Nb>(*this) <<= __position; }

      bitset<_Nb>
      operator>>(size_t __position) const noexcept
      { return bitset<_Nb>(*this) >>= __position; }
# 1370 "/usr/include/c++/10/bitset" 3
      size_t
      _Find_first() const noexcept
      { return this->_M_do_find_first(_Nb); }
# 1381 "/usr/include/c++/10/bitset" 3
      size_t
      _Find_next(size_t __prev) const noexcept
      { return this->_M_do_find_next(__prev, _Nb); }
    };


  template<size_t _Nb>
    template<class _CharT, class _Traits>
      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>
      void
      bitset<_Nb>::
      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
   _CharT __zero, _CharT __one) const
      {
 __s.assign(_Nb, __zero);
 for (size_t __i = _Nb; __i > 0; --__i)
   if (_Unchecked_test(__i - 1))
     _Traits::assign(__s[_Nb - __i], __one);
      }
# 1431 "/usr/include/c++/10/bitset" 3
  template<size_t _Nb>
    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>
    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>
    inline bitset<_Nb>
    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
    {
      bitset<_Nb> __result(__x);
      __result ^= __y;
      return __result;
    }
# 1468 "/usr/include/c++/10/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;

      std::basic_string<_CharT, _Traits> __tmp;
      __tmp.reserve(_Nb);



      const char_type __zero = __is.widen('0');
      const char_type __one = __is.widen('1');

      typename __ios_base::iostate __state = __ios_base::goodbit;
      typename __istream_type::sentry __sentry(__is);
      if (__sentry)
 {
   try
     {
       for (size_t __i = _Nb; __i > 0; --__i)
  {
    static typename _Traits::int_type __eof = _Traits::eof();

    typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
    if (_Traits::eq_int_type(__c1, __eof))
      {
        __state |= __ios_base::eofbit;
        break;
      }
    else
      {
        const char_type __c2 = _Traits::to_char_type(__c1);
        if (_Traits::eq(__c2, __zero))
   __tmp.push_back(__zero);
        else if (_Traits::eq(__c2, __one))
   __tmp.push_back(__one);
        else if (_Traits::
          eq_int_type(__is.rdbuf()->sputbackc(__c2),
        __eof))
   {
     __state |= __ios_base::failbit;
     break;
   }
      }
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __is._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     { __is._M_setstate(__ios_base::badbit); }
 }

      if (__tmp.empty() && _Nb)
 __state |= __ios_base::failbit;
      else
 __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
    __zero, __one);
      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; }
    };


}
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/container_fwd.hpp" 2 3 4

# 1 "/usr/include/c++/10/complex" 1 3 4
# 39 "/usr/include/c++/10/complex" 3 4
       
# 40 "/usr/include/c++/10/complex" 3




# 1 "/usr/include/c++/10/cmath" 1 3
# 39 "/usr/include/c++/10/cmath" 3
       
# 40 "/usr/include/c++/10/cmath" 3
# 45 "/usr/include/c++/10/complex" 2 3
# 1 "/usr/include/c++/10/sstream" 1 3
# 36 "/usr/include/c++/10/sstream" 3
       
# 37 "/usr/include/c++/10/sstream" 3

# 1 "/usr/include/c++/10/istream" 1 3
# 36 "/usr/include/c++/10/istream" 3
       
# 37 "/usr/include/c++/10/istream" 3




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

# 57 "/usr/include/c++/10/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
        __num_get_type;
      typedef ctype<_CharT> __ctype_type;

    protected:





      streamsize _M_gcount;

    public:







      explicit
      basic_istream(__streambuf_type* __sb)
      : _M_gcount(streamsize(0))
      { this->init(__sb); }






      virtual
      ~basic_istream()
      { _M_gcount = streamsize(0); }


      class sentry;
      friend class sentry;
# 119 "/usr/include/c++/10/istream" 3
      __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&))
      { return __pf(*this); }

      __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&))
      {
 __pf(*this);
 return *this;
      }

      __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&))
      {
 __pf(*this);
 return *this;
      }
# 167 "/usr/include/c++/10/istream" 3
      __istream_type&
      operator>>(bool& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(short& __n);

      __istream_type&
      operator>>(unsigned short& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(int& __n);

      __istream_type&
      operator>>(unsigned int& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(long& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(unsigned long& __n)
      { return _M_extract(__n); }


      __istream_type&
      operator>>(long long& __n)
      { return _M_extract(__n); }

      __istream_type&
      operator>>(unsigned long long& __n)
      { return _M_extract(__n); }
# 213 "/usr/include/c++/10/istream" 3
      __istream_type&
      operator>>(float& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(double& __f)
      { return _M_extract(__f); }

      __istream_type&
      operator>>(long double& __f)
      { return _M_extract(__f); }
# 234 "/usr/include/c++/10/istream" 3
      __istream_type&
      operator>>(void*& __p)
      { return _M_extract(__p); }
# 258 "/usr/include/c++/10/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 268 "/usr/include/c++/10/istream" 3
      streamsize
      gcount() const
      { return _M_gcount; }
# 301 "/usr/include/c++/10/istream" 3
      int_type
      get();
# 315 "/usr/include/c++/10/istream" 3
      __istream_type&
      get(char_type& __c);
# 342 "/usr/include/c++/10/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 353 "/usr/include/c++/10/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 376 "/usr/include/c++/10/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 386 "/usr/include/c++/10/istream" 3
      __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 415 "/usr/include/c++/10/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 426 "/usr/include/c++/10/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 450 "/usr/include/c++/10/istream" 3
      __istream_type&
      ignore(streamsize __n, int_type __delim);

      __istream_type&
      ignore(streamsize __n);

      __istream_type&
      ignore();
# 467 "/usr/include/c++/10/istream" 3
      int_type
      peek();
# 485 "/usr/include/c++/10/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 504 "/usr/include/c++/10/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 521 "/usr/include/c++/10/istream" 3
      __istream_type&
      putback(char_type __c);
# 537 "/usr/include/c++/10/istream" 3
      __istream_type&
      unget();
# 555 "/usr/include/c++/10/istream" 3
      int
      sync();
# 570 "/usr/include/c++/10/istream" 3
      pos_type
      tellg();
# 585 "/usr/include/c++/10/istream" 3
      __istream_type&
      seekg(pos_type);
# 601 "/usr/include/c++/10/istream" 3
      __istream_type&
      seekg(off_type, ios_base::seekdir);


    protected:
      basic_istream()
      : _M_gcount(streamsize(0))
      { this->init(0); }


      basic_istream(const basic_istream&) = delete;

      basic_istream(basic_istream&& __rhs)
      : __ios_type(), _M_gcount(__rhs._M_gcount)
      {
 __ios_type::move(__rhs);
 __rhs._M_gcount = 0;
      }



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

      basic_istream&
      operator=(basic_istream&& __rhs)
      {
 swap(__rhs);
 return *this;
      }

      void
      swap(basic_istream& __rhs)
      {
 __ios_type::swap(__rhs);
 std::swap(_M_gcount, __rhs._M_gcount);
      }


      template<typename _ValueT>
 __istream_type&
 _M_extract(_ValueT& __v);
    };


  template<>
    basic_istream<char>&
    basic_istream<char>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n, int_type __delim);


  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n, int_type __delim);
# 685 "/usr/include/c++/10/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream<_CharT, _Traits>::sentry
    {

      bool _M_ok;

    public:

      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename _Traits::int_type __int_type;
# 721 "/usr/include/c++/10/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 732 "/usr/include/c++/10/istream" 3
      explicit

      operator bool() const
      { return _M_ok; }
    };
# 750 "/usr/include/c++/10/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }
# 792 "/usr/include/c++/10/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);


  template<>
    basic_istream<char>&
    operator>>(basic_istream<char>& __in, char* __s);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }
# 823 "/usr/include/c++/10/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_iostream
    : public basic_istream<_CharT, _Traits>,
      public basic_ostream<_CharT, _Traits>
    {
    public:



      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;







      explicit
      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
      : __istream_type(__sb), __ostream_type(__sb) { }




      virtual
      ~basic_iostream() { }

    protected:
      basic_iostream()
      : __istream_type(), __ostream_type() { }


      basic_iostream(const basic_iostream&) = delete;

      basic_iostream(basic_iostream&& __rhs)
      : __istream_type(std::move(__rhs)), __ostream_type(*this)
      { }



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

      basic_iostream&
      operator=(basic_iostream&& __rhs)
      {
 swap(__rhs);
 return *this;
      }

      void
      swap(basic_iostream& __rhs)
      { __istream_type::swap(__rhs); }

    };
# 906 "/usr/include/c++/10/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);


  template<typename _Ch, typename _Up>
    basic_istream<_Ch, _Up>&
    __is_convertible_to_basic_istream_test(basic_istream<_Ch, _Up>*);

  template<typename _Tp, typename = void>
    struct __is_convertible_to_basic_istream_impl
    {
      using __istream_type = void;
    };

  template<typename _Tp>
    using __do_is_convertible_to_basic_istream_impl =
    decltype(__is_convertible_to_basic_istream_test
      (declval<typename remove_reference<_Tp>::type*>()));

  template<typename _Tp>
    struct __is_convertible_to_basic_istream_impl
    <_Tp,
     __void_t<__do_is_convertible_to_basic_istream_impl<_Tp>>>
    {
      using __istream_type =
 __do_is_convertible_to_basic_istream_impl<_Tp>;
    };

  template<typename _Tp>
    struct __is_convertible_to_basic_istream
    : __is_convertible_to_basic_istream_impl<_Tp>
    {
    public:
      using type = __not_<is_void<
        typename __is_convertible_to_basic_istream_impl<_Tp>::__istream_type>>;
      constexpr static bool value = type::value;
    };

  template<typename _Istream, typename _Tp, typename = void>
    struct __is_extractable : false_type {};

  template<typename _Istream, typename _Tp>
    struct __is_extractable<_Istream, _Tp,
       __void_t<decltype(declval<_Istream&>()
           >> declval<_Tp>())>>
    : true_type {};

  template<typename _Istream>
    using __rvalue_istream_type =
      typename __is_convertible_to_basic_istream<
 _Istream>::__istream_type;
# 972 "/usr/include/c++/10/istream" 3
  template<typename _Istream, typename _Tp>
    inline
    typename enable_if<__and_<__not_<is_lvalue_reference<_Istream>>,
         __is_convertible_to_basic_istream<_Istream>,
         __is_extractable<
    __rvalue_istream_type<_Istream>,
    _Tp&&>>::value,
         __rvalue_istream_type<_Istream>>::type
    operator>>(_Istream&& __is, _Tp&& __x)
    {
      __rvalue_istream_type<_Istream> __ret_is = __is;
      __ret_is >> std::forward<_Tp>(__x);
      return __ret_is;
    }



}

# 1 "/usr/include/c++/10/bits/istream.tcc" 1 3
# 37 "/usr/include/c++/10/bits/istream.tcc" 3
       
# 38 "/usr/include/c++/10/bits/istream.tcc" 3



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


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>::sentry::
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
    {
      ios_base::iostate __err = ios_base::goodbit;
      if (__in.good())
 try
   {
     if (__in.tie())
       __in.tie()->flush();
     if (!__noskip && bool(__in.flags() & ios_base::skipws))
       {
  const __int_type __eof = traits_type::eof();
  __streambuf_type* __sb = __in.rdbuf();
  __int_type __c = __sb->sgetc();

  const __ctype_type& __ct = __check_facet(__in._M_ctype);
  while (!traits_type::eq_int_type(__c, __eof)
         && __ct.is(ctype_base::space,
      traits_type::to_char_type(__c)))
    __c = __sb->snextc();




  if (traits_type::eq_int_type(__c, __eof))
    __err |= ios_base::eofbit;
       }
   }
 catch(__cxxabiv1::__forced_unwind&)
   {
     __in._M_setstate(ios_base::badbit);
     throw;
   }
 catch(...)
   { __in._M_setstate(ios_base::badbit); }

      if (__in.good() && __err == ios_base::goodbit)
 _M_ok = true;
      else
 {
   __err |= ios_base::failbit;
   __in.setstate(__err);
 }
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_istream<_CharT, _Traits>&
      basic_istream<_CharT, _Traits>::
      _M_extract(_ValueT& __v)
      {
 sentry __cerb(*this, false);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::goodbit;
     try
       {
  const __num_get_type& __ng = __check_facet(this->_M_num_get);
  __ng.get(*this, 0, *this, __err, __v);
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(short& __n)
    {


      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       long __l;
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __l);



       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<short>::__min;
  }
       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<short>::__max;
  }
       else
  __n = short(__l);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(int& __n)
    {


      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       long __l;
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __l);



       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<int>::__min;
  }
       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<int>::__max;
  }
       else
  __n = int(__l);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__streambuf_type* __sbout)
    {
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, false);
      if (__cerb && __sbout)
 {
   try
     {
       bool __ineof;
       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
  __err |= ios_base::failbit;
       if (__ineof)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::failbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbout)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    get(void)
    {
      const int_type __eof = traits_type::eof();
      int_type __c = __eof;
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       __c = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__c, __eof))
  _M_gcount = 1;
       else
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type& __c)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __cb = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
  {
    _M_gcount = 1;
    __c = traits_type::to_char_type(__cb);
  }
       else
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       int_type __c = __sb->sgetc();

       while (_M_gcount + 1 < __n
       && !traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim))
  {
    *__s++ = traits_type::to_char_type(__c);
    ++_M_gcount;
    __c = __sb->snextc();
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(__streambuf_type& __sb, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __this_sb = this->rdbuf();
       int_type __c = __this_sb->sgetc();
       char_type __c2 = traits_type::to_char_type(__c);

       while (!traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim)
       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
  {
    ++_M_gcount;
    __c = __this_sb->snextc();
    __c2 = traits_type::to_char_type(__c);
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();

              while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
                  *__s++ = traits_type::to_char_type(__c);
                  __c = __sb->snextc();
                  ++_M_gcount;
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
              else
                {
                  if (traits_type::eq_int_type(__c, __idelim))
                    {
                      __sb->sbumpc();
                      ++_M_gcount;
                    }
                  else
                    __err |= ios_base::failbit;
                }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }




  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(void)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();

       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
  __err |= ios_base::eofbit;
       else
  _M_gcount = 1;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();
# 521 "/usr/include/c++/10/bits/istream.tcc" 3
       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

       if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n, int_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();


       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof)
    && !traits_type::eq_int_type(__c, __delim))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof)
        && !traits_type::eq_int_type(__c, __delim))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
       else if (traits_type::eq_int_type(__c, __delim))
  {
    if (_M_gcount
        < __gnu_cxx::__numeric_traits<streamsize>::__max)
      ++_M_gcount;
    __sb->sbumpc();
  }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __c = this->rdbuf()->sgetc();
       if (traits_type::eq_int_type(__c, traits_type::eof()))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       _M_gcount = this->rdbuf()->sgetn(__s, __n);
       if (_M_gcount != __n)
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {

       const streamsize __num = this->rdbuf()->in_avail();
       if (__num > 0)
  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
       else if (__num == -1)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {


      _M_gcount = 0;

      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {


      _M_gcount = 0;

      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sungetc(), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {


      int __ret = -1;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {


      pos_type __ret = pos_type(-1);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       if (!this->fail())
  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
        ios_base::in);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {



      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (!this->fail())
  {

    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
         ios_base::in);


    if (__p == pos_type(off_type(-1)))
      __err |= ios_base::failbit;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {



      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (!this->fail())
  {

    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
         ios_base::in);


    if (__p == pos_type(off_type(-1)))
      __err |= ios_base::failbit;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const __int_type __cb = __in.rdbuf()->sbumpc();
       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
  __c = _Traits::to_char_type(__cb);
       else
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename _Traits::int_type int_type;
      typedef _CharT char_type;
      typedef ctype<_CharT> __ctype_type;

      streamsize __extracted = 0;
      ios_base::iostate __err = ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       streamsize __num = __in.width();
       if (__num <= 0)
  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;

       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

       const int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       int_type __c = __sb->sgetc();

       while (__extracted < __num - 1
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    *__s++ = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }
       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;



       *__s = char_type();
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
 }
      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename __istream_type::int_type __int_type;
      typedef ctype<_CharT> __ctype_type;

      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
      const __int_type __eof = _Traits::eof();
      __streambuf_type* __sb = __in.rdbuf();
      __int_type __c = __sb->sgetc();

      while (!_Traits::eq_int_type(__c, __eof)
      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
 __c = __sb->snextc();

       if (_Traits::eq_int_type(__c, __eof))
  __in.setstate(ios_base::eofbit);
      return __in;
    }




  extern template class basic_istream<char>;
  extern template istream& ws(istream&);
  extern template istream& operator>>(istream&, char&);
  extern template istream& operator>>(istream&, char*);
  extern template istream& operator>>(istream&, unsigned char&);
  extern template istream& operator>>(istream&, signed char&);
  extern template istream& operator>>(istream&, unsigned char*);
  extern template istream& operator>>(istream&, signed char*);

  extern template istream& istream::_M_extract(unsigned short&);
  extern template istream& istream::_M_extract(unsigned int&);
  extern template istream& istream::_M_extract(long&);
  extern template istream& istream::_M_extract(unsigned long&);
  extern template istream& istream::_M_extract(bool&);

  extern template istream& istream::_M_extract(long long&);
  extern template istream& istream::_M_extract(unsigned long long&);

  extern template istream& istream::_M_extract(float&);
  extern template istream& istream::_M_extract(double&);
  extern template istream& istream::_M_extract(long double&);
  extern template istream& istream::_M_extract(void*&);

  extern template class basic_iostream<char>;


  extern template class basic_istream<wchar_t>;
  extern template wistream& ws(wistream&);
  extern template wistream& operator>>(wistream&, wchar_t&);
  extern template wistream& operator>>(wistream&, wchar_t*);

  extern template wistream& wistream::_M_extract(unsigned short&);
  extern template wistream& wistream::_M_extract(unsigned int&);
  extern template wistream& wistream::_M_extract(long&);
  extern template wistream& wistream::_M_extract(unsigned long&);
  extern template wistream& wistream::_M_extract(bool&);

  extern template wistream& wistream::_M_extract(long long&);
  extern template wistream& wistream::_M_extract(unsigned long long&);

  extern template wistream& wistream::_M_extract(float&);
  extern template wistream& wistream::_M_extract(double&);
  extern template wistream& wistream::_M_extract(long double&);
  extern template wistream& wistream::_M_extract(void*&);

  extern template class basic_iostream<wchar_t>;




}
# 992 "/usr/include/c++/10/istream" 2 3
# 39 "/usr/include/c++/10/sstream" 2 3


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

namespace __cxx11 {
# 64 "/usr/include/c++/10/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
    {
      struct __xfer_bufptrs;
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;

      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

    protected:

      ios_base::openmode _M_mode;


      __string_type _M_string;

    public:
# 99 "/usr/include/c++/10/sstream" 3
      basic_stringbuf()
      : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string()
      { }
# 110 "/usr/include/c++/10/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 123 "/usr/include/c++/10/sstream" 3
      explicit
      basic_stringbuf(const __string_type& __str,
        ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(),
 _M_string(__str.data(), __str.size(), __str.get_allocator())
      { _M_stringbuf_init(__mode); }


      basic_stringbuf(const basic_stringbuf&) = delete;

      basic_stringbuf(basic_stringbuf&& __rhs)
      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }



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

      basic_stringbuf&
      operator=(basic_stringbuf&& __rhs)
      {
 __xfer_bufptrs __st{__rhs, this};
 const __streambuf_type& __base = __rhs;
 __streambuf_type::operator=(__base);
 this->pubimbue(__rhs.getloc());
 _M_mode = __rhs._M_mode;
 _M_string = std::move(__rhs._M_string);
 __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
 return *this;
      }

      void
      swap(basic_stringbuf& __rhs)
      {
 __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
 __xfer_bufptrs __r_st{__rhs, this};
 __streambuf_type& __base = __rhs;
 __streambuf_type::swap(__base);
 __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
 std::swap(_M_mode, __rhs._M_mode);
 std::swap(_M_string, __rhs._M_string);
      }
# 177 "/usr/include/c++/10/sstream" 3
      __string_type
      str() const
      {
 __string_type __ret(_M_string.get_allocator());
 if (this->pptr())
   {

     if (this->pptr() > this->egptr())
       __ret.assign(this->pbase(), this->pptr());
     else
       __ret.assign(this->pbase(), this->egptr());
   }
 else
   __ret = _M_string;
 return __ret;
      }
# 201 "/usr/include/c++/10/sstream" 3
      void
      str(const __string_type& __s)
      {


 _M_string.assign(__s.data(), __s.size());
 _M_stringbuf_init(_M_mode);
      }

    protected:

      void
      _M_stringbuf_init(ios_base::openmode __mode)
      {
 _M_mode = __mode;
 __size_type __len = 0;
 if (_M_mode & (ios_base::ate | ios_base::app))
   __len = _M_string.size();
 _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
      }

      virtual streamsize
      showmanyc()
      {
 streamsize __ret = -1;
 if (_M_mode & ios_base::in)
   {
     _M_update_egptr();
     __ret = this->egptr() - this->gptr();
   }
 return __ret;
      }

      virtual int_type
      underflow();

      virtual int_type
      pbackfail(int_type __c = traits_type::eof());

      virtual int_type
      overflow(int_type __c = traits_type::eof());
# 254 "/usr/include/c++/10/sstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n)
      {
 if (__s && __n >= 0)
   {






     _M_string.clear();


     _M_sync(__s, __n, 0);
   }
 return this;
      }

      virtual pos_type
      seekoff(off_type __off, ios_base::seekdir __way,
       ios_base::openmode __mode = ios_base::in | ios_base::out);

      virtual pos_type
      seekpos(pos_type __sp,
       ios_base::openmode __mode = ios_base::in | ios_base::out);




      void
      _M_sync(char_type* __base, __size_type __i, __size_type __o);



      void
      _M_update_egptr()
      {
 const bool __testin = _M_mode & ios_base::in;
 if (this->pptr() && this->pptr() > this->egptr())
   {
     if (__testin)
       this->setg(this->eback(), this->gptr(), this->pptr());
     else
       this->setg(this->pptr(), this->pptr(), this->pptr());
   }
      }



      void
      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);

    private:




      struct __xfer_bufptrs
      {
 __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
 : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
 {
   const _CharT* const __str = __from._M_string.data();
   const _CharT* __end = nullptr;
   if (__from.eback())
     {
       _M_goff[0] = __from.eback() - __str;
       _M_goff[1] = __from.gptr() - __str;
       _M_goff[2] = __from.egptr() - __str;
       __end = __from.egptr();
     }
   if (__from.pbase())
     {
       _M_poff[0] = __from.pbase() - __str;
       _M_poff[1] = __from.pptr() - __from.pbase();
       _M_poff[2] = __from.epptr() - __str;
       if (__from.pptr() > __end)
  __end = __from.pptr();
     }


   if (__end)
     {


       auto& __mut_from = const_cast<basic_stringbuf&>(__from);
       __mut_from._M_string._M_length(__end - __str);
     }
 }

 ~__xfer_bufptrs()
 {
   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
   if (_M_goff[0] != -1)
     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
   if (_M_poff[0] != -1)
     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
 }

 basic_stringbuf* _M_to;
 off_type _M_goff[3];
 off_type _M_poff[3];
      };
# 368 "/usr/include/c++/10/sstream" 3
      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
      { }

    };
# 391 "/usr/include/c++/10/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_istringstream : public basic_istream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 425 "/usr/include/c++/10/sstream" 3
      basic_istringstream()
      : __istream_type(), _M_stringbuf(ios_base::in)
      { this->init(&_M_stringbuf); }
# 441 "/usr/include/c++/10/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 459 "/usr/include/c++/10/sstream" 3
      explicit
      basic_istringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
      { this->init(&_M_stringbuf); }







      ~basic_istringstream()
      { }


      basic_istringstream(const basic_istringstream&) = delete;

      basic_istringstream(basic_istringstream&& __rhs)
      : __istream_type(std::move(__rhs)),
      _M_stringbuf(std::move(__rhs._M_stringbuf))
      { __istream_type::set_rdbuf(&_M_stringbuf); }



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

      basic_istringstream&
      operator=(basic_istringstream&& __rhs)
      {
 __istream_type::operator=(std::move(__rhs));
 _M_stringbuf = std::move(__rhs._M_stringbuf);
 return *this;
      }

      void
      swap(basic_istringstream& __rhs)
      {
 __istream_type::swap(__rhs);
 _M_stringbuf.swap(__rhs._M_stringbuf);
      }
# 510 "/usr/include/c++/10/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };
# 549 "/usr/include/c++/10/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 583 "/usr/include/c++/10/sstream" 3
      basic_ostringstream()
      : __ostream_type(), _M_stringbuf(ios_base::out)
      { this->init(&_M_stringbuf); }
# 599 "/usr/include/c++/10/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 617 "/usr/include/c++/10/sstream" 3
      explicit
      basic_ostringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
      { this->init(&_M_stringbuf); }







      ~basic_ostringstream()
      { }


      basic_ostringstream(const basic_ostringstream&) = delete;

      basic_ostringstream(basic_ostringstream&& __rhs)
      : __ostream_type(std::move(__rhs)),
      _M_stringbuf(std::move(__rhs._M_stringbuf))
      { __ostream_type::set_rdbuf(&_M_stringbuf); }



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

      basic_ostringstream&
      operator=(basic_ostringstream&& __rhs)
      {
 __ostream_type::operator=(std::move(__rhs));
 _M_stringbuf = std::move(__rhs._M_stringbuf);
 return *this;
      }

      void
      swap(basic_ostringstream& __rhs)
      {
 __ostream_type::swap(__rhs);
 _M_stringbuf.swap(__rhs._M_stringbuf);
      }
# 668 "/usr/include/c++/10/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };
# 707 "/usr/include/c++/10/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringstream : public basic_iostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 741 "/usr/include/c++/10/sstream" 3
      basic_stringstream()
      : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in)
      { this->init(&_M_stringbuf); }
# 755 "/usr/include/c++/10/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 771 "/usr/include/c++/10/sstream" 3
      explicit
      basic_stringstream(const __string_type& __str,
    ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__str, __m)
      { this->init(&_M_stringbuf); }







      ~basic_stringstream()
      { }


      basic_stringstream(const basic_stringstream&) = delete;

      basic_stringstream(basic_stringstream&& __rhs)
      : __iostream_type(std::move(__rhs)),
      _M_stringbuf(std::move(__rhs._M_stringbuf))
      { __iostream_type::set_rdbuf(&_M_stringbuf); }



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

      basic_stringstream&
      operator=(basic_stringstream&& __rhs)
      {
 __iostream_type::operator=(std::move(__rhs));
 _M_stringbuf = std::move(__rhs._M_stringbuf);
 return *this;
      }

      void
      swap(basic_stringstream& __rhs)
      {
 __iostream_type::swap(__rhs);
 _M_stringbuf.swap(__rhs._M_stringbuf);
      }
# 822 "/usr/include/c++/10/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };



  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


}

}

# 1 "/usr/include/c++/10/bits/sstream.tcc" 1 3
# 37 "/usr/include/c++/10/bits/sstream.tcc" 3
       
# 38 "/usr/include/c++/10/bits/sstream.tcc" 3

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


  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    pbackfail(int_type __c)
    {
      int_type __ret = traits_type::eof();
      if (this->eback() < this->gptr())
 {


   const bool __testeof = traits_type::eq_int_type(__c, __ret);
   if (!__testeof)
     {
       const bool __testeq = traits_type::eq(traits_type::
          to_char_type(__c),
          this->gptr()[-1]);
       const bool __testout = this->_M_mode & ios_base::out;
       if (__testeq || __testout)
  {
    this->gbump(-1);
    if (!__testeq)
      *this->gptr() = traits_type::to_char_type(__c);
    __ret = __c;
  }
     }
   else
     {
       this->gbump(-1);
       __ret = traits_type::not_eof(__c);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    overflow(int_type __c)
    {
      const bool __testout = this->_M_mode & ios_base::out;
      if (__builtin_expect(!__testout, false))
 return traits_type::eof();

      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
      if (__builtin_expect(__testeof, false))
 return traits_type::not_eof(__c);

      const __size_type __capacity = _M_string.capacity();


      if ((this->epptr() - this->pbase()) < __capacity)
 {

   char_type* __base = const_cast<char_type*>(_M_string.data());
   _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase());
   if (_M_mode & ios_base::in)
     {
       const __size_type __nget = this->gptr() - this->eback();
       const __size_type __eget = this->egptr() - this->eback();
       this->setg(__base, __base + __nget, __base + __eget + 1);
     }
   *this->pptr() = traits_type::to_char_type(__c);
   this->pbump(1);
   return __c;
 }


      const __size_type __max_size = _M_string.max_size();
      const bool __testput = this->pptr() < this->epptr();
      if (__builtin_expect(!__testput && __capacity == __max_size, false))
 return traits_type::eof();



      const char_type __conv = traits_type::to_char_type(__c);
      if (!__testput)
 {
# 129 "/usr/include/c++/10/bits/sstream.tcc" 3
   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
       __size_type(512));
   const __size_type __len = std::min(__opt_len, __max_size);
   __string_type __tmp(_M_string.get_allocator());
   __tmp.reserve(__len);
   if (this->pbase())
     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
   __tmp.push_back(__conv);
   _M_string.swap(__tmp);
   _M_sync(const_cast<char_type*>(_M_string.data()),
    this->gptr() - this->eback(), this->pptr() - this->pbase());
 }
      else
 *this->pptr() = __conv;
      this->pbump(1);
      return __c;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin)
 {

   _M_update_egptr();

   if (this->gptr() < this->egptr())
     __ret = traits_type::to_int_type(*this->gptr());
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
      const bool __testboth = __testin && __testout && __way != ios_base::cur;
      __testin &= !(__mode & ios_base::out);
      __testout &= !(__mode & ios_base::in);



      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !__off) && (__testin || __testout || __testboth))
 {
   _M_update_egptr();

   off_type __newoffi = __off;
   off_type __newoffo = __newoffi;
   if (__way == ios_base::cur)
     {
       __newoffi += this->gptr() - __beg;
       __newoffo += this->pptr() - __beg;
     }
   else if (__way == ios_base::end)
     __newoffo = __newoffi += this->egptr() - __beg;

   if ((__testin || __testboth)
       && __newoffi >= 0
       && this->egptr() - __beg >= __newoffi)
     {
       this->setg(this->eback(), this->eback() + __newoffi,
    this->egptr());
       __ret = pos_type(__newoffi);
     }
   if ((__testout || __testboth)
       && __newoffo >= 0
       && this->egptr() - __beg >= __newoffo)
     {
       _M_pbump(this->pbase(), this->epptr(), __newoffo);
       __ret = pos_type(__newoffo);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekpos(pos_type __sp, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;

      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !off_type(__sp)) && (__testin || __testout))
 {
   _M_update_egptr();

   const off_type __pos(__sp);
   const bool __testpos = (0 <= __pos
      && __pos <= this->egptr() - __beg);
   if (__testpos)
     {
       if (__testin)
  this->setg(this->eback(), this->eback() + __pos,
      this->egptr());
       if (__testout)
  _M_pbump(this->pbase(), this->epptr(), __pos);
       __ret = __sp;
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    _M_sync(char_type* __base, __size_type __i, __size_type __o)
    {
      const bool __testin = _M_mode & ios_base::in;
      const bool __testout = _M_mode & ios_base::out;
      char_type* __endg = __base + _M_string.size();
      char_type* __endp = __base + _M_string.capacity();

      if (__base != _M_string.data())
 {

   __endg += __i;
   __i = 0;
   __endp = __endg;
 }

      if (__testin)
 this->setg(__base, __base + __i, __endg);
      if (__testout)
 {
   _M_pbump(__base, __endp, __o);



   if (!__testin)
     this->setg(__endg, __endg, __endg);
 }
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
    {
      this->setp(__pbeg, __pend);
      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
 {
   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
   __off -= __gnu_cxx::__numeric_traits<int>::__max;
 }
      this->pbump(__off);
    }




  extern template class basic_stringbuf<char>;
  extern template class basic_istringstream<char>;
  extern template class basic_ostringstream<char>;
  extern template class basic_stringstream<char>;


  extern template class basic_stringbuf<wchar_t>;
  extern template class basic_istringstream<wchar_t>;
  extern template class basic_ostringstream<wchar_t>;
  extern template class basic_stringstream<wchar_t>;




}
# 880 "/usr/include/c++/10/sstream" 2 3
# 46 "/usr/include/c++/10/complex" 2 3
# 54 "/usr/include/c++/10/complex" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 67 "/usr/include/c++/10/complex" 3
  template<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 norm(const complex<_Tp>&);


  template<typename _Tp>
    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>&);
# 126 "/usr/include/c++/10/complex" 3
  template<typename _Tp>
    struct complex
    {

      typedef _Tp value_type;



      constexpr complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
      : _M_real(__r), _M_imag(__i) { }



      constexpr complex(const complex&) = default;



      template<typename _Up>
        constexpr complex(const complex<_Up>& __z)
 : _M_real(__z.real()), _M_imag(__z.imag()) { }




      __attribute ((__abi_tag__ ("cxx11")))
      constexpr _Tp
      real() const { return _M_real; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr _Tp
      imag() const { return _M_imag; }
# 177 "/usr/include/c++/10/complex" 3
      void
      real(_Tp __val) { _M_real = __val; }

      void
      imag(_Tp __val) { _M_imag = __val; }


      complex<_Tp>& operator=(const _Tp&);



      complex<_Tp>&
      operator+=(const _Tp& __t)
      {
 _M_real += __t;
 return *this;
      }



      complex<_Tp>&
      operator-=(const _Tp& __t)
      {
 _M_real -= __t;
 return *this;
      }


      complex<_Tp>& operator*=(const _Tp&);

      complex<_Tp>& operator/=(const _Tp&);



      complex& operator=(const complex&) = default;



      template<typename _Up>
        complex<_Tp>& operator=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator+=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator-=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator*=(const complex<_Up>&);

      template<typename _Up>
        complex<_Tp>& operator/=(const complex<_Up>&);

      constexpr complex __rep() const
      { return *this; }

    private:
      _Tp _M_real;
      _Tp _M_imag;
    };

  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator=(const _Tp& __t)
    {
     _M_real = __t;
     _M_imag = _Tp();
     return *this;
    }


  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator*=(const _Tp& __t)
    {
      _M_real *= __t;
      _M_imag *= __t;
      return *this;
    }


  template<typename _Tp>
    complex<_Tp>&
    complex<_Tp>::operator/=(const _Tp& __t)
    {
      _M_real /= __t;
      _M_imag /= __t;
      return *this;
    }

  template<typename _Tp>
    template<typename _Up>
    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>
    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>
    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>
    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>
    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 complex<_Tp>
    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator+(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator-(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = -__y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator*(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r *= __x;
      return __r;
    }




  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline complex<_Tp>
    operator/(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }



  template<typename _Tp>
    inline complex<_Tp>
    operator+(const complex<_Tp>& __x)
    { return __x; }


  template<typename _Tp>
    inline 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(); }

  template<typename _Tp>
    inline constexpr bool
    operator==(const _Tp& __x, const complex<_Tp>& __y)
    { return __x == __y.real() && _Tp() == __y.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(); }

  template<typename _Tp>
    inline constexpr bool
    operator!=(const _Tp& __x, const complex<_Tp>& __y)
    { return __x != __y.real() || _Tp() != __y.imag(); }



  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(); }
# 596 "/usr/include/c++/10/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()); }
# 632 "/usr/include/c++/10/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()); }
# 662 "/usr/include/c++/10/complex" 3
  template<bool>
    struct _Norm_helper
    {
      template<typename _Tp>
        static inline _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 _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 _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 (! (__rho >= 0)) std::__replacement_assert("/usr/include/c++/10/complex", 700, __PRETTY_FUNCTION__, "__rho >= 0"); } while (false);
      return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
    }

  template<typename _Tp>
    inline 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()); }
# 799 "/usr/include/c++/10/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()); }
# 891 "/usr/include/c++/10/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()); }
# 935 "/usr/include/c++/10/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()); }
# 963 "/usr/include/c++/10/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()); }
# 992 "/usr/include/c++/10/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<>
    struct complex<float>
    {
      typedef float value_type;
      typedef __complex__ float _ComplexT;

      constexpr complex(_ComplexT __z) : _M_value(__z) { }

      constexpr complex(float __r = 0.0f, float __i = 0.0f)

      : _M_value{ __r, __i } { }







      explicit constexpr complex(const complex<double>&);
      explicit constexpr complex(const complex<long double>&);




      __attribute ((__abi_tag__ ("cxx11")))
      constexpr float
      real() const { return __real__ _M_value; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr float
      imag() const { return __imag__ _M_value; }
# 1126 "/usr/include/c++/10/complex" 3
      void
      real(float __val) { __real__ _M_value = __val; }

      void
      imag(float __val) { __imag__ _M_value = __val; }

      complex&
      operator=(float __f)
      {
 _M_value = __f;
 return *this;
      }

      complex&
      operator+=(float __f)
      {
 _M_value += __f;
 return *this;
      }

      complex&
      operator-=(float __f)
      {
 _M_value -= __f;
 return *this;
      }

      complex&
      operator*=(float __f)
      {
 _M_value *= __f;
 return *this;
      }

      complex&
      operator/=(float __f)
      {
 _M_value /= __f;
 return *this;
      }




      constexpr complex& operator=(const complex&) = default;


      template<typename _Tp>
        complex&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        complex&
        operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<class _Tp>
        complex&
        operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<class _Tp>
        complex&
        operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<class _Tp>
        complex&
        operator/=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value /= __t;
   return *this;
 }

      constexpr _ComplexT __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  template<>
    struct complex<double>
    {
      typedef double value_type;
      typedef __complex__ double _ComplexT;

      constexpr complex(_ComplexT __z) : _M_value(__z) { }

      constexpr complex(double __r = 0.0, double __i = 0.0)

      : _M_value{ __r, __i } { }







      constexpr complex(const complex<float>& __z)
      : _M_value(__z.__rep()) { }

      explicit constexpr complex(const complex<long double>&);




      __attribute ((__abi_tag__ ("cxx11")))
      constexpr double
      real() const { return __real__ _M_value; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr double
      imag() const { return __imag__ _M_value; }
# 1273 "/usr/include/c++/10/complex" 3
      void
      real(double __val) { __real__ _M_value = __val; }

      void
      imag(double __val) { __imag__ _M_value = __val; }

      complex&
      operator=(double __d)
      {
 _M_value = __d;
 return *this;
      }

      complex&
      operator+=(double __d)
      {
 _M_value += __d;
 return *this;
      }

      complex&
      operator-=(double __d)
      {
 _M_value -= __d;
 return *this;
      }

      complex&
      operator*=(double __d)
      {
 _M_value *= __d;
 return *this;
      }

      complex&
      operator/=(double __d)
      {
 _M_value /= __d;
 return *this;
      }



      constexpr complex& operator=(const complex&) = default;


      template<typename _Tp>
        complex&
        operator=(const complex<_Tp>& __z)
 {
   _M_value = __z.__rep();
   return *this;
 }

      template<typename _Tp>
        complex&
        operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<typename _Tp>
        complex&
        operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<typename _Tp>
        complex&
        operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        complex&
        operator/=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value /= __t;
   return *this;
 }

      constexpr _ComplexT __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  template<>
    struct complex<long double>
    {
      typedef long double value_type;
      typedef __complex__ long double _ComplexT;

      constexpr complex(_ComplexT __z) : _M_value(__z) { }

      constexpr complex(long double __r = 0.0L,
     long double __i = 0.0L)

      : _M_value{ __r, __i } { }







      constexpr complex(const complex<float>& __z)
      : _M_value(__z.__rep()) { }

      constexpr complex(const complex<double>& __z)
      : _M_value(__z.__rep()) { }




      __attribute ((__abi_tag__ ("cxx11")))
      constexpr long double
      real() const { return __real__ _M_value; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr long double
      imag() const { return __imag__ _M_value; }
# 1420 "/usr/include/c++/10/complex" 3
      void
      real(long double __val) { __real__ _M_value = __val; }

      void
      imag(long double __val) { __imag__ _M_value = __val; }

      complex&
      operator=(long double __r)
      {
 _M_value = __r;
 return *this;
      }

      complex&
      operator+=(long double __r)
      {
 _M_value += __r;
 return *this;
      }

      complex&
      operator-=(long double __r)
      {
 _M_value -= __r;
 return *this;
      }

      complex&
      operator*=(long double __r)
      {
 _M_value *= __r;
 return *this;
      }

      complex&
      operator/=(long double __r)
      {
 _M_value /= __r;
 return *this;
      }



      constexpr complex& operator=(const complex&) = default;


      template<typename _Tp>
        complex&
        operator=(const complex<_Tp>& __z)
 {
   _M_value = __z.__rep();
   return *this;
 }

      template<typename _Tp>
        complex&
 operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<typename _Tp>
        complex&
 operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<typename _Tp>
        complex&
 operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        complex&
 operator/=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value /= __t;
   return *this;
 }

      constexpr _ComplexT __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };



  inline constexpr
  complex<float>::complex(const complex<double>& __z)
  : _M_value(__z.__rep()) { }

  inline constexpr
  complex<float>::complex(const complex<long double>& __z)
  : _M_value(__z.__rep()) { }

  inline constexpr
  complex<double>::complex(const complex<long double>& __z)
  : _M_value(__z.__rep()) { }





  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 __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Up>
    struct __promote_2<std::complex<_Tp>, _Up>
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

  template<typename _Tp, typename _Up>
    struct __promote_2<_Tp, std::complex<_Up> >
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };

  template<typename _Tp, typename _Up>
    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
    {
    public:
      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
    };


}



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());
    }


  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()); }
# 1636 "/usr/include/c++/10/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()); }
# 1672 "/usr/include/c++/10/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()); }
# 1716 "/usr/include/c++/10/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()); }
# 1752 "/usr/include/c++/10/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()); }
# 1791 "/usr/include/c++/10/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()); }
# 1835 "/usr/include/c++/10/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>
    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()); }
# 1952 "/usr/include/c++/10/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
 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
#pragma GCC diagnostic ignored "-Wliteral-suffix"


  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
}
}




}
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/container_fwd.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 3 4
namespace boost
{
    template <class A, class B>
    std::size_t hash_value(std::pair<A, B> const&);
    template <class T, class A>
    std::size_t hash_value(std::vector<T, A> const&);
    template <class T, class A>
    std::size_t hash_value(std::list<T, A> const& v);
    template <class T, class A>
    std::size_t hash_value(std::deque<T, A> const& v);
    template <class K, class C, class A>
    std::size_t hash_value(std::set<K, C, A> const& v);
    template <class K, class C, class A>
    std::size_t hash_value(std::multiset<K, C, A> const& v);
    template <class K, class T, class C, class A>
    std::size_t hash_value(std::map<K, T, C, A> const& v);
    template <class K, class T, class C, class A>
    std::size_t hash_value(std::multimap<K, T, C, A> const& v);

    template <class T>
    std::size_t hash_value(std::complex<T> const&);

    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;
    }

    inline std::size_t hash_range(
        std::vector<bool>::iterator first,
        std::vector<bool>::iterator last)
    {
        std::size_t seed = 0;

        for(; first != last; ++first)
        {
            hash_combine<bool>(seed, *first);
        }

        return seed;
    }

    inline std::size_t hash_range(
        std::vector<bool>::const_iterator first,
        std::vector<bool>::const_iterator last)
    {
        std::size_t seed = 0;

        for(; first != last; ++first)
        {
            hash_combine<bool>(seed, *first);
        }

        return seed;
    }

    inline void hash_range(
        std::size_t& seed,
        std::vector<bool>::iterator first,
        std::vector<bool>::iterator last)
    {
        for(; first != last; ++first)
        {
            hash_combine<bool>(seed, *first);
        }
    }

    inline void hash_range(
        std::size_t& seed,
        std::vector<bool>::const_iterator first,
        std::vector<bool>::const_iterator last)
    {
        for(; first != last; ++first)
        {
            hash_combine<bool>(seed, *first);
        }
    }

    template <class T, class A>
    std::size_t hash_value(std::vector<T, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class T, class A>
    std::size_t hash_value(std::list<T, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class T, class A>
    std::size_t hash_value(std::deque<T, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class C, class A>
    std::size_t hash_value(std::set<K, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class C, class A>
    std::size_t hash_value(std::multiset<K, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class T, class C, class A>
    std::size_t hash_value(std::map<K, T, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class T, class C, class A>
    std::size_t hash_value(std::multimap<K, T, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class T>
    std::size_t hash_value(std::complex<T> const& v)
    {
        boost::hash<T> hasher;
        std::size_t seed = hasher(v.imag());
        seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
        return seed;
    }


    template <class T, std::size_t N>
    std::size_t hash_value(std::array<T, N> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }



    namespace hash_detail {
        template <std::size_t I, typename T>
        inline typename boost::enable_if_c<(I == std::tuple_size<T>::value),
                void>::type
            hash_combine_tuple(std::size_t&, T const&)
        {
        }

        template <std::size_t I, typename T>
        inline typename boost::enable_if_c<(I < std::tuple_size<T>::value),
                void>::type
            hash_combine_tuple(std::size_t& seed, T const& v)
        {
            boost::hash_combine(seed, std::get<I>(v));
            boost::hash_detail::hash_combine_tuple<I + 1>(seed, v);
        }

        template <typename T>
        inline std::size_t hash_tuple(T const& v)
        {
            std::size_t seed = 0;
            boost::hash_detail::hash_combine_tuple<0>(seed, v);
            return seed;
        }
    }


    template <typename... T>
    inline std::size_t hash_value(std::tuple<T...> const& v)
    {
        return boost::hash_detail::hash_tuple(v);
    }
# 288 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 3 4
    template <typename T>
    inline std::size_t hash_value(std::shared_ptr<T> const& x) {
        return boost::hash_value(x.get());
    }

    template <typename T, typename Deleter>
    inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) {
        return boost::hash_value(x.get());
    }
# 352 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 3 4
    template <class T> struct hash
        : boost::hash_detail::hash_base<T>
    {

        std::size_t operator()(T const& val) const
        {
            return hash_value(val);
        }






    };
# 412 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/extensions.hpp" 3 4
}
# 761 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container_hash/hash.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 3 4
        


namespace boost { namespace typeindex {






class stl_type_index
    : public type_index_facade<
        stl_type_index,



            std::type_info

    >
{
public:



    typedef std::type_info type_info_t;


private:
    const type_info_t* data_;

public:
    inline stl_type_index() noexcept
        : data_(&typeid(void))
    {}

    inline stl_type_index(const type_info_t& data) noexcept
        : data_(&data)
    {}

    inline const type_info_t& type_info() const noexcept;

    inline const char* raw_name() const noexcept;
    inline const char* name() const noexcept;
    inline std::string pretty_name() const;

    inline std::size_t hash_code() const noexcept;
    inline bool equal(const stl_type_index& rhs) const noexcept;
    inline bool before(const stl_type_index& rhs) const noexcept;

    template <class T>
    inline static stl_type_index type_id() noexcept;

    template <class T>
    inline static stl_type_index type_id_with_cvr() noexcept;

    template <class T>
    inline static stl_type_index type_id_runtime(const T& value) noexcept;
};

inline const stl_type_index::type_info_t& stl_type_index::type_info() const noexcept {
    return *data_;
}


inline const char* stl_type_index::raw_name() const noexcept {



    return data_->name();

}

inline const char* stl_type_index::name() const noexcept {
    return data_->name();
}

inline std::string stl_type_index::pretty_name() const {
    static const char cvr_saver_name[] = "boost::typeindex::detail::cvr_saver<";
    static constexpr std::string::size_type cvr_saver_name_len = sizeof(cvr_saver_name) - 1;



    const boost::core::scoped_demangled_name demangled_name(data_->name());

    const char* begin = demangled_name.get();
    if (!begin) {
        boost::throw_exception(std::runtime_error("Type name demangling failed"));
    }

    const std::string::size_type len = std::strlen(begin);
    const char* end = begin + len;

    if (len > cvr_saver_name_len) {
        const char* b = std::strstr(begin, cvr_saver_name);
        if (b) {
            b += cvr_saver_name_len;


            while (*b == ' ') {
                ++ b;
            }


            const char* e = end - 1;
            while (e > b && *e != '>') {
                -- e;
            }


            while (e > b && *(e - 1) == ' ') {
                -- e;
            }

            if (b < e) {

                begin = b;
                end = e;
            }
        }
    }

    return std::string(begin, end);
}


inline std::size_t stl_type_index::hash_code() const noexcept {



    return data_->hash_code();



}
# 203 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index/stl_type_index.hpp" 3 4
inline bool stl_type_index::equal(const stl_type_index& rhs) const noexcept {



    return !!(*data_ == *rhs.data_);

}

inline bool stl_type_index::before(const stl_type_index& rhs) const noexcept {



    return !!data_->before(*rhs.data_);

}







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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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::mpl::if_<
        boost::mpl::or_<boost::is_reference<T>, boost::is_const<T>, boost::is_volatile<T> >,
        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);

}

}}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
namespace boost { namespace typeindex {
# 132 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
    typedef boost::typeindex::stl_type_index type_index;
# 144 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
typedef type_index::type_info_t type_info;
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
template <class T>
inline type_index type_id() noexcept {
    return type_index::type_id<T>();
}
# 230 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
template <class T>
inline type_index type_id_with_cvr() noexcept {
    return type_index::type_id_with_cvr<T>();
}
# 255 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_index.hpp" 3 4
template <class T>
inline type_index type_id_runtime(const T& runtime_val) noexcept {
    return type_index::type_id_runtime(runtime_val);
}

}}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_copy.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_copy.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_copy_constructible.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_copy_constructible.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_constructible.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_constructible.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_destructible.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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(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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_destructible.hpp" 3 4
   template <> struct is_destructible<void> : public false_type{};
   template <> struct is_destructible<void const> : public false_type{};
   template <> struct is_destructible<void volatile> : public false_type{};
   template <> struct is_destructible<void const volatile> : public false_type{};
   template <class T> struct is_destructible<T&> : public is_destructible<T>{};

   template <class T> struct is_destructible<T&&> : public is_destructible<T>{};

   template <class T, std::size_t N> struct is_destructible<T[N]> : public is_destructible<T>{};
   template <class T> struct is_destructible<T[]> : public is_destructible<T>{};

}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_constructible.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_default_constructible.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_default_constructible.hpp" 3 4
   }







   template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
   };

   template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
   template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
   template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};




   template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};

   template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_default_constructible.hpp" 3 4
}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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(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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_constructible.hpp" 3 4
}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_copy.hpp" 3 4
namespace boost {

template <typename T> struct has_trivial_copy
: public integral_constant<bool,

   ((__has_trivial_copy(T) ) && !is_reference<T>::value) && is_copy_constructible<T>::value



>{};

template <typename T, std::size_t N> struct has_trivial_copy<T[N]> : public false_type{};
template <typename T> struct has_trivial_copy<T[]> : public false_type{};

template <typename T> struct has_trivial_copy<T volatile> : public false_type{};

template <> struct has_trivial_copy<void> : public false_type{};

template <> struct has_trivial_copy<void const> : public false_type{};
template <> struct has_trivial_copy<void volatile> : public false_type{};
template <> struct has_trivial_copy<void const volatile> : public false_type{};


template <class T> struct has_trivial_copy<T&> : public false_type{};

template <class T> struct has_trivial_copy<T&&> : public false_type{};


template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};



}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_destructor.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
namespace boost {

template <typename T> struct has_trivial_destructor : public integral_constant<bool, (__has_trivial_destructor(T) && is_destructible<T>::value)>{};
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
template <> struct has_trivial_destructor<void> : public false_type{};

template <> struct has_trivial_destructor<void const> : public false_type{};
template <> struct has_trivial_destructor<void const volatile> : public false_type{};
template <> struct has_trivial_destructor<void volatile> : public false_type{};


}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/composite_traits.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/composite_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_union.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>{};

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/composite_traits.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ref.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ref.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 1 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
namespace boost
{
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
template<class T> class reference_wrapper
{
public:



    typedef T type;







    inline __attribute__ ((__always_inline__)) explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
    reference_wrapper(T&& t) = delete;
public:






    inline __attribute__ ((__always_inline__)) operator T& () const { return *t_; }





    inline __attribute__ ((__always_inline__)) T& get() const { return *t_; }






    inline __attribute__ ((__always_inline__)) T* get_pointer() const { return t_; }

private:

    T* t_;
};
# 131 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
template<class T> inline __attribute__ ((__always_inline__)) reference_wrapper<T> const ref( T & t )
{






    return reference_wrapper<T>( t );


}







template<class T> inline __attribute__ ((__always_inline__)) reference_wrapper<T const> const cref( T const & t )
{
    return reference_wrapper<T const>(t);
}
# 174 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
template<class T> void ref(T const&&) = delete;




template<class T> void cref(T const&&) = delete;
# 194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
template<typename T> struct is_reference_wrapper
{
    static const bool value = false;
};




template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
{
    static const bool value = true;
};



template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
{
    static const bool value = true;
};

template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
{
    static const bool value = true;
};

template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
{
    static const bool value = true;
};
# 239 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
template<typename T> struct unwrap_reference
{
    typedef T type;
};




template<typename T> struct unwrap_reference< reference_wrapper<T> >
{
    typedef T type;
};



template<typename T> struct unwrap_reference< reference_wrapper<T> const >
{
    typedef T type;
};

template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
{
    typedef T type;
};

template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
{
    typedef T type;
};
# 281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ref.hpp" 3 4
template<class T> inline __attribute__ ((__always_inline__)) typename unwrap_reference<T>::type& unwrap_ref( T & t )
{
    return t;
}






template<class T> inline __attribute__ ((__always_inline__)) T* get_pointer( reference_wrapper<T> const & r )
{
    return r.get_pointer();
}




}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ref.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/alignment_of.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/alignment_of.hpp" 3 4
template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};

template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};


}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_equal.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_equal.hpp" 3 4
namespace boost {

template<typename F, typename G>
  bool function_equal_impl(const F& f, const G& g, long)
  { return f == g; }




template<typename F, typename G>
  bool function_equal(const F& f, const G& g)
  { return function_equal_impl(f, g, 0); }

}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_fwd.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_fwd.hpp" 3 4
namespace boost {
  class bad_function_call;



  template<typename Signature> class function;

  template<typename Signature>
  inline void swap(function<Signature>& f1, function<Signature>& f2)
  {
    f1.swap(f2);
  }



  template<typename R> class function0;
  template<typename R, typename T1> class function1;
  template<typename R, typename T1, typename T2> class function2;
  template<typename R, typename T1, typename T2, typename T3> class function3;
  template<typename R, typename T1, typename T2, typename T3, typename T4>
    class function4;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5>
    class function5;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6>
    class function6;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7>
    class function7;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8>
    class function8;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8, typename T9>
    class function9;
  template<typename R, typename T1, typename T2, typename T3, typename T4,
           typename T5, typename T6, typename T7, typename T8, typename T9,
           typename T10>
    class function10;
}
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 2 3 4
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      class X;







      union function_buffer_members
      {

        typedef void* obj_ptr_t;
        mutable obj_ptr_t obj_ptr;


        struct type_t {

          const boost::typeindex::type_info* type;


          bool const_qualified;

          bool volatile_qualified;
        } type;


        typedef void (*func_ptr_t)();
        mutable func_ptr_t func_ptr;


        struct bound_memfunc_ptr_t {
          void (X::*memfunc_ptr)(int);
          void* obj_ptr;
        } bound_memfunc_ptr;



        struct obj_ref_t {
          mutable void* obj_ptr;
          bool is_const_qualified;
          bool is_volatile_qualified;
        } obj_ref;
      };

      union function_buffer
      {

        mutable function_buffer_members members;


        mutable char data[sizeof(function_buffer_members)];
      };







      struct unusable
      {
        unusable() {}
        template<typename T> unusable(const T&) {}
      };





      template<typename T> struct function_return_type { typedef T type; };

      template<>
      struct function_return_type<void>
      {
        typedef unusable type;
      };


      enum functor_manager_operation_type {
        clone_functor_tag,
        move_functor_tag,
        destroy_functor_tag,
        check_functor_type_tag,
        get_functor_type_tag
      };


      struct function_ptr_tag {};
      struct function_obj_tag {};
      struct member_ptr_tag {};
      struct function_obj_ref_tag {};

      template<typename F>
      class get_function_tag
      {
        typedef typename mpl::if_c<(is_pointer<F>::value),
                                   function_ptr_tag,
                                   function_obj_tag>::type ptr_or_obj_tag;

        typedef typename mpl::if_c<(is_member_pointer<F>::value),
                                   member_ptr_tag,
                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;

        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
                                   function_obj_ref_tag,
                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;

      public:
        typedef or_ref_tag type;
      };



      template<typename F>
      struct reference_manager
      {
        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          switch (op) {
          case clone_functor_tag:
            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
            return;

          case move_functor_tag:
            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
            in_buffer.members.obj_ref.obj_ptr = 0;
            return;

          case destroy_functor_tag:
            out_buffer.members.obj_ref.obj_ptr = 0;
            return;

          case check_functor_type_tag:
            {


              if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
                  && (!in_buffer.members.obj_ref.is_const_qualified
                      || out_buffer.members.type.const_qualified)
                  && (!in_buffer.members.obj_ref.is_volatile_qualified
                      || out_buffer.members.type.volatile_qualified))
                out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
              else
                out_buffer.members.obj_ptr = 0;
            }
            return;

          case get_functor_type_tag:
            out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
            out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
            out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
            return;
          }
        }
      };





      template<typename F>
      struct function_allows_small_object_optimization
      {
        static const bool value = ((sizeof(F) <= sizeof(function_buffer) && (alignment_of<function_buffer>::value % alignment_of<F>::value == 0)))



                                                       ;
      };

      template <typename F,typename A>
      struct functor_wrapper: public F, public A
      {
        functor_wrapper( F f, A a ):
          F(f),
          A(a)
        {
        }

        functor_wrapper(const functor_wrapper& f) :
          F(static_cast<const F&>(f)),
          A(static_cast<const A&>(f))
        {
        }
      };





      template<typename Functor>
      struct functor_manager_common
      {
        typedef Functor functor_type;


        static inline void
        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag)
            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
          else if (op == move_functor_tag) {
            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
            in_buffer.members.func_ptr = 0;
          } else if (op == destroy_functor_tag)
            out_buffer.members.func_ptr = 0;
          else if (op == check_functor_type_tag) {
            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
              out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
            else
              out_buffer.members.obj_ptr = 0;
          } else {
            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
            out_buffer.members.type.const_qualified = false;
            out_buffer.members.type.volatile_qualified = false;
          }
        }


        static inline void
        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op)
        {
          if (op == clone_functor_tag || op == move_functor_tag) {
            const functor_type* in_functor =
              reinterpret_cast<const functor_type*>(in_buffer.data);
            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);

            if (op == move_functor_tag) {
              functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
              (void)f;
              f->~Functor();
            }
          } else if (op == destroy_functor_tag) {

             functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
             (void)f;
             f->~Functor();
          } else if (op == check_functor_type_tag) {
             if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
              out_buffer.members.obj_ptr = in_buffer.data;
            else
              out_buffer.members.obj_ptr = 0;
          } else {
            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
            out_buffer.members.type.const_qualified = false;
            out_buffer.members.type.volatile_qualified = false;
          }
        }
      };

      template<typename Functor>
      struct functor_manager
      {
      private:
        typedef Functor functor_type;


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::false_)
        {
          if (op == clone_functor_tag) {





            const functor_type* f =
              static_cast<const functor_type*>(in_buffer.members.obj_ptr);
            functor_type* new_f = new functor_type(*f);
            out_buffer.members.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
            in_buffer.members.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {

            functor_type* f =
              static_cast<functor_type*>(out_buffer.members.obj_ptr);
            delete f;
            out_buffer.members.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
            else
              out_buffer.members.obj_ptr = 0;
          } else {
            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
            out_buffer.members.type.const_qualified = false;
            out_buffer.members.type.volatile_qualified = false;
          }
        }




        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, member_ptr_tag)
        {
          manager(in_buffer, out_buffer, op, mpl::true_());
        }

      public:


        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
            out_buffer.members.type.const_qualified = false;
            out_buffer.members.type.volatile_qualified = false;
            return;

          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };

      template<typename Functor, typename Allocator>
      struct functor_manager_a
      {
      private:
        typedef Functor functor_type;


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_ptr_tag)
        {
          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::true_)
        {
          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
        }


        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, mpl::false_)
        {
          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;


          if (op == clone_functor_tag) {



            const functor_wrapper_type* f =
              static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



            std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);



            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
            out_buffer.members.obj_ptr = new_f;
          } else if (op == move_functor_tag) {
            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
            in_buffer.members.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {

            functor_wrapper_type* victim =
              static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));



            std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);

            wrapper_allocator.deallocate(victim,1);
            out_buffer.members.obj_ptr = 0;
          } else if (op == check_functor_type_tag) {
            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
            else
              out_buffer.members.obj_ptr = 0;
          } else {
            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
            out_buffer.members.type.const_qualified = false;
            out_buffer.members.type.volatile_qualified = false;
          }
        }




        static inline void
        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
                functor_manager_operation_type op, function_obj_tag)
        {
          manager(in_buffer, out_buffer, op,
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }

      public:


        static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
            out_buffer.members.type.const_qualified = false;
            out_buffer.members.type.volatile_qualified = false;
            return;

          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }
      };


      struct useless_clear_type {};
# 593 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 3 4
      struct vtable_base
      {
        void (*manager)(const function_buffer& in_buffer,
                        function_buffer& out_buffer,
                        functor_manager_operation_type op);
      };
    }
  }







class function_base
{
public:
  function_base() : vtable(0) { }


  bool empty() const { return !vtable; }



  const boost::typeindex::type_info& target_type() const
  {
    if (!vtable) return boost::typeindex::type_id<void>().type_info();

    detail::function::function_buffer type;
    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
    return *type.members.type.type;
  }

  template<typename Functor>
    Functor* target()
    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
      type_result.members.type.const_qualified = is_const<Functor>::value;
      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);
      return static_cast<Functor*>(type_result.members.obj_ptr);
    }

  template<typename Functor>
    const Functor* target() const
    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
      type_result.members.type.const_qualified = true;
      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
      get_vtable()->manager(functor, type_result,
                      detail::function::check_functor_type_tag);


      return static_cast<const Functor*>(type_result.members.obj_ptr);
    }

  template<typename F>
    bool contains(const F& f) const
    {
      if (const F* fp = this->template target<F>())
      {
        return function_equal(*fp, f);
      } else {
        return false;
      }
    }
# 691 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 3 4
public:
  detail::function::vtable_base* get_vtable() const {
    return reinterpret_cast<detail::function::vtable_base*>(
             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
  }

  bool has_trivial_copy_and_destroy() const {
    return reinterpret_cast<std::size_t>(vtable) & 0x01;
  }

  detail::function::vtable_base* vtable;
  mutable detail::function::function_buffer functor;
};
# 713 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 3 4
class bad_function_call : public std::runtime_error
{
public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
};





inline bool operator==(const function_base& f,
                       detail::function::useless_clear_type*)
{
  return f.empty();
}

inline bool operator!=(const function_base& f,
                       detail::function::useless_clear_type*)
{
  return !f.empty();
}

inline bool operator==(detail::function::useless_clear_type*,
                       const function_base& f)
{
  return f.empty();
}

inline bool operator!=(detail::function::useless_clear_type*,
                       const function_base& f)
{
  return !f.empty();
}
# 783 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_base.hpp" 3 4
template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator==(const function_base& f, Functor g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return function_equal(*fp, g);
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator==(Functor g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return function_equal(g, *fp);
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator!=(const function_base& f, Functor g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return !function_equal(*fp, g);
    else return true;
  }

template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator!=(Functor g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return !function_equal(g, *fp);
    else return true;
  }


template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator==(const function_base& f, reference_wrapper<Functor> g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return fp == g.get_pointer();
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator==(reference_wrapper<Functor> g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return g.get_pointer() == fp;
    else return false;
  }

template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator!=(const function_base& f, reference_wrapper<Functor> g)
  {
    if (const Functor* fp = f.template target<Functor>())
      return fp != g.get_pointer();
    else return true;
  }

template<typename Functor>
  typename ::boost::enable_if_c< !(::boost::is_integral<Functor>::value), bool>::type
  operator!=(reference_wrapper<Functor> g, const function_base& f)
  {
    if (const Functor* fp = f.template target<Functor>())
      return g.get_pointer() != fp;
    else return true;
  }



namespace detail {
  namespace function {
    inline bool has_empty_target(const function_base* f)
    {
      return f->empty();
    }







    inline bool has_empty_target(...)
    {
      return false;
    }

  }
}
}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mem_fn.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mem_fn.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/get_pointer.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/get_pointer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/no_tr1/memory.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/get_pointer.hpp" 2 3 4

namespace boost {



template<class T> T * get_pointer(T * p)
{
    return p;
}
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/get_pointer.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"



template<class T> T * get_pointer(std::auto_ptr<T> const& p)
{
    return p.get();
}


#pragma GCC diagnostic pop







template<class T> T * get_pointer( std::unique_ptr<T> const& p )
{
    return p.get();
}

template<class T> T * get_pointer( std::shared_ptr<T> const& p )
{
    return p.get();
}



}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 2 3 4


namespace boost
{
# 207 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 3 4
namespace _mfi
{






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn_template.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn_template.hpp" 3 4
template<class R, class T > class mf0
{
public:

    typedef R result_type;
    typedef T * argument_type;

private:

    typedef R ( T::*F) ();
    F f_;

    template<class U> R call(U & u, T const *) const
    {
        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_)();
    }

public:

    explicit mf0(F f): f_(f) {}

    R operator()(T * p) const
    {
        return (p->*f_)();
    }

    template<class U> R operator()(U & u) const
    {
        U const * p = 0;
        return call(u, p);
    }



    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
        return call(u, p);
    }



    R operator()(T & t) const
    {
        return (t.*f_)();
    }

    bool operator==(mf0 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf0 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T > class cmf0
{
public:

    typedef R result_type;
    typedef T const * argument_type;

private:

    typedef R ( T::*F) () const;
    F f_;

    template<class U> R call(U & u, T const *) const
    {
        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_)();
    }

public:

    explicit cmf0(F f): f_(f) {}

    template<class U> R operator()(U const & u) const
    {
        U const * p = 0;
        return call(u, p);
    }

    R operator()(T const & t) const
    {
        return (t.*f_)();
    }

    bool operator==(cmf0 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf0 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1 > class mf1
{
public:

    typedef R result_type;
    typedef T * first_argument_type;
    typedef A1 second_argument_type;

private:

    typedef R ( T::*F) (A1);
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
        return (get_pointer(u)->*f_)(b1);
    }

public:

    explicit mf1(F f): f_(f) {}

    R operator()(T * p, A1 a1) const
    {
        return (p->*f_)(a1);
    }

    template<class U> R operator()(U & u, A1 a1) const
    {
        U const * p = 0;
        return call(u, p, a1);
    }



    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
        return call(u, p, a1);
    }



    R operator()(T & t, A1 a1) const
    {
        return (t.*f_)(a1);
    }

    bool operator==(mf1 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf1 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1 > class cmf1
{
public:

    typedef R result_type;
    typedef T const * first_argument_type;
    typedef A1 second_argument_type;

private:

    typedef R ( T::*F) (A1) const;
    F f_;

    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
    {
        return (u.*f_)(b1);
    }

    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
    {
        return (get_pointer(u)->*f_)(b1);
    }

public:

    explicit cmf1(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1) const
    {
        U const * p = 0;
        return call(u, p, a1);
    }

    R operator()(T const & t, A1 a1) const
    {
        return (t.*f_)(a1);
    }

    bool operator==(cmf1 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf1 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2 > class mf2
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2);
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
        return (get_pointer(u)->*f_)(b1, b2);
    }

public:

    explicit mf2(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2) const
    {
        return (p->*f_)(a1, a2);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
        return call(u, p, a1, a2);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
        return call(u, p, a1, a2);
    }



    R operator()(T & t, A1 a1, A2 a2) const
    {
        return (t.*f_)(a1, a2);
    }

    bool operator==(mf2 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf2 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2 > class cmf2
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2) const;
    F f_;

    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
    {
        return (u.*f_)(b1, b2);
    }

    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
    {
        return (get_pointer(u)->*f_)(b1, b2);
    }

public:

    explicit cmf2(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        U const * p = 0;
        return call(u, p, a1, a2);
    }

    R operator()(T const & t, A1 a1, A2 a2) const
    {
        return (t.*f_)(a1, a2);
    }

    bool operator==(cmf2 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf2 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3 > class mf3
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3);
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

public:

    explicit mf3(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
    {
        return (p->*f_)(a1, a2, a3);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
    {
        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(mf3 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf3 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3 > class cmf3
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3) const;
    F f_;

    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (u.*f_)(b1, b2, b3);
    }

    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3);
    }

public:

    explicit cmf3(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
    {
        return (t.*f_)(a1, a2, a3);
    }

    bool operator==(cmf3 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf3 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4 > class mf4
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4);
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

public:

    explicit mf4(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (p->*f_)(a1, a2, a3, a4);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(mf4 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf4 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4 > class cmf4
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (u.*f_)(b1, b2, b3, b4);
    }

    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
    }

public:

    explicit cmf4(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return (t.*f_)(a1, a2, a3, a4);
    }

    bool operator==(cmf4 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf4 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class mf5
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

public:

    explicit mf5(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(mf5 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf5 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class cmf5
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
    }

public:

    explicit cmf5(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5);
    }

    bool operator==(cmf5 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf5 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class mf6
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

public:

    explicit mf6(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(mf6 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf6 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class cmf6
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
    }

public:

    explicit cmf6(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6);
    }

    bool operator==(cmf6 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf6 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class mf7
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

public:

    explicit mf7(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(mf7 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf7 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class cmf7
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
    }

public:

    explicit cmf7(F f): f_(f) {}

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
    }

    bool operator==(cmf7 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf7 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class mf8
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

public:

    explicit mf8(F f): f_(f) {}

    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }



    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(mf8 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(mf8 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};



template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class cmf8
{
public:

    typedef R result_type;

private:

    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
    F f_;

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
    {
        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
    }

public:

    explicit cmf8(F f): f_(f) {}

    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        U const * p = 0;
        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(cmf8 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf8 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};
# 216 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 2 3 4
# 258 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 3 4
}
# 268 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn_cc.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn_cc.hpp" 3 4
template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
{
    return _mfi::mf0<R, T>(f);
}

template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
{
    return _mfi::cmf0<R, T>(f);
}

template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
{
    return _mfi::mf1<R, T, A1>(f);
}

template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
{
    return _mfi::cmf1<R, T, A1>(f);
}

template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
{
    return _mfi::mf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
{
    return _mfi::cmf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
{
    return _mfi::mf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
{
    return _mfi::cmf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
{
    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
{
    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
{
    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
{
    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
{
    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
{
    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
{
    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
{
    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
{
    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
{
    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}
# 269 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 2 3 4
# 311 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/mem_fn.hpp" 3 4
namespace _mfi
{

template<class R, class T> class dm
{
public:

    typedef R const & result_type;
    typedef T const * argument_type;

private:

    typedef R (T::*F);
    F f_;

    template<class U> R const & call(U & u, T const *) const
    {
        return (u.*f_);
    }

    template<class U> R const & call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_);
    }

public:

    explicit dm(F f): f_(f) {}

    R & operator()(T * p) const
    {
        return (p->*f_);
    }

    R const & operator()(T const * p) const
    {
        return (p->*f_);
    }

    template<class U> R const & operator()(U const & u) const
    {
        return call(u, &u);
    }



    R & operator()(T & t) const
    {
        return (t.*f_);
    }

    R const & operator()(T const & t) const
    {
        return (t.*f_);
    }



    bool operator==(dm const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(dm const & rhs) const
    {
        return f_ != rhs.f_;
    }
};

}

template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
{
    return _mfi::dm<R, T>(f);
}

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mem_fn.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum_params.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/prologue.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 2 3 4
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R
       
        >
      struct function_invoker0
      {
        static R invoke(function_buffer& function_ptr
                        )
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f();
        }
      };

      template<
        typename FunctionPtr,
        typename R
       
        >
      struct void_function_invoker0
      {
        static void
        invoke(function_buffer& function_ptr
               )

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct function_obj_invoker0
      {
        static R invoke(function_buffer& function_obj_ptr
                        )

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct void_function_obj_invoker0
      {
        static void
        invoke(function_buffer& function_obj_ptr
               )

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct function_ref_invoker0
      {
        static R invoke(function_buffer& function_obj_ptr
                        )

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)();
        }
      };

      template<
        typename FunctionObj,
        typename R
       
      >
      struct void_function_ref_invoker0
      {
        static void
        invoke(function_buffer& function_obj_ptr
               )

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)();
        }
      };
# 236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<
        typename FunctionPtr,
        typename R
       
      >
      struct get_function_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker0<
                            FunctionPtr,
                            R
                           
                          >,
                          function_invoker0<
                            FunctionPtr,
                            R
                           
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R
       
       >
      struct get_function_obj_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker0<
                            FunctionObj,
                            R
                           
                          >,
                          function_obj_invoker0<
                            FunctionObj,
                            R
                           
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R
       
       >
      struct get_function_ref_invoker0
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker0<
                            FunctionObj,
                            R
                           
                          >,
                          function_ref_invoker0<
                            FunctionObj,
                            R
                           
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker0 { };


      template<>
      struct get_invoker0<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R >
        struct apply
        {
          typedef typename get_function_invoker0<
                             FunctionPtr,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker0<
                             FunctionPtr,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };
# 406 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<>
      struct get_invoker0<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R >
        struct apply
        {
          typedef typename get_function_obj_invoker0<
                             FunctionObj,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker0<
                             FunctionObj,
                             R
                            
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker0<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R >
        struct apply
        {
          typedef typename get_function_ref_invoker0<
                             typename RefWrapper::type,
                             R
                            
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R ,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker0<
                             typename RefWrapper::type,
                             R
                            
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R >
      struct basic_vtable0
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                           
                                            );

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }
# 568 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R
   
  >
  class function0 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable0<
              R >
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 0;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 0;
   

    typedef function0 self_type;

    function0() : function_base() { }



    template<typename Functor>
    function0(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function0(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function0(clear_type*) : function_base() { }







    function0(const function0& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function0(function0&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function0() { clear(); }

    result_type operator()() const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor );
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function0&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function0& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function0& operator=(const function0& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function0& operator=(function0&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function0& other)
    {
      if (&other == this)
        return;

      function0 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function0& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker0<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R
                        >
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker0<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R
                         ,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function0& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R >
  inline void swap(function0<
                     R
                    
                   >& f1,
                   function0<
                     R
                    
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R >
  void operator==(const function0<
                          R
                          >&,
                  const function0<
                          R
                          >&);
template<typename R >
  void operator!=(const function0<
                          R
                          >&,
                  const function0<
                          R
                          >& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R
         >
class function<R (void)>
  : public function0<R >
{
  typedef function0<R > base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0
        >
      struct function_invoker1
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0
        >
      struct void_function_invoker1
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct function_obj_invoker1
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct void_function_obj_invoker1
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct function_ref_invoker1
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
      >
      struct void_function_ref_invoker1
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0
      >
      struct function_mem_invoker1
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0
      >
      struct function_void_mem_invoker1
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0
      >
      struct get_function_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker1<
                            FunctionPtr,
                            R ,
                            T0
                          >,
                          function_invoker1<
                            FunctionPtr,
                            R ,
                            T0
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
       >
      struct get_function_obj_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >,
                          function_obj_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0
       >
      struct get_function_ref_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >,
                          function_ref_invoker1<
                            FunctionObj,
                            R ,
                            T0
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0
       >
      struct get_member_invoker1
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker1<
                            MemberPtr,
                            R ,
                            T0
                          >,
                          function_mem_invoker1<
                            MemberPtr,
                            R ,
                            T0
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker1 { };


      template<>
      struct get_invoker1<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_function_invoker1<
                             FunctionPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker1<
                             FunctionPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker1<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_member_invoker1<
                             MemberPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker1<
                             MemberPtr,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker1<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_function_obj_invoker1<
                             FunctionObj,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker1<
                             FunctionObj,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker1<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0>
        struct apply
        {
          typedef typename get_function_ref_invoker1<
                             typename RefWrapper::type,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker1<
                             typename RefWrapper::type,
                             R ,
                             T0
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0>
      struct basic_vtable1
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0
  >
  class function1 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable1<
              R , T0>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 1;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };


    typedef T0 argument_type;





    static const int arity = 1;
    typedef T0 arg1_type;

    typedef function1 self_type;

    function1() : function_base() { }



    template<typename Functor>
    function1(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function1(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function1(clear_type*) : function_base() { }







    function1(const function1& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function1(function1&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function1() { clear(); }

    result_type operator()( T0 a0) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function1&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function1& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function1& operator=(const function1& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function1& operator=(function1&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function1& other)
    {
      if (&other == this)
        return;

      function1 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function1& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker1<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker1<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function1& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0>
  inline void swap(function1<
                     R ,
                     T0
                   >& f1,
                   function1<
                     R ,
                     T0
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0>
  void operator==(const function1<
                          R ,
                          T0>&,
                  const function1<
                          R ,
                          T0>&);
template<typename R , typename T0>
  void operator!=(const function1<
                          R ,
                          T0>&,
                  const function1<
                          R ,
                          T0>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0>
class function<R ( T0)>
  : public function1<R , T0>
{
  typedef function1<R , T0> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
        >
      struct function_invoker2
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
        >
      struct void_function_invoker2
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct function_obj_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct void_function_obj_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct function_ref_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
      >
      struct void_function_ref_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct function_mem_invoker2
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct function_void_mem_invoker2
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1
      >
      struct get_function_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker2<
                            FunctionPtr,
                            R ,
                            T0 , T1
                          >,
                          function_invoker2<
                            FunctionPtr,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
       >
      struct get_function_obj_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >,
                          function_obj_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1
       >
      struct get_function_ref_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >,
                          function_ref_invoker2<
                            FunctionObj,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1
       >
      struct get_member_invoker2
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker2<
                            MemberPtr,
                            R ,
                            T0 , T1
                          >,
                          function_mem_invoker2<
                            MemberPtr,
                            R ,
                            T0 , T1
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker2 { };


      template<>
      struct get_invoker2<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_invoker2<
                             FunctionPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker2<
                             FunctionPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker2<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_member_invoker2<
                             MemberPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker2<
                             MemberPtr,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker2<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_obj_invoker2<
                             FunctionObj,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker2<
                             FunctionObj,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker2<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1>
        struct apply
        {
          typedef typename get_function_ref_invoker2<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker2<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1>
      struct basic_vtable2
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1
  >
  class function2 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable2<
              R , T0 , T1>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 2;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };




    typedef T0 first_argument_type;
    typedef T1 second_argument_type;


    static const int arity = 2;
    typedef T0 arg1_type; typedef T1 arg2_type;

    typedef function2 self_type;

    function2() : function_base() { }



    template<typename Functor>
    function2(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function2(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function2(clear_type*) : function_base() { }







    function2(const function2& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function2(function2&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function2() { clear(); }

    result_type operator()( T0 a0 , T1 a1) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function2&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function2& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function2& operator=(const function2& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function2& operator=(function2&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function2& other)
    {
      if (&other == this)
        return;

      function2 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function2& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker2<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker2<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function2& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1>
  inline void swap(function2<
                     R ,
                     T0 , T1
                   >& f1,
                   function2<
                     R ,
                     T0 , T1
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1>
  void operator==(const function2<
                          R ,
                          T0 , T1>&,
                  const function2<
                          R ,
                          T0 , T1>&);
template<typename R , typename T0 , typename T1>
  void operator!=(const function2<
                          R ,
                          T0 , T1>&,
                  const function2<
                          R ,
                          T0 , T1>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1>
class function<R ( T0 , T1)>
  : public function2<R , T0 , T1>
{
  typedef function2<R , T0 , T1> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
        >
      struct function_invoker3
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
        >
      struct void_function_invoker3
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_obj_invoker3
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct void_function_obj_invoker3
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_ref_invoker3
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct void_function_ref_invoker3
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_mem_invoker3
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct function_void_mem_invoker3
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
      >
      struct get_function_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker3<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_invoker3<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
       >
      struct get_function_obj_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_obj_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2
       >
      struct get_function_ref_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_ref_invoker3<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2
       >
      struct get_member_invoker3
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker3<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2
                          >,
                          function_mem_invoker3<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker3 { };


      template<>
      struct get_invoker3<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_function_invoker3<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker3<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker3<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_member_invoker3<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker3<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker3<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_function_obj_invoker3<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker3<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker3<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2>
        struct apply
        {
          typedef typename get_function_ref_invoker3<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker3<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2>
      struct basic_vtable3
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2
  >
  class function3 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable3<
              R , T0 , T1 , T2>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 3;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 3;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type;

    typedef function3 self_type;

    function3() : function_base() { }



    template<typename Functor>
    function3(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function3(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function3(clear_type*) : function_base() { }







    function3(const function3& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function3(function3&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function3() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function3&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function3& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function3& operator=(const function3& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function3& operator=(function3&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function3& other)
    {
      if (&other == this)
        return;

      function3 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function3& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker3<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker3<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function3& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2>
  inline void swap(function3<
                     R ,
                     T0 , T1 , T2
                   >& f1,
                   function3<
                     R ,
                     T0 , T1 , T2
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2>
  void operator==(const function3<
                          R ,
                          T0 , T1 , T2>&,
                  const function3<
                          R ,
                          T0 , T1 , T2>&);
template<typename R , typename T0 , typename T1 , typename T2>
  void operator!=(const function3<
                          R ,
                          T0 , T1 , T2>&,
                  const function3<
                          R ,
                          T0 , T1 , T2>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2>
class function<R ( T0 , T1 , T2)>
  : public function3<R , T0 , T1 , T2>
{
  typedef function3<R , T0 , T1 , T2> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
        >
      struct function_invoker4
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
        >
      struct void_function_invoker4
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_obj_invoker4
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct void_function_obj_invoker4
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_ref_invoker4
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct void_function_ref_invoker4
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_mem_invoker4
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct function_void_mem_invoker4
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
      >
      struct get_function_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker4<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_invoker4<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
       >
      struct get_function_obj_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_obj_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
       >
      struct get_function_ref_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_ref_invoker4<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3
       >
      struct get_member_invoker4
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker4<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >,
                          function_mem_invoker4<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker4 { };


      template<>
      struct get_invoker4<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_function_invoker4<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker4<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker4<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_member_invoker4<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker4<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker4<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_function_obj_invoker4<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker4<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker4<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
        struct apply
        {
          typedef typename get_function_ref_invoker4<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker4<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
      struct basic_vtable4
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3
  >
  class function4 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable4<
              R , T0 , T1 , T2 , T3>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 4;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 4;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type;

    typedef function4 self_type;

    function4() : function_base() { }



    template<typename Functor>
    function4(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function4(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function4(clear_type*) : function_base() { }







    function4(const function4& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function4(function4&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function4() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function4&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function4& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function4& operator=(const function4& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function4& operator=(function4&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function4& other)
    {
      if (&other == this)
        return;

      function4 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function4& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker4<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker4<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function4& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
  inline void swap(function4<
                     R ,
                     T0 , T1 , T2 , T3
                   >& f1,
                   function4<
                     R ,
                     T0 , T1 , T2 , T3
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
  void operator==(const function4<
                          R ,
                          T0 , T1 , T2 , T3>&,
                  const function4<
                          R ,
                          T0 , T1 , T2 , T3>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
  void operator!=(const function4<
                          R ,
                          T0 , T1 , T2 , T3>&,
                  const function4<
                          R ,
                          T0 , T1 , T2 , T3>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3>
class function<R ( T0 , T1 , T2 , T3)>
  : public function4<R , T0 , T1 , T2 , T3>
{
  typedef function4<R , T0 , T1 , T2 , T3> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
        >
      struct function_invoker5
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
        >
      struct void_function_invoker5
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_obj_invoker5
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct void_function_obj_invoker5
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_ref_invoker5
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct void_function_ref_invoker5
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_mem_invoker5
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct function_void_mem_invoker5
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
      >
      struct get_function_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker5<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_invoker5<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
       >
      struct get_function_obj_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_obj_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
       >
      struct get_function_ref_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_ref_invoker5<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
       >
      struct get_member_invoker5
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker5<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >,
                          function_mem_invoker5<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker5 { };


      template<>
      struct get_invoker5<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_function_invoker5<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker5<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker5<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_member_invoker5<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker5<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker5<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_function_obj_invoker5<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker5<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker5<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
        struct apply
        {
          typedef typename get_function_ref_invoker5<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker5<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
      struct basic_vtable5
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4
  >
  class function5 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable5<
              R , T0 , T1 , T2 , T3 , T4>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 5;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 5;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type;

    typedef function5 self_type;

    function5() : function_base() { }



    template<typename Functor>
    function5(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function5(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function5(clear_type*) : function_base() { }







    function5(const function5& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function5(function5&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function5() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function5&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function5& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function5& operator=(const function5& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function5& operator=(function5&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function5& other)
    {
      if (&other == this)
        return;

      function5 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function5& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker5<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker5<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function5& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
  inline void swap(function5<
                     R ,
                     T0 , T1 , T2 , T3 , T4
                   >& f1,
                   function5<
                     R ,
                     T0 , T1 , T2 , T3 , T4
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
  void operator==(const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>&,
                  const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
  void operator!=(const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>&,
                  const function5<
                          R ,
                          T0 , T1 , T2 , T3 , T4>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
class function<R ( T0 , T1 , T2 , T3 , T4)>
  : public function5<R , T0 , T1 , T2 , T3 , T4>
{
  typedef function5<R , T0 , T1 , T2 , T3 , T4> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
        >
      struct function_invoker6
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
        >
      struct void_function_invoker6
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_obj_invoker6
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct void_function_obj_invoker6
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_ref_invoker6
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct void_function_ref_invoker6
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_mem_invoker6
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct function_void_mem_invoker6
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
      >
      struct get_function_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker6<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_invoker6<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
       >
      struct get_function_obj_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_obj_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
       >
      struct get_function_ref_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_ref_invoker6<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
       >
      struct get_member_invoker6
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker6<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >,
                          function_mem_invoker6<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker6 { };


      template<>
      struct get_invoker6<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_function_invoker6<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker6<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker6<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_member_invoker6<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker6<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker6<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_function_obj_invoker6<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker6<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker6<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
        struct apply
        {
          typedef typename get_function_ref_invoker6<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker6<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
      struct basic_vtable6
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
  >
  class function6 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable6<
              R , T0 , T1 , T2 , T3 , T4 , T5>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 6;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 6;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type;

    typedef function6 self_type;

    function6() : function_base() { }



    template<typename Functor>
    function6(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function6(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function6(clear_type*) : function_base() { }







    function6(const function6& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function6(function6&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function6() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function6&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function6& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function6& operator=(const function6& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function6& operator=(function6&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function6& other)
    {
      if (&other == this)
        return;

      function6 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function6& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker6<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker6<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function6& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
  inline void swap(function6<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5
                   >& f1,
                   function6<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
  void operator==(const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>&,
                  const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
  void operator!=(const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>&,
                  const function6<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5)>
  : public function6<R , T0 , T1 , T2 , T3 , T4 , T5>
{
  typedef function6<R , T0 , T1 , T2 , T3 , T4 , T5> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
        >
      struct function_invoker7
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
        >
      struct void_function_invoker7
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_obj_invoker7
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct void_function_obj_invoker7
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_ref_invoker7
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct void_function_ref_invoker7
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_mem_invoker7
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct function_void_mem_invoker7
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
      >
      struct get_function_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker7<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_invoker7<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
       >
      struct get_function_obj_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_obj_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
       >
      struct get_function_ref_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_ref_invoker7<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
       >
      struct get_member_invoker7
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker7<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >,
                          function_mem_invoker7<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker7 { };


      template<>
      struct get_invoker7<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_function_invoker7<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker7<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker7<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_member_invoker7<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker7<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker7<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_function_obj_invoker7<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker7<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker7<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
        struct apply
        {
          typedef typename get_function_ref_invoker7<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker7<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
      struct basic_vtable7
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
  >
  class function7 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable7<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 7;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 7;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type;

    typedef function7 self_type;

    function7() : function_base() { }



    template<typename Functor>
    function7(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function7(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function7(clear_type*) : function_base() { }







    function7(const function7& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function7(function7&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function7() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function7&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function7& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function7& operator=(const function7& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function7& operator=(function7&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function7& other)
    {
      if (&other == this)
        return;

      function7 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function7& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker7<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker7<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function7& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
  inline void swap(function7<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6
                   >& f1,
                   function7<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
  void operator==(const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
                  const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
  void operator!=(const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
                  const function7<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
  : public function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
{
  typedef function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
        >
      struct function_invoker8
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
        >
      struct void_function_invoker8
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_obj_invoker8
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct void_function_obj_invoker8
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_ref_invoker8
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct void_function_ref_invoker8
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_mem_invoker8
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct function_void_mem_invoker8
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
      >
      struct get_function_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker8<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_invoker8<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
       >
      struct get_function_obj_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_obj_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
       >
      struct get_function_ref_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_ref_invoker8<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
       >
      struct get_member_invoker8
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker8<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >,
                          function_mem_invoker8<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker8 { };


      template<>
      struct get_invoker8<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_function_invoker8<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker8<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker8<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_member_invoker8<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker8<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker8<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_function_obj_invoker8<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker8<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker8<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
        struct apply
        {
          typedef typename get_function_ref_invoker8<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker8<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
      struct basic_vtable8
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
  >
  class function8 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable8<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 8;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 8;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type;

    typedef function8 self_type;

    function8() : function_base() { }



    template<typename Functor>
    function8(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function8(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function8(clear_type*) : function_base() { }







    function8(const function8& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function8(function8&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function8() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function8&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function8& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function8& operator=(const function8& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function8& operator=(function8&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function8& other)
    {
      if (&other == this)
        return;

      function8 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function8& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker8<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker8<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function8& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
  inline void swap(function8<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                   >& f1,
                   function8<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
  void operator==(const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
                  const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
  void operator!=(const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
                  const function8<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
  : public function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
{
  typedef function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
        >
      struct function_invoker9
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
        >
      struct void_function_invoker9
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_obj_invoker9
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct void_function_obj_invoker9
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_ref_invoker9
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct void_function_ref_invoker9
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_mem_invoker9
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct function_void_mem_invoker9
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
      >
      struct get_function_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker9<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_invoker9<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
       >
      struct get_function_obj_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_obj_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
       >
      struct get_function_ref_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_ref_invoker9<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
       >
      struct get_member_invoker9
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker9<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >,
                          function_mem_invoker9<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker9 { };


      template<>
      struct get_invoker9<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_function_invoker9<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker9<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker9<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_member_invoker9<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker9<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker9<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_function_obj_invoker9<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker9<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker9<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
        struct apply
        {
          typedef typename get_function_ref_invoker9<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker9<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
      struct basic_vtable9
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
  >
  class function9 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable9<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 9;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 9;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type;

    typedef function9 self_type;

    function9() : function_base() { }



    template<typename Functor>
    function9(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function9(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function9(clear_type*) : function_base() { }







    function9(const function9& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function9(function9&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function9() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function9&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function9& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function9& operator=(const function9& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function9& operator=(function9&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function9& other)
    {
      if (&other == this)
        return;

      function9 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function9& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker9<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker9<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function9& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
  inline void swap(function9<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                   >& f1,
                   function9<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
  void operator==(const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
                  const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
  void operator!=(const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
                  const function9<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
  : public function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
{
  typedef function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
namespace boost {
  namespace detail {
    namespace function {
      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
        >
      struct function_invoker10
      {
        static R invoke(function_buffer& function_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          return f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };

      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
        >
      struct void_function_invoker10
      {
        static void
        invoke(function_buffer& function_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
          f( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_obj_invoker10
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct void_function_obj_invoker10
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f;
          if (function_allows_small_object_optimization<FunctionObj>::value)
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
          else
            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_ref_invoker10
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          return (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct void_function_ref_invoker10
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          FunctionObj* f =
            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
          (*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_mem_invoker10
      {
        static R invoke(function_buffer& function_obj_ptr ,
                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          return boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };

      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct function_void_mem_invoker10
      {
        static void
        invoke(function_buffer& function_obj_ptr ,
               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)

        {
          MemberPtr* f =
            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
          boost::mem_fn(*f)( ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
        }
      };


      template<
        typename FunctionPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
      >
      struct get_function_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_invoker10<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_invoker10<
                            FunctionPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
       >
      struct get_function_obj_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_obj_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_obj_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };

      template<
        typename FunctionObj,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
       >
      struct get_function_ref_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            void_function_ref_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_ref_invoker10<
                            FunctionObj,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };



      template<
        typename MemberPtr,
        typename R ,
        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
       >
      struct get_member_invoker10
      {
        typedef typename mpl::if_c<(is_void<R>::value),
                            function_void_mem_invoker10<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >,
                          function_mem_invoker10<
                            MemberPtr,
                            R ,
                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                          >
                       >::type type;
      };
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename Tag>
      struct get_invoker10 { };


      template<>
      struct get_invoker10<function_ptr_tag>
      {
        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_function_invoker10<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };

        template<typename FunctionPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_invoker10<
                             FunctionPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<FunctionPtr> manager_type;
        };
      };



      template<>
      struct get_invoker10<member_ptr_tag>
      {
        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_member_invoker10<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };

        template<typename MemberPtr,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_member_invoker10<
                             MemberPtr,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<MemberPtr> manager_type;
        };
      };



      template<>
      struct get_invoker10<function_obj_tag>
      {
        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_function_obj_invoker10<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager<FunctionObj> manager_type;
        };

        template<typename FunctionObj,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_obj_invoker10<
                             FunctionObj,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
        };
      };


      template<>
      struct get_invoker10<function_obj_ref_tag>
      {
        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
        struct apply
        {
          typedef typename get_function_ref_invoker10<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };

        template<typename RefWrapper,
                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
                 typename Allocator>
        struct apply_a
        {
          typedef typename get_function_ref_invoker10<
                             typename RefWrapper::type,
                             R ,
                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                           >::type
            invoker_type;

          typedef reference_manager<typename RefWrapper::type> manager_type;
        };
      };
# 481 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
      struct basic_vtable10
      {

        typedef R result_type;




        typedef result_type (*invoker_type)(function_buffer&
                                            ,
                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9);

        template<typename F>
        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

        void clear(function_buffer& functor) const
        {
          if (base.manager)
            base.manager(functor, functor, destroy_functor_tag);
        }

      private:

        template<typename FunctionPtr>
        bool
        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {


            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionPtr,typename Allocator>
        bool
        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }



        template<typename MemberPtr>
        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {



          if (f) {
            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {



          if (f) {
            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
          }
        }




        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }


        template<typename FunctionObj>
        void
        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.members.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void
        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;





          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;

          wrapper_allocator_type wrapper_allocator(a);
          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);



          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));

          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
          functor.members.obj_ptr = new_f;
        }

        template<typename FunctionObj>
        bool
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }


        template<typename FunctionObj>
        bool
        assign_to(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, function_obj_ref_tag) const
        {
          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool
        assign_to_a(const reference_wrapper<FunctionObj>& f,
                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
        vtable_base base;
        invoker_type invoker;
      };
    }
  }

  template<
    typename R ,
    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
  >
  class function10 : public function_base
  {
  public:

    typedef R result_type;





  private:
    typedef boost::detail::function::basic_vtable10<
              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
      vtable_type;

    vtable_type* get_vtable() const {
      return reinterpret_cast<vtable_type*>(
               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 10;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    static const int arity = 10;
    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type;

    typedef function10 self_type;

    function10() : function_base() { }



    template<typename Functor>
    function10(Functor f

                            ,typename boost::enable_if_c<
                             !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to(f);
    }
    template<typename Functor,typename Allocator>
    function10(Functor f, Allocator a

                            ,typename boost::enable_if_c<
                              !(is_integral<Functor>::value),
                                        int>::type = 0

                            ) :
      function_base()
    {
      this->assign_to_a(f,a);
    }


    function10(clear_type*) : function_base() { }







    function10(const function10& f) : function_base()
    {
      this->assign_to_own(f);
    }


    function10(function10&& f) : function_base()
    {
      this->move_assign(f);
    }


    ~function10() { clear(); }

    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor , ::boost::forward< T0 >(a0) , ::boost::forward< T1 >(a1) , ::boost::forward< T2 >(a2) , ::boost::forward< T3 >(a3) , ::boost::forward< T4 >(a4) , ::boost::forward< T5 >(a5) , ::boost::forward< T6 >(a6) , ::boost::forward< T7 >(a7) , ::boost::forward< T8 >(a8) , ::boost::forward< T9 >(a9));
    }






    template<typename Functor>

    typename boost::enable_if_c<
                  !(is_integral<Functor>::value),
               function10&>::type



    operator=(Functor f)
    {
      this->clear();
      { try {
        this->assign_to(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor f, Allocator a)
    {
      this->clear();
      { try{
        this->assign_to_a(f,a);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }


    function10& operator=(clear_type*)
    {
      this->clear();
      return *this;
    }
# 826 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
    function10& operator=(const function10& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }



    function10& operator=(function10&& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->move_assign(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }


    void swap(function10& other)
    {
      if (&other == this)
        return;

      function10 tmp;
      tmp.move_assign(*this);
      this->move_assign(other);
      other.move_assign(tmp);
    }


    void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }





  private:
    struct dummy {
      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();

  public:
    operator safe_bool () const
      { return (this->empty())? 0 : &dummy::nonnull; }

    bool operator!() const
      { return this->empty(); }


  private:
    void assign_to_own(const function10& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker10<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R ,
                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }

    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::get_invoker10<tag> get_invoker;
      typedef typename get_invoker::
                         template apply_a<Functor, R ,
                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9,
                         Allocator>
        handler_type;

      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;





      static const vtable_type stored_vtable =
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to_a(f, functor, a)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);

        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else
        vtable = 0;
    }




    void move_assign(function10& f)
    {
      if (&f == this)
        return;

      { try {
        if (!f.empty()) {
          this->vtable = f.vtable;
          if (this->has_trivial_copy_and_destroy())
            this->functor = f.functor;
          else
            get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::move_functor_tag);
          f.vtable = 0;
        } else {
          clear();
        }
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
    }
  };

  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  inline void swap(function10<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                   >& f1,
                   function10<
                     R ,
                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
                   >& f2)
  {
    f1.swap(f2);
  }


template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  void operator==(const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
                  const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&);
template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  void operator!=(const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
                  const function10<
                          R ,
                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>& );
# 1048 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/function_template.hpp" 3 4
template<typename R ,
         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
  : public function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
{
  typedef function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
  typedef function self_type;

  struct clear_type {};

public:

  function() : base_type() {}

  template<typename Functor>
  function(Functor f

           ,typename boost::enable_if_c<
                          !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f)
  {
  }
  template<typename Functor,typename Allocator>
  function(Functor f, Allocator a

           ,typename boost::enable_if_c<
                           !(is_integral<Functor>::value),
                       int>::type = 0

           ) :
    base_type(f,a)
  {
  }


  function(clear_type*) : base_type() {}


  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}



  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}


  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(self_type&& f)
  {
    self_type(static_cast<self_type&&>(f)).swap(*this);
    return *this;
  }


  template<typename Functor>

  typename boost::enable_if_c<
                         !(is_integral<Functor>::value),
                      self_type&>::type



  operator=(Functor f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(clear_type*)
  {
    this->clear();
    return *this;
  }


  self_type& operator=(const base_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }


  self_type& operator=(base_type&& f)
  {
    self_type(static_cast<base_type&&>(f)).swap(*this);
    return *this;
  }

};




}
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_iterator.hpp" 2 3 4

namespace boost {
    namespace algorithm {
        namespace detail {




            template<typename IteratorT>
            class find_iterator_base
            {
            protected:

                typedef IteratorT input_iterator_type;
                typedef iterator_range<IteratorT> match_type;
                typedef function2<
                    match_type,
                    input_iterator_type,
                    input_iterator_type> finder_type;

            protected:



                find_iterator_base() {}

                find_iterator_base( const find_iterator_base& Other ) :
                    m_Finder(Other.m_Finder) {}


                template<typename FinderT>
                find_iterator_base( FinderT Finder, int ) :
                    m_Finder(Finder) {}


                ~find_iterator_base() {}


                match_type do_find(
                    input_iterator_type Begin,
                    input_iterator_type End ) const
                {
                    if (!m_Finder.empty())
                    {
                        return m_Finder(Begin,End);
                    }
                    else
                    {
                        return match_type(End,End);
                    }
                }


                bool is_null() const
                {
                    return m_Finder.empty();
                }

            private:

                finder_type m_Finder;
            };

       }
    }
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 3 4
        template<typename IteratorT>
        class find_iterator :
            public iterator_facade<
                find_iterator<IteratorT>,
                const iterator_range<IteratorT>,
                forward_traversal_tag >,
            private detail::find_iterator_base<IteratorT>
        {
        private:

            friend class ::boost::iterator_core_access;

        private:


            typedef detail::find_iterator_base<IteratorT> base_type;
            typedef typename
                base_type::input_iterator_type input_iterator_type;
            typedef typename
                base_type::match_type match_type;

        public:






            find_iterator() {}





            find_iterator( const find_iterator& Other ) :
                base_type(Other),
                m_Match(Other.m_Match),
                m_End(Other.m_End) {}






            template<typename FinderT>
            find_iterator(
                    IteratorT Begin,
                    IteratorT End,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0),
                m_Match(Begin,Begin),
                m_End(End)
            {
                increment();
            }






            template<typename FinderT, typename RangeT>
            find_iterator(
                    RangeT& Col,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0)
            {
                iterator_range<typename range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
                m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
                m_End=::boost::end(lit_col);

                increment();
            }

        private:



            const match_type& dereference() const
            {
                return m_Match;
            }


            void increment()
            {
                m_Match=this->do_find(m_Match.end(),m_End);
            }


            bool equal( const find_iterator& Other ) const
            {
                bool bEof=eof();
                bool bOtherEof=Other.eof();

                return bEof || bOtherEof ? bEof==bOtherEof :
                    (
                        m_Match==Other.m_Match &&
                        m_End==Other.m_End
                    );
            }

        public:
# 160 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 3 4
            bool eof() const
            {
                return
                    this->is_null() ||
                    (
                        m_Match.begin() == m_End &&
                        m_Match.end() == m_End
                    );
            }

        private:

            match_type m_Match;
            input_iterator_type m_End;
        };





        template<typename RangeT, typename FinderT>
        inline find_iterator<
            typename range_iterator<RangeT>::type>
        make_find_iterator(
            RangeT& Collection,
            FinderT Finder)
        {
            return find_iterator<typename range_iterator<RangeT>::type>(
                Collection, Finder);
        }
# 205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 3 4
        template<typename IteratorT>
        class split_iterator :
            public iterator_facade<
                split_iterator<IteratorT>,
                const iterator_range<IteratorT>,
                forward_traversal_tag >,
            private detail::find_iterator_base<IteratorT>
        {
        private:

            friend class ::boost::iterator_core_access;

        private:


            typedef detail::find_iterator_base<IteratorT> base_type;
            typedef typename
                base_type::input_iterator_type input_iterator_type;
            typedef typename
                base_type::match_type match_type;

        public:






            split_iterator() :
                m_Next(),
                m_End(),
                m_bEof(true)
            {}





            split_iterator( const split_iterator& Other ) :
                base_type(Other),
                m_Match(Other.m_Match),
                m_Next(Other.m_Next),
                m_End(Other.m_End),
                m_bEof(Other.m_bEof)
            {}






            template<typename FinderT>
            split_iterator(
                    IteratorT Begin,
                    IteratorT End,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0),
                m_Match(Begin,Begin),
                m_Next(Begin),
                m_End(End),
                m_bEof(false)
            {

                if(Begin!=End)
                {
                    increment();
                }
            }





            template<typename FinderT, typename RangeT>
            split_iterator(
                    RangeT& Col,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0),
                m_bEof(false)
            {
                iterator_range<typename range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
                m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
                m_Next=::boost::begin(lit_col);
                m_End=::boost::end(lit_col);


                if(m_Next!=m_End)
                {
                    increment();
                }
            }


        private:



            const match_type& dereference() const
            {
                return m_Match;
            }


            void increment()
            {
                match_type FindMatch=this->do_find( m_Next, m_End );

                if(FindMatch.begin()==m_End && FindMatch.end()==m_End)
                {
                    if(m_Match.end()==m_End)
                    {

                        m_bEof=true;
                    }
                }

                m_Match=match_type( m_Next, FindMatch.begin() );
                m_Next=FindMatch.end();
            }


            bool equal( const split_iterator& Other ) const
            {
                bool bEof=eof();
                bool bOtherEof=Other.eof();

                return bEof || bOtherEof ? bEof==bOtherEof :
                    (
                        m_Match==Other.m_Match &&
                        m_Next==Other.m_Next &&
                        m_End==Other.m_End
                    );
            }

        public:
# 348 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_iterator.hpp" 3 4
            bool eof() const
            {
                return this->is_null() || m_bEof;
            }

        private:

            match_type m_Match;
            input_iterator_type m_Next;
            input_iterator_type m_End;
            bool m_bEof;
        };





        template<typename RangeT, typename FinderT>
        inline split_iterator<
            typename range_iterator<RangeT>::type>
        make_split_iterator(
            RangeT& Collection,
            FinderT Finder)
        {
            return split_iterator<typename range_iterator<RangeT>::type>(
                Collection, Finder);
        }


    }


    using algorithm::find_iterator;
    using algorithm::make_find_iterator;
    using algorithm::split_iterator;
    using algorithm::make_split_iterator;

}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/util.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/util.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/util.hpp" 3 4
            template< typename CharT >
            struct empty_container
            {
                typedef empty_container<CharT> type;
                typedef CharT value_type;
                typedef std::size_t size_type;
                typedef std::ptrdiff_t difference_type;
                typedef const value_type& reference;
                typedef const value_type& const_reference;
                typedef const value_type* iterator;
                typedef const value_type* const_iterator;



                const_iterator begin() const
                {
                    return reinterpret_cast<const_iterator>(0);
                }

                const_iterator end() const
                {
                    return reinterpret_cast<const_iterator>(0);
                }

                bool empty() const
                {
                    return false;
                }

                size_type size() const
                {
                    return 0;
                }
            };




            template<typename InputIteratorT, typename OutputIteratorT>
            inline OutputIteratorT bounded_copy(
                InputIteratorT First,
                InputIteratorT Last,
                OutputIteratorT DestFirst,
                OutputIteratorT DestLast )
            {
                InputIteratorT InputIt=First;
                OutputIteratorT OutputIt=DestFirst;
                for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ )
                {
                    *OutputIt=*InputIt;
                }

                return OutputIt;
            }




            template<
                typename SeqT,
                typename IteratorT=typename SeqT::const_iterator >
            struct copy_iterator_rangeF
            {
                typedef iterator_range<IteratorT> argument_type;
                typedef SeqT result_type;
                SeqT operator()( const iterator_range<IteratorT>& Range ) const
                {
                    return copy_range<SeqT>(Range);
                }
            };

        }
    }
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 3 4
namespace boost {
    namespace algorithm {
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 3 4
        template<
            typename SequenceSequenceT,
            typename RangeT,
            typename FinderT >
        inline SequenceSequenceT&
        iter_find(
            SequenceSequenceT& Result,
            RangeT& Input,
            FinderT Finder )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_iterator<RangeT>::type> )>::failed> boost_concept_check77 __attribute__((__unused__))



                  ;

            iterator_range<typename range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            typedef typename
                range_iterator<RangeT>::type input_iterator_type;
            typedef find_iterator<input_iterator_type> find_iterator_type;
            typedef detail::copy_iterator_rangeF<
                typename
                    range_value<SequenceSequenceT>::type,
                input_iterator_type> copy_range_type;

            input_iterator_type InputEnd=::boost::end(lit_input);

            typedef transform_iterator<copy_range_type, find_iterator_type>
                transform_iter_type;

            transform_iter_type itBegin=
                ::boost::make_transform_iterator(
                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                    copy_range_type());

            transform_iter_type itEnd=
                ::boost::make_transform_iterator(
                    find_iterator_type(),
                    copy_range_type());

            SequenceSequenceT Tmp(itBegin, itEnd);

            Result.swap(Tmp);
            return Result;
        }
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/iter_find.hpp" 3 4
        template<
            typename SequenceSequenceT,
            typename RangeT,
            typename FinderT >
        inline SequenceSequenceT&
        iter_split(
            SequenceSequenceT& Result,
            RangeT& Input,
            FinderT Finder )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept<FinderT, typename range_iterator<RangeT>::type> )>::failed> boost_concept_check148 __attribute__((__unused__))


                  ;

            iterator_range<typename range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            typedef typename
                range_iterator<RangeT>::type input_iterator_type;
            typedef split_iterator<input_iterator_type> find_iterator_type;
            typedef detail::copy_iterator_rangeF<
                typename
                    range_value<SequenceSequenceT>::type,
                input_iterator_type> copy_range_type;

            input_iterator_type InputEnd=::boost::end(lit_input);

            typedef transform_iterator<copy_range_type, find_iterator_type>
                transform_iter_type;

            transform_iter_type itBegin=
                ::boost::make_transform_iterator(
                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                    copy_range_type() );

            transform_iter_type itEnd=
                ::boost::make_transform_iterator(
                    find_iterator_type(),
                    copy_range_type() );

            SequenceSequenceT Tmp(itBegin, itEnd);

            Result.swap(Tmp);
            return Result;
        }

    }


    using algorithm::iter_find;
    using algorithm::iter_split;

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/split.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/split.hpp" 3 4
namespace boost {
    namespace algorithm {
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/split.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& find_all(
            SequenceSequenceT& Result,
            Range1T& Input,
            const Range2T& Search)
        {
            return ::boost::algorithm::iter_find(
                Result,
                Input,
                ::boost::algorithm::first_finder(Search) );
        }
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/split.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& ifind_all(
            SequenceSequenceT& Result,
            Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::iter_find(
                Result,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );
        }
# 139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/split.hpp" 3 4
        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
        inline SequenceSequenceT& split(
            SequenceSequenceT& Result,
            RangeT& Input,
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off )
        {
            return ::boost::algorithm::iter_split(
                Result,
                Input,
                ::boost::algorithm::token_finder( Pred, eCompress ) );
        }

    }


    using algorithm::find_all;
    using algorithm::ifind_all;
    using algorithm::split;

}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/join.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/join.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/sequence.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/sequence.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/logical.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/sequence.hpp" 2 3 4





namespace boost {
    namespace algorithm {
        namespace detail {



            template< typename InputT, typename ForwardIteratorT >
            inline void insert(
                InputT& Input,
                typename InputT::iterator At,
                ForwardIteratorT Begin,
                ForwardIteratorT End )
            {
                Input.insert( At, Begin, End );
            }

            template< typename InputT, typename InsertT >
            inline void insert(
                InputT& Input,
                typename InputT::iterator At,
                const InsertT& Insert )
            {
                ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
            }







            template< typename InputT >
            inline typename InputT::iterator erase(
                InputT& Input,
                typename InputT::iterator From,
                typename InputT::iterator To )
            {
                return Input.erase( From, To );
            }





            template< bool HasConstTimeOperations >
            struct replace_const_time_helper
            {
                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {

                    ForwardIteratorT InsertIt=Begin;
                    typename InputT::iterator InputIt=From;
                    for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ )
                    {
                        *InputIt=*InsertIt;
                    }

                    if ( InsertIt!=End )
                    {

                        Input.insert( InputIt, InsertIt, End );
                    }
                    else
                    {
                        if ( InputIt!=To )
                        {

                            Input.erase( InputIt, To );
                        }
                    }
                }
            };

            template<>
            struct replace_const_time_helper< true >
            {

                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {
                    typename InputT::iterator At=Input.erase( From, To );
                    if ( Begin!=End )
                    {
                        if(!Input.empty())
                        {
                            Input.insert( At, Begin, End );
                        }
                        else
                        {
                            Input.insert( Input.begin(), Begin, End );
                        }
                    }
                }
            };


            template< bool HasNative >
            struct replace_native_helper
            {
                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {
                    replace_const_time_helper<
                        boost::mpl::and_<
                            has_const_time_insert<InputT>,
                            has_const_time_erase<InputT> >::value >()(
                        Input, From, To, Begin, End );
                }
            };


            template<>
            struct replace_native_helper< true >
            {
                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {
                    Input.replace( From, To, Begin, End );
                }
            };



            template< typename InputT, typename ForwardIteratorT >
            inline void replace(
                InputT& Input,
                typename InputT::iterator From,
                typename InputT::iterator To,
                ForwardIteratorT Begin,
                ForwardIteratorT End )
            {
                replace_native_helper< has_native_replace<InputT>::value >()(
                    Input, From, To, Begin, End );
            }

            template< typename InputT, typename InsertT >
            inline void replace(
                InputT& Input,
                typename InputT::iterator From,
                typename InputT::iterator To,
                const InsertT& Insert )
            {
                if(From!=To)
                {
                    ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
                }
                else
                {
                    ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
                }
            }

        }
    }
}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/join.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/join.hpp" 3 4
namespace boost {
    namespace algorithm {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/join.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T>
        inline typename range_value<SequenceSequenceT>::type
        join(
            const SequenceSequenceT& Input,
            const Range1T& Separator)
        {

            typedef typename range_value<SequenceSequenceT>::type ResultT;
            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;


            InputIteratorT itBegin=::boost::begin(Input);
            InputIteratorT itEnd=::boost::end(Input);


            ResultT Result;


            if(itBegin!=itEnd)
            {
                detail::insert(Result, ::boost::end(Result), *itBegin);
                ++itBegin;
            }

            for(;itBegin!=itEnd; ++itBegin)
            {

                detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));

                detail::insert(Result, ::boost::end(Result), *itBegin);
            }

            return Result;
        }
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/join.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T, typename PredicateT>
        inline typename range_value<SequenceSequenceT>::type
        join_if(
            const SequenceSequenceT& Input,
            const Range1T& Separator,
            PredicateT Pred)
        {

            typedef typename range_value<SequenceSequenceT>::type ResultT;
            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;


            InputIteratorT itBegin=::boost::begin(Input);
            InputIteratorT itEnd=::boost::end(Input);


            ResultT Result;


            while(itBegin!=itEnd && !Pred(*itBegin)) ++itBegin;

            if(itBegin!=itEnd)
            {
                detail::insert(Result, ::boost::end(Result), *itBegin);
                ++itBegin;
            }

            for(;itBegin!=itEnd; ++itBegin)
            {
                if(Pred(*itBegin))
                {

                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));

                    detail::insert(Result, ::boost::end(Result), *itBegin);
                }
            }

            return Result;
        }

    }


    using algorithm::join;
    using algorithm::join_if;

}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format_store.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format_store.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {







            template<
                typename ForwardIteratorT,
                typename FormatterT,
                typename FormatResultT >
            class find_format_store :
                public iterator_range<ForwardIteratorT>
            {
            public:

                typedef iterator_range<ForwardIteratorT> base_type;
                typedef FormatterT formatter_type;
                typedef FormatResultT format_result_type;

            public:

                find_format_store(
                        const base_type& FindResult,
                        const format_result_type& FormatResult,
                        const formatter_type& Formatter ) :
                    base_type(FindResult),
                    m_FormatResult(FormatResult),
                    m_Formatter(Formatter) {}


                template< typename FindResultT >
                find_format_store& operator=( FindResultT FindResult )
                {
                    iterator_range<ForwardIteratorT>::operator=(FindResult);
                    if( !this->empty() ) {
                        m_FormatResult=m_Formatter(FindResult);
                    }

                    return *this;
                }


                const format_result_type& format_result()
                {
                    return m_FormatResult;
                }

            private:
                format_result_type m_FormatResult;
                const formatter_type& m_Formatter;
            };

            template<typename InputT, typename FindResultT>
            bool check_find_result(InputT&, FindResultT& FindResult)
            {
                typedef typename
                    range_const_iterator<InputT>::type input_iterator_type;
                iterator_range<input_iterator_type> ResultRange(FindResult);
                return !ResultRange.empty();
            }




        }
    }
}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/replace_storage.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/replace_storage.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



            template< typename StorageT, typename OutputIteratorT >
            inline OutputIteratorT move_from_storage(
                StorageT& Storage,
                OutputIteratorT DestBegin,
                OutputIteratorT DestEnd )
            {
                OutputIteratorT OutputIt=DestBegin;

                while( !Storage.empty() && OutputIt!=DestEnd )
                {
                    *OutputIt=Storage.front();
                    Storage.pop_front();
                    ++OutputIt;
                }

                return OutputIt;
            }

            template< typename StorageT, typename WhatT >
            inline void copy_to_storage(
                StorageT& Storage,
                const WhatT& What )
            {
                Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
            }




            template< bool HasStableIterators >
            struct process_segment_helper
            {

                template<
                    typename StorageT,
                    typename InputT,
                    typename ForwardIteratorT >
                ForwardIteratorT operator()(
                    StorageT& Storage,
                    InputT& ,
                    ForwardIteratorT InsertIt,
                    ForwardIteratorT SegmentBegin,
                    ForwardIteratorT SegmentEnd )
                {

                    ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );






                    if( Storage.empty() )
                    {
                        if( It==SegmentBegin )
                        {

                            return SegmentEnd;
                        }
                        else
                        {

                            return std::copy( SegmentBegin, SegmentEnd, It );
                        }
                    }
                    else
                    {

                        while( It!=SegmentEnd )
                        {

                            Storage.push_back( *It );

                            *It=Storage.front();
                            Storage.pop_front();


                            ++It;
                        }

                        return It;
                    }
                }
            };

            template<>
            struct process_segment_helper< true >
            {

                template<
                    typename StorageT,
                    typename InputT,
                    typename ForwardIteratorT >
                ForwardIteratorT operator()(
                    StorageT& Storage,
                    InputT& Input,
                    ForwardIteratorT InsertIt,
                    ForwardIteratorT SegmentBegin,
                    ForwardIteratorT SegmentEnd )

                {

                    ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );

                    Storage.clear();

                    return SegmentEnd;
                }
            };


            template<
                typename StorageT,
                typename InputT,
                typename ForwardIteratorT >
            inline ForwardIteratorT process_segment(
                StorageT& Storage,
                InputT& Input,
                ForwardIteratorT InsertIt,
                ForwardIteratorT SegmentBegin,
                ForwardIteratorT SegmentEnd )
            {
                return
                    process_segment_helper<
                        has_stable_iterators<InputT>::value>()(
                                Storage, Input, InsertIt, SegmentBegin, SegmentEnd );
            }


        }
    }
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format.hpp" 2 3 4

namespace boost {
    namespace algorithm {
        namespace detail {



           template<
                typename OutputIteratorT,
                typename InputT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline OutputIteratorT find_format_copy_impl2(
                OutputIteratorT Output,
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult )
            {
                typedef find_format_store<
                    typename
                        range_const_iterator<InputT>::type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );

                if ( !M )
                {

                    Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                    return Output;
                }


                Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );


                Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );

                Output = std::copy( M.end(), ::boost::end(Input), Output );

                return Output;
            }

            template<
                typename OutputIteratorT,
                typename InputT,
                typename FormatterT,
                typename FindResultT >
            inline OutputIteratorT find_format_copy_impl(
                OutputIteratorT Output,
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult )
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_copy_impl2(
                        Output,
                        Input,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                }
            }




           template<
                typename InputT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline InputT find_format_copy_impl2(
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult)
            {
                typedef find_format_store<
                    typename
                        range_const_iterator<InputT>::type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );

                if ( !M )
                {

                    return InputT( Input );
                }

                InputT Output;

                boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );

                boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );

                boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );

                return Output;
            }

            template<
                typename InputT,
                typename FormatterT,
                typename FindResultT >
            inline InputT find_format_copy_impl(
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_copy_impl2(
                        Input,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return Input;
                }
            }



            template<
                typename InputT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline void find_format_impl2(
                InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult)
            {
                typedef find_format_store<
                    typename
                        range_iterator<InputT>::type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );

                if ( !M )
                {

                    return;
                }


                ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
            }

            template<
                typename InputT,
                typename FormatterT,
                typename FindResultT >
            inline void find_format_impl(
                InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    ::boost::algorithm::detail::find_format_impl2(
                        Input,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                }
            }

        }
    }
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format_all.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/find_format_all.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



           template<
                typename OutputIteratorT,
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline OutputIteratorT find_format_all_copy_impl2(
                OutputIteratorT Output,
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult )
            {
                typedef typename
                    range_const_iterator<InputT>::type input_iterator_type;

                typedef find_format_store<
                        input_iterator_type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );


                input_iterator_type LastMatch=::boost::begin(Input);


                while( M )
                {

                    Output = std::copy( LastMatch, M.begin(), Output );

                    Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );


                    LastMatch=M.end();
                    M=Finder( LastMatch, ::boost::end(Input) );
                }


                Output = std::copy( LastMatch, ::boost::end(Input), Output );

                return Output;
            }

            template<
                typename OutputIteratorT,
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT >
            inline OutputIteratorT find_format_all_copy_impl(
                OutputIteratorT Output,
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult )
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
                        Output,
                        Input,
                        Finder,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                }
            }



           template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline InputT find_format_all_copy_impl2(
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult)
            {
                typedef typename
                    range_const_iterator<InputT>::type input_iterator_type;

                typedef find_format_store<
                        input_iterator_type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );


                input_iterator_type LastMatch=::boost::begin(Input);


                InputT Output;


                while( M )
                {

                    boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() );

                    boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );


                    LastMatch=M.end();
                    M=Finder( LastMatch, ::boost::end(Input) );
                }


                ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );

                return Output;
            }

            template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT >
            inline InputT find_format_all_copy_impl(
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
                        Input,
                        Finder,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return Input;
                }
            }



            template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline void find_format_all_impl2(
                InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                FindResultT FindResult,
                FormatResultT FormatResult)
            {
                typedef typename
                    range_iterator<InputT>::type input_iterator_type;
                typedef find_format_store<
                        input_iterator_type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );


                std::deque<
                    typename range_value<InputT>::type> Storage;


                input_iterator_type InsertIt=::boost::begin(Input);
                input_iterator_type SearchIt=::boost::begin(Input);

                while( M )
                {

                    InsertIt=process_segment(
                        Storage,
                        Input,
                        InsertIt,
                        SearchIt,
                        M.begin() );


                    SearchIt=M.end();


                    ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );


                    M=Finder( SearchIt, ::boost::end(Input) );
                }


                InsertIt=::boost::algorithm::detail::process_segment(
                    Storage,
                    Input,
                    InsertIt,
                    SearchIt,
                    ::boost::end(Input) );

                if ( Storage.empty() )
                {

                    ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
                }
                else
                {

                    ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
                }
            }

            template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT >
            inline void find_format_all_impl(
                InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                FindResultT FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    ::boost::algorithm::detail::find_format_all_impl2(
                        Input,
                        Finder,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                }
            }

        }
    }
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 2 3 4







namespace boost {
    namespace algorithm {
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT,
            typename FinderT,
            typename FormatterT>
        inline OutputIteratorT find_format_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check65 __attribute__((__unused__))



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check70 __attribute__((__unused__))



                  ;

            iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            return detail::find_format_copy_impl(
                Output,
                lit_input,
                Formatter,
                Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
        }





        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT>
        inline SequenceT find_format_copy(
            const SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check99 __attribute__((__unused__))



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check104 __attribute__((__unused__))



                  ;

            return detail::find_format_copy_impl(
                Input,
                Formatter,
                Finder(::boost::begin(Input), ::boost::end(Input)));
        }
# 125 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT>
        inline void find_format(
            SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter)
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check135 __attribute__((__unused__))



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check140 __attribute__((__unused__))



                  ;

            detail::find_format_impl(
                Input,
                Formatter,
                Finder(::boost::begin(Input), ::boost::end(Input)));
        }
# 172 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT,
            typename FinderT,
            typename FormatterT>
        inline OutputIteratorT find_format_all_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            FinderT Finder,
            FormatterT Formatter)
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check184 __attribute__((__unused__))



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check189 __attribute__((__unused__))



                  ;

            iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            return detail::find_format_all_copy_impl(
                Output,
                lit_input,
                Finder,
                Formatter,
                Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
        }





        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT >
        inline SequenceT find_format_all_copy(
            const SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check219 __attribute__((__unused__))



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check224 __attribute__((__unused__))



                  ;

            return detail::find_format_all_copy_impl(
                Input,
                Finder,
                Formatter,
                Finder( ::boost::begin(Input), ::boost::end(Input) ) );
        }
# 247 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT >
        inline void find_format_all(
            SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check257 __attribute__((__unused__))



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check262 __attribute__((__unused__))



                  ;

            detail::find_format_all_impl(
                Input,
                Finder,
                Formatter,
                Finder(::boost::begin(Input), ::boost::end(Input)));

        }

    }


    using algorithm::find_format_copy;
    using algorithm::find_format;
    using algorithm::find_format_all_copy;
    using algorithm::find_format_all;

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/formatter.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/formatter.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {




            template<typename RangeT>
            struct const_formatF
            {
            private:
                typedef typename
                    range_const_iterator<RangeT>::type format_iterator;
                typedef iterator_range<format_iterator> result_type;

            public:

                const_formatF(const RangeT& Format) :
                    m_Format(::boost::begin(Format), ::boost::end(Format)) {}
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/detail/formatter.hpp" 3 4
                template<typename Range2T>
                const result_type& operator()(const Range2T&) const
                {
                    return m_Format;
                }

            private:
                result_type m_Format;
            };




            template<typename RangeT>
            struct identity_formatF
            {

                template< typename Range2T >
                const RangeT& operator()(const Range2T& Replace) const
                {
                    return RangeT(::boost::begin(Replace), ::boost::end(Replace));
                }
            };




            template< typename CharT >
            struct empty_formatF
            {
                template< typename ReplaceT >
                empty_container<CharT> operator()(const ReplaceT&) const
                {
                    return empty_container<CharT>();
                }
            };




            template<typename FinderT>
            struct dissect_formatF
            {
            public:

                dissect_formatF(FinderT Finder) :
                  m_Finder(Finder) {}


                  template<typename RangeT>
                  inline iterator_range<
                      typename range_const_iterator<RangeT>::type>
                  operator()(const RangeT& Replace) const
                  {
                      return m_Finder(::boost::begin(Replace), ::boost::end(Replace));
                  }

            private:
                FinderT m_Finder;
            };


        }
    }
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 3 4
namespace boost {
    namespace algorithm {
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename RangeT>
        inline detail::const_formatF<
            iterator_range<
                typename range_const_iterator<RangeT>::type> >
        const_formatter(const RangeT& Format)
        {
            return detail::const_formatF<
                iterator_range<
                    typename range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
        }
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename RangeT>
        inline detail::identity_formatF<
            iterator_range<
                typename range_const_iterator<RangeT>::type> >
        identity_formatter()
        {
            return detail::identity_formatF<
                iterator_range<
                    typename range_const_iterator<RangeT>::type> >();
        }
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename RangeT>
        inline detail::empty_formatF<
            typename range_value<RangeT>::type>
        empty_formatter(const RangeT&)
        {
            return detail::empty_formatF<
                typename range_value<RangeT>::type>();
        }
# 101 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename FinderT>
        inline detail::dissect_formatF< FinderT >
        dissect_formatter(const FinderT& Finder)
        {
            return detail::dissect_formatF<FinderT>(Finder);
        }


    }


    using algorithm::const_formatter;
    using algorithm::identity_formatter;
    using algorithm::empty_formatter;
    using algorithm::dissect_formatter;

}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 2 3 4







namespace boost {
    namespace algorithm {
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT replace_range_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const iterator_range<
                typename
                    range_const_iterator<Range1T>::type>& SearchRange,
            const Range2T& Format)
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::const_formatter(Format));
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT replace_range_copy(
            const SequenceT& Input,
            const iterator_range<
                typename
                    range_const_iterator<SequenceT>::type>& SearchRange,
            const RangeT& Format)
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::const_formatter(Format));
        }
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void replace_range(
            SequenceT& Input,
            const iterator_range<
                typename
                    range_iterator<SequenceT>::type>& SearchRange,
            const RangeT& Format)
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::const_formatter(Format));
        }
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format)
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_first_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_first(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range2T, typename Range1T>
        inline SequenceT ireplace_first_copy(
            const SequenceT& Input,
            const Range2T& Search,
            const Range1T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 252 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_first(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 283 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_last_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 326 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_last(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 358 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT ireplace_last_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 405 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_last(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 438 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth,
            const Range3T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_nth_copy(
            const SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::const_formatter(Format) );
        }
# 485 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_nth(
            SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::const_formatter(Format) );
        }
# 520 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT ireplace_nth_copy(
            const SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 571 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_nth(
            SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 603 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_all_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 646 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_all(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 678 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT ireplace_all_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 725 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_all(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 760 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT replace_head_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            int N,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT replace_head_copy(
            const SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }
# 806 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void replace_head(
            SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }
# 840 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT replace_tail_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            int N,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT replace_tail_copy(
            const SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }
# 886 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void replace_tail(
            SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }

    }


    using algorithm::replace_range_copy;
    using algorithm::replace_range;
    using algorithm::replace_first_copy;
    using algorithm::replace_first;
    using algorithm::ireplace_first_copy;
    using algorithm::ireplace_first;
    using algorithm::replace_last_copy;
    using algorithm::replace_last;
    using algorithm::ireplace_last_copy;
    using algorithm::ireplace_last;
    using algorithm::replace_nth_copy;
    using algorithm::replace_nth;
    using algorithm::ireplace_nth_copy;
    using algorithm::ireplace_nth;
    using algorithm::replace_all_copy;
    using algorithm::replace_all;
    using algorithm::ireplace_all_copy;
    using algorithm::ireplace_all;
    using algorithm::replace_head_copy;
    using algorithm::replace_head;
    using algorithm::replace_tail_copy;
    using algorithm::replace_tail;

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT>
        inline OutputIteratorT erase_range_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            const iterator_range<
                typename
                    range_const_iterator<RangeT>::type>& SearchRange )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT>
        inline SequenceT erase_range_copy(
            const SequenceT& Input,
            const iterator_range<
                typename
                    range_const_iterator<SequenceT>::type>& SearchRange )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT>
        inline void erase_range(
            SequenceT& Input,
            const iterator_range<
                typename
                    range_iterator<SequenceT>::type>& SearchRange )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_first_copy(
            const SequenceT& Input,
            const RangeT& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_first(
            SequenceT& Input,
            const RangeT& Search )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 186 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_first_copy(
            const SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 228 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_first(
            SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 256 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_last_copy(
            const SequenceT& Input,
            const RangeT& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 295 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_last(
            SequenceT& Input,
            const RangeT& Search )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 324 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_last_copy(
            const SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 366 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_last(
            SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 397 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_nth_copy(
            const SequenceT& Input,
            const RangeT& Search,
            int Nth )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 440 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_nth(
            SequenceT& Input,
            const RangeT& Search,
            int Nth )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 472 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_nth_copy(
            const SequenceT& Input,
            const RangeT& Search,
            int Nth,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                empty_formatter(Input) );
        }
# 518 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_nth(
            SequenceT& Input,
            const RangeT& Search,
            int Nth,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 549 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_all_copy(
            const SequenceT& Input,
            const RangeT& Search )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 588 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_all(
            SequenceT& Input,
            const RangeT& Search )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 617 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_all_copy(
            const SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 659 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_all(
            SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 691 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT>
        inline OutputIteratorT erase_head_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }





        template<typename SequenceT>
        inline SequenceT erase_head_copy(
            const SequenceT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }
# 732 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT>
        inline void erase_head(
            SequenceT& Input,
            int N )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }
# 763 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT>
        inline OutputIteratorT erase_tail_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }





        template<typename SequenceT>
        inline SequenceT erase_tail_copy(
            const SequenceT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }
# 804 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT>
        inline void erase_tail(
            SequenceT& Input,
            int N )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }

    }


    using algorithm::erase_range_copy;
    using algorithm::erase_range;
    using algorithm::erase_first_copy;
    using algorithm::erase_first;
    using algorithm::ierase_first_copy;
    using algorithm::ierase_first;
    using algorithm::erase_last_copy;
    using algorithm::erase_last;
    using algorithm::ierase_last_copy;
    using algorithm::ierase_last;
    using algorithm::erase_nth_copy;
    using algorithm::erase_nth;
    using algorithm::ierase_nth_copy;
    using algorithm::ierase_nth;
    using algorithm::erase_all_copy;
    using algorithm::erase_all;
    using algorithm::ierase_all_copy;
    using algorithm::ierase_all;
    using algorithm::erase_head_copy;
    using algorithm::erase_head;
    using algorithm::erase_tail_copy;
    using algorithm::erase_tail;

}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/algorithm/string.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.h" 1






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/explicit_operator_bool.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/explicit_operator_bool.hpp" 3 4
       
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/swap.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/swap.hpp" 3 4
namespace boost_swap_impl
{
  template<class T>
 
  void swap_impl(T& left, T& right)
  {
    using namespace std;
    swap(left,right);
  }

  template<class T, std::size_t N>
 
  void swap_impl(T (& left)[N], T (& right)[N])
  {
    for (std::size_t i = 0; i < N; ++i)
    {
      ::boost_swap_impl::swap_impl(left[i], right[i]);
    }
  }
}

namespace boost
{
  template<class T1, class T2>
 
  void swap(T1& left, T2& right)
  {
    ::boost_swap_impl::swap_impl(left, right);
  }
}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/bad_optional_access.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/bad_optional_access.hpp" 3 4
namespace boost {

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.")
    {}
};

}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type.hpp" 3 4
namespace boost {



  template <class T>
  struct type {};

}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_constructor.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_constructor.hpp" 3 4
namespace boost {

template <class T> struct has_nothrow_constructor : public integral_constant<bool, (__has_nothrow_constructor(T) && is_default_constructible<T>::value )>{};
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>{};

}
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/type_with_alignment.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/type_with_alignment.hpp" 3 4
}
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/decay.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/decay.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_bounds.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_bounds.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_extent.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_base_of.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_base_of.hpp" 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{};

}
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_nothrow_move_assignable.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_move_assign.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_move_assign.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_assignable.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_assignable.hpp" 3 4
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_move_assign.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_assign.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_assign.hpp" 3 4
namespace boost {
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_assign.hpp" 3 4
   template <class T>
   struct has_nothrow_assign : public integral_constant < bool,
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_assign.hpp" 3 4
      ((__has_nothrow_assign(T) ) && !is_volatile<T>::value && !is_const<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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3 4







namespace boost {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_c<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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};


}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_nothrow_move_constructible.hpp" 1 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_c<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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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{};


}
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility.hpp" 2 3 4
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility.hpp" 3 4
      namespace boost {
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 149 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/utility.hpp" 2 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/none.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/none.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/none_t.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/none_t.hpp" 3 4
namespace boost {
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/none_t.hpp" 3 4
struct none_t
{
  struct init_tag{};
  explicit none_t(init_tag){}
};



}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/none.hpp" 2 3 4





namespace boost {
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/none.hpp" 3 4
const none_t none ((none_t::init_tag()));



}
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/compare_pointees.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/compare_pointees.hpp" 3 4
namespace boost {
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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) ; }
} ;

}
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional_fwd.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_config.hpp" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_factory_support.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 ;
}
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_aligned_storage.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
    {
        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(); }

} ;

}
}
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4




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 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 ;

  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 ( argument_type val )
      :
      m_initialized(false)
    {
        construct(val);
    }




    optional_base ( 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);
    }
# 221 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
    }
# 363 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 { return m_initialized ; }

  protected :

    void construct ( argument_type val )
     {
       ::new (m_storage.address()) value_type(val) ;
       m_initialized = true ;
     }


    void construct ( rval_reference_type val )
     {
       ::new (m_storage.address()) value_type( boost::move(val) ) ;
       m_initialized = true ;
     }






    template<class... Args>
    void construct ( in_place_init_t, Args&&... args )
    {
      ::new (m_storage.address()) 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)...);
    }
# 579 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
     }
# 649 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
    template<class Expr>
    void construct ( Expr&& expr, void const* )
    {
      new (m_storage.address()) 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) );
    }
# 731 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 1 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 ( 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);
    }
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3 4
    void assign ( tc_optional_base const& rhs )
    {
      this->operator=(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);
    }
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)...);
    }
# 327 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
     }
# 397 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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) );
    }
# 479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 ;
} ;
# 763 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4


template <typename U>
struct is_optional_related
  : 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 is_convertible_to_T_or_factory
  : boost::conditional< boost::is_base_of<boost::in_place_factory_base, typename boost::decay<U>::type>::value
                     || boost::is_base_of<boost::typed_in_place_factory_base, typename boost::decay<U>::type>::value
                     || (boost::is_constructible<T, U&&>::value && !boost::is_same<T, typename boost::decay<U>::type>::value)
                      , boost::true_type, boost::false_type>::type
{};

template <typename T, typename U>
struct is_optional_constructible : boost::is_constructible<T, U>
{};
# 800 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
template <typename T, typename U>
struct is_optional_val_init_candidate
  : boost::conditional< !is_optional_related<U>::value && is_convertible_to_T_or_factory<T, U>::value
                      , boost::true_type, boost::false_type>::type
{};

}

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
{};

}
# 828 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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(val) {}




    optional ( rval_reference_type val ) : base( 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()) );
    }
# 928 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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))
    {}
# 944 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
    optional ( optional const& ) = default;
# 954 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
    optional ( optional && rhs ) = default;
# 975 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
    template<class Expr>
    typename boost::enable_if<optional_detail::is_optional_val_init_candidate<T, Expr>, optional&>::type
    operator= ( Expr&& expr )
      {
        this->assign_expr(boost::forward<Expr>(expr),boost::addressof(expr));
        return *this ;
      }
# 996 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
# 1031 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
    optional& operator= ( optional && ) = default;
# 1046 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 ;
      }
# 1078 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)... )
    {}
# 1179 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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<void> (0)) ; return this->get_impl(); }
    reference_type get() { (static_cast<void> (0)) ; 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<void> (0)) ; return this->get_ptr_impl() ; }
    pointer_type operator->() { (static_cast<void> (0)) ; 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());
      }
# 1260 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
      }
# 1308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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();
      }
# 1336 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 3 4
    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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_reference_spec.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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<void> (0)); return *ptr_; }

    T* get_ptr() const noexcept { return ptr_; }
    T* operator->() const { (static_cast<void> (0)); return ptr_; }
    T& operator*() const { (static_cast<void> (0)); return *ptr_; }
    T& value() const { return ptr_ ? *ptr_ : (throw_exception(bad_optional_access()), *ptr_); }

    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; }



    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()); }
# 241 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
}

}
# 1359 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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));
}
# 1402 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_relops.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_relops.hpp" 3 4
namespace boost {
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 ) ; }

}
# 1488 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/detail/optional_swap.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
}

}
# 1489 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/in_place_factory_prefix.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/in_place_factory_prefix.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/punctuation/paren.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 2 3 4

namespace boost {

class in_place_factory_base {} ;



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
class in_place_factory0
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory0
      ( )



  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

 
};
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
inline in_place_factory0 in_place()
{
  return in_place_factory0();
}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 >

class in_place_factory1
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory1
      ( A0 const& a0 )

    : m_a0 ( a0 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0;
};


template< class A0 >
inline in_place_factory1< A0 >
in_place( A0 const& a0 )
{
  return in_place_factory1< A0 >
      ( a0 );
}
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 >

class in_place_factory2
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory2
      ( A0 const& a0 , A1 const& a1 )

    : m_a0 ( a0 ) , m_a1 ( a1 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1;
};


template< class A0 , class A1 >
inline in_place_factory2< A0 , A1 >
in_place( A0 const& a0 , A1 const& a1 )
{
  return in_place_factory2< A0 , A1 >
      ( a0 , a1 );
}
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 >

class in_place_factory3
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory3
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2;
};


template< class A0 , class A1 , class A2 >
inline in_place_factory3< A0 , A1 , A2 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 )
{
  return in_place_factory3< A0 , A1 , A2 >
      ( a0 , a1 , a2 );
}
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 , class A3 >

class in_place_factory4
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory4
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3;
};


template< class A0 , class A1 , class A2 , class A3 >
inline in_place_factory4< A0 , A1 , A2 , A3 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 )
{
  return in_place_factory4< A0 , A1 , A2 , A3 >
      ( a0 , a1 , a2 , a3 );
}
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 , class A3 , class A4 >

class in_place_factory5
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory5
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4;
};


template< class A0 , class A1 , class A2 , class A3 , class A4 >
inline in_place_factory5< A0 , A1 , A2 , A3 , A4 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 )
{
  return in_place_factory5< A0 , A1 , A2 , A3 , A4 >
      ( a0 , a1 , a2 , a3 , a4 );
}
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >

class in_place_factory6
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory6
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5;
};


template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >
inline in_place_factory6< A0 , A1 , A2 , A3 , A4 , A5 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 )
{
  return in_place_factory6< A0 , A1 , A2 , A3 , A4 , A5 >
      ( a0 , a1 , a2 , a3 , a4 , a5 );
}
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >

class in_place_factory7
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory7
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6;
};


template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >
inline in_place_factory7< A0 , A1 , A2 , A3 , A4 , A5 , A6 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 )
{
  return in_place_factory7< A0 , A1 , A2 , A3 , A4 , A5 , A6 >
      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 );
}
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >

class in_place_factory8
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory8
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7;
};


template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >
inline in_place_factory8< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 )
{
  return in_place_factory8< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 >
      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 );
}
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >

class in_place_factory9
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory9
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 ) , m_a8 ( a8 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 , m_a8 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7; A8 const& m_a8;
};


template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >
inline in_place_factory9< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 )
{
  return in_place_factory9< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >
      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 );
}
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 3 4
template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >

class in_place_factory10
  :
  public in_place_factory_base
{
public:

  explicit in_place_factory10
      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 )

    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 ) , m_a8 ( a8 ) , m_a9 ( a9 )

  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 , m_a8 , m_a9 );
  }

  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7; A8 const& m_a8; A9 const& m_a9;
};


template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
inline in_place_factory10< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >
in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 )
{
  return in_place_factory10< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >
      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 );
}
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 2 3 4

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/detail/in_place_factory_suffix.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/in_place_factory.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/armor.h" 1





# 5 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/armor.h"
extern "C" {


int ceph_armor(char *dst, const char *dst_end,
        const char *src, const char *end);

int ceph_armor_linebreak(char *dst, const char *dst_end,
        const char *src, const char *end,
        int line_width);
int ceph_unarmor(char *dst, const char *dst_end,
   const char *src, const char *end);

}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/mime.h" 1
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/mime.h"
extern "C" {
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/mime.h"
signed int mime_encode_as_qp(const char *input, char *output, int outlen);
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/mime.h"
signed int mime_decode_from_qp(const char *input, char *output, int outlen);


}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/utf8.h" 1
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/utf8.h"
extern "C" {






int check_utf8(const char *buf, int len);





int check_utf8_cstr(const char *buf);




int is_control_character(int ch);



int check_for_control_characters(const char *buf, int len);



int check_for_control_characters_cstr(const char *buf);





int encode_utf8(unsigned long u, unsigned char *buf);





unsigned long decode_utf8(unsigned char *buf, int nbytes);


}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 1



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/int_types.h" 1



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/include/acconfig.h" 1 3 4
# 5 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/int_types.h" 2

# 1 "/usr/include/inttypes.h" 1 3 4
# 266 "/usr/include/inttypes.h" 3 4

# 266 "/usr/include/inttypes.h" 3 4
extern "C" {




typedef struct
  {
    long int quot;
    long int rem;
  } imaxdiv_t;
# 290 "/usr/include/inttypes.h" 3 4
extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__));


extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
      throw () __attribute__ ((__const__));


extern intmax_t strtoimax (const char *__restrict __nptr,
      char **__restrict __endptr, int __base) throw ();


extern uintmax_t strtoumax (const char *__restrict __nptr,
       char ** __restrict __endptr, int __base) throw ();


extern intmax_t wcstoimax (const wchar_t *__restrict __nptr,
      wchar_t **__restrict __endptr, int __base)
     throw ();


extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr,
       wchar_t ** __restrict __endptr, int __base)
     throw ();





extern long int __strtol_internal (const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()

{
  return __strtol_internal (nptr, endptr, base, 0);
}

extern unsigned long int __strtoul_internal (const char *__restrict __nptr,
          char ** __restrict __endptr,
          int __base, int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()

{
  return __strtoul_internal (nptr, endptr, base, 0);
}

extern long int __wcstol_internal (const wchar_t * __restrict __nptr,
       wchar_t **__restrict __endptr,
       int __base, int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) wcstoimax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()

{
  return __wcstol_internal (nptr, endptr, base, 0);
}

extern unsigned long int __wcstoul_internal (const wchar_t *
          __restrict __nptr,
          wchar_t **
          __restrict __endptr,
          int __base, int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) wcstoumax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()

{
  return __wcstoul_internal (nptr, endptr, base, 0);
}
# 432 "/usr/include/inttypes.h" 3 4
}
# 7 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/int_types.h" 2


# 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
# 24 "/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;
# 47 "/usr/include/linux/types.h" 3 4
typedef unsigned __poll_t;
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/int_types.h" 2
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/int_types.h"

# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/int_types.h"
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/byteorder.h" 1


       







template<typename T>
inline typename std::enable_if<sizeof(T) == sizeof(uint16_t), T>::type
swab(T val) {
  return __builtin_bswap16(val);
}
template<typename T>
inline typename std::enable_if<sizeof(T) == sizeof(uint32_t), T>::type
swab(T val) {
  return __builtin_bswap32(val);
}
template<typename T>
inline typename std::enable_if<sizeof(T) == sizeof(uint64_t), T>::type
swab(T val) {
  return __builtin_bswap64(val);
}
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/byteorder.h"
template<typename T>
inline T mswab(T val) {
  return val;
}


template<typename T>
struct ceph_le {
  T v;
  ceph_le<T>& operator=(T nv) {
    v = mswab(nv);
    return *this;
  }
  operator T() const { return mswab(v); }
} __attribute__ ((packed));

template<typename T>
inline bool operator==(ceph_le<T> a, ceph_le<T> b) {
  return a.v == b.v;
}

using ceph_le64 = ceph_le<__u64>;
using ceph_le32 = ceph_le<__u32>;
using ceph_le16 = ceph_le<__u16>;

inline ceph_le64 init_le64(__u64 x) {
  ceph_le64 v;
  v = x;
  return v;
}
inline ceph_le32 init_le32(__u32 x) {
  ceph_le32 v;
  v = x;
  return v;
}
inline ceph_le16 init_le16(__u16 x) {
  ceph_le16 v;
  v = x;
  return v;
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h" 1







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4

# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
namespace boost {
namespace container {



template <class T, class Allocator = new_allocator<T> >
class small_vector_base;
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
template<class Allocator>
class small_vector_allocator
   : public Allocator
{
   typedef unsigned int allocation_type;

   private:

  

   inline __attribute__ ((__always_inline__)) const Allocator &as_base() const
   { return static_cast<const Allocator&>(*this); }

   inline __attribute__ ((__always_inline__)) Allocator &as_base()
   { return static_cast<Allocator&>(*this); }



   public:

   typedef allocator_traits<Allocator> allocator_traits_type;


   typedef typename allocator_traits<Allocator>::value_type value_type;
   typedef typename allocator_traits<Allocator>::pointer pointer;
   typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
   typedef typename allocator_traits<Allocator>::reference reference;
   typedef typename allocator_traits<Allocator>::const_reference const_reference;
   typedef typename allocator_traits<Allocator>::size_type size_type;
   typedef typename allocator_traits<Allocator>::difference_type difference_type;
   typedef typename allocator_traits<Allocator>::void_pointer void_pointer;
   typedef typename allocator_traits<Allocator>::const_void_pointer const_void_pointer;

   typedef typename allocator_traits<Allocator>::propagate_on_container_copy_assignment propagate_on_container_copy_assignment;
   typedef typename allocator_traits<Allocator>::propagate_on_container_move_assignment propagate_on_container_move_assignment;
   typedef typename allocator_traits<Allocator>::propagate_on_container_swap propagate_on_container_swap;

   typedef dtl::bool_<false> is_always_equal;

   typedef dtl::bool_<true> is_partially_propagable;

   typedef dtl::version_type<small_vector_allocator , 1> version;



   template<class T2>
   struct rebind
   {
      typedef typename allocator_traits<Allocator>::template rebind_alloc<T2>::type other;
   };



      template<class ...Args>
      inline __attribute__ ((__always_inline__)) explicit small_vector_allocator(Args && ...args)
         : Allocator(::boost::forward<Args>(args)...)
      {}
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) small_vector_allocator
      (const small_vector_allocator &other) noexcept
      : Allocator(other.as_base())
   {}



   inline __attribute__ ((__always_inline__)) small_vector_allocator
      (small_vector_allocator && other) noexcept
      : Allocator(::boost::move(other.as_base()))
   {}



   template<class OtherAllocator>
   inline __attribute__ ((__always_inline__)) small_vector_allocator
      (const small_vector_allocator<OtherAllocator> &other) noexcept
      : Allocator(other.as_base())
   {}



   template<class OtherAllocator>
   inline __attribute__ ((__always_inline__)) small_vector_allocator
      (small_vector_allocator<OtherAllocator> && other) noexcept
      : Allocator(::boost::move(other.as_base()))
   {}



   inline __attribute__ ((__always_inline__)) small_vector_allocator &
      operator=(const small_vector_allocator & other) noexcept
   { return static_cast<small_vector_allocator&>(this->Allocator::operator=(other.as_base())); }



   inline __attribute__ ((__always_inline__)) small_vector_allocator &
      operator=(small_vector_allocator && other) noexcept
   { return static_cast<small_vector_allocator&>(this->Allocator::operator=(::boost::move(other.as_base()))); }



   template<class OtherAllocator>
   inline __attribute__ ((__always_inline__)) small_vector_allocator &
      operator=(const small_vector_allocator<OtherAllocator> & other) noexcept
   { return static_cast<small_vector_allocator&>(this->Allocator::operator=(other.as_base())); }



   template<class OtherAllocator>
   inline __attribute__ ((__always_inline__)) small_vector_allocator &
      operator=(small_vector_allocator<OtherAllocator> && other) noexcept
   { return static_cast<small_vector_allocator&>(this->Allocator::operator=(::boost::move(other.as_base()))); }


   inline __attribute__ ((__always_inline__)) pointer allocate(size_type count, const_void_pointer hint = const_void_pointer())
   { return allocator_traits_type::allocate(this->as_base(), count, hint); }



   void deallocate(pointer ptr, size_type n) noexcept
   {
      if(!this->is_internal_storage(ptr))
         allocator_traits_type::deallocate(this->as_base(), ptr, n);
   }



   inline __attribute__ ((__always_inline__)) size_type max_size() const noexcept
   { return allocator_traits_type::max_size(this->as_base()); }

   small_vector_allocator select_on_container_copy_construction() const
   { return small_vector_allocator(allocator_traits_type::select_on_container_copy_construction(this->as_base())); }

   bool storage_is_unpropagable(pointer p) const
   { return this->is_internal_storage(p) || allocator_traits_type::storage_is_unpropagable(this->as_base(), p); }



   inline __attribute__ ((__always_inline__)) friend void swap(small_vector_allocator &l, small_vector_allocator &r) noexcept
   { boost::adl_move_swap(l.as_base(), r.as_base()); }



   inline __attribute__ ((__always_inline__)) friend bool operator==(const small_vector_allocator &l, const small_vector_allocator &r) noexcept
   { return allocator_traits_type::equal(l.as_base(), r.as_base()); }



   inline __attribute__ ((__always_inline__)) friend bool operator!=(const small_vector_allocator &l, const small_vector_allocator &r) noexcept
   { return !(l == r); }
# 266 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
   private:
# 279 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) bool is_internal_storage(pointer p) const
   { return this->internal_storage() == p; }

   pointer internal_storage() const
   {
      typedef typename Allocator::value_type value_type;
      typedef typename allocator_traits_type::size_type size_type;
      typedef vector_alloc_holder< small_vector_allocator<Allocator>, size_type > vector_alloc_holder_t;
      typedef vector<value_type, small_vector_allocator<Allocator> > vector_base;
      typedef small_vector_base<value_type, Allocator> derived_type;

      const vector_alloc_holder_t &v_holder = static_cast<const vector_alloc_holder_t &>(*this);
      const vector_base &v_base = reinterpret_cast<const vector_base &>(v_holder);
      const derived_type &d_base = static_cast<const derived_type &>(v_base);
      return d_base.internal_storage();
   }

};
# 323 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
template <class T, class SecondaryAllocator>
class small_vector_base
   : public vector<T, small_vector_allocator<SecondaryAllocator> >
{

   public:


   typedef typename allocator_traits<SecondaryAllocator>::pointer pointer;

   private:
  

   friend class small_vector_allocator<SecondaryAllocator>;

   pointer internal_storage() const noexcept
   {
      return boost::intrusive::pointer_traits<pointer>::pointer_to
         (*const_cast<T*>(static_cast<const T*>(static_cast<const void*>(m_storage_start.data))));
   }

   typedef vector<T, small_vector_allocator<SecondaryAllocator> > base_type;
         base_type &as_base() { return static_cast<base_type&>(*this); }
   const base_type &as_base() const { return static_cast<const base_type&>(*this); }

   public:
   typedef typename dtl::aligned_storage
      <sizeof(T), dtl::alignment_of<T>::value>::type storage_type;
   typedef small_vector_allocator<SecondaryAllocator> allocator_type;

   protected:

   inline __attribute__ ((__always_inline__)) explicit small_vector_base(initial_capacity_t, std::size_t initial_capacity)
      : base_type(initial_capacity_t(), this->internal_storage(), initial_capacity)
   {}

   template<class AllocFwd>
   inline __attribute__ ((__always_inline__)) explicit small_vector_base(initial_capacity_t, std::size_t capacity, AllocFwd && a)
      : base_type(initial_capacity_t(), this->internal_storage(), capacity, ::boost::forward<AllocFwd>(a))
   {}



   private:

   storage_type m_storage_start;



   public:
   inline __attribute__ ((__always_inline__)) small_vector_base& operator=(const small_vector_base & other)
   { return static_cast<small_vector_base&>(this->base_type::operator=(static_cast<base_type const&>(other))); }

   inline __attribute__ ((__always_inline__)) small_vector_base& operator=(small_vector_base && other)
   { return static_cast<small_vector_base&>(this->base_type::operator=(::boost::move((base_type&)(other)))); }

   inline __attribute__ ((__always_inline__)) void swap(small_vector_base &other)
   { return this->base_type::swap(other); }


   protected:
   void move_construct_impl(base_type &x, const allocator_type &a)
   {
      if(base_type::is_propagable_from(x.get_stored_allocator(), x.data(), a, true)){
         this->steal_resources(x);
      }
      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 ()))
                     );
      }
   }

};
# 405 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
template<std::size_t Needed, std::size_t Hdr, std::size_t SSize, bool NeedsZero = (0u == Needed || Needed <= Hdr)>
struct small_vector_storage_calculator_helper
{
   static const std::size_t value = (Needed - Hdr - 1u)/SSize + 1u;
};

template<std::size_t Needed, std::size_t Hdr, std::size_t SSize>
struct small_vector_storage_calculator_helper<Needed, Hdr, SSize, true>
{
   static const std::size_t value = 0u;
};

template<class Storage, class Allocator, class T, std::size_t N>
struct small_vector_storage_calculator
{
   typedef small_vector_base<T, Allocator> svh_type;
   typedef vector<T, small_vector_allocator<Allocator> > svhb_type;
   static const std::size_t s_align = dtl::alignment_of<Storage>::value;
   static const std::size_t s_size = sizeof(Storage);
   static const std::size_t svh_sizeof = sizeof(svh_type);
   static const std::size_t svhb_sizeof = sizeof(svhb_type);
   static const std::size_t s_start = ((svhb_sizeof-1)/s_align+1)*s_align;
   static const std::size_t header_bytes = svh_sizeof-s_start;
   static const std::size_t needed_bytes = sizeof(T)*N;
   static const std::size_t needed_extra_storages =
      small_vector_storage_calculator_helper<needed_bytes, header_bytes, s_size>::value;
};






template<class Storage, std::size_t N>
struct small_vector_storage
{
   Storage m_rest_of_storage[N];
};

template<class Storage>
struct small_vector_storage<Storage, 0>
{};

template<class Allocator, std::size_t N>
struct small_vector_storage_definer
{
   typedef typename Allocator::value_type value_type;
   typedef typename small_vector_base<value_type, Allocator>::storage_type storage_type;
   static const std::size_t needed_extra_storages =
      small_vector_storage_calculator<storage_type, Allocator, value_type, N>::needed_extra_storages;
   typedef small_vector_storage<storage_type, needed_extra_storages> type;
};
# 472 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
template <class T, std::size_t N, class Allocator >
class small_vector : public small_vector_base<T, Allocator>

   , private small_vector_storage_definer<Allocator, N>::type

{

   typedef small_vector_base<T, Allocator> base_type;
   typedef typename small_vector_storage_definer<Allocator, N>::type remaining_storage_holder;

  

   typedef allocator_traits<typename base_type::allocator_type> allocator_traits_type;

   public:
   typedef small_vector_storage_calculator< typename small_vector_base<T, Allocator>
      ::storage_type, Allocator, T, N> storage_test;

   static const std::size_t needed_extra_storages = storage_test::needed_extra_storages;
   static const std::size_t needed_bytes = storage_test::needed_bytes;
   static const std::size_t header_bytes = storage_test::header_bytes;
   static const std::size_t s_start = storage_test::s_start;

   typedef typename base_type::allocator_type allocator_type;
   typedef typename base_type::size_type size_type;
   typedef typename base_type::value_type value_type;

   inline __attribute__ ((__always_inline__)) static std::size_t internal_capacity()
   { return (sizeof(small_vector) - storage_test::s_start)/sizeof(T); }




   static const size_type static_capacity = N;

   public:
   inline __attribute__ ((__always_inline__)) small_vector()
      noexcept((dtl::is_nothrow_default_constructible<Allocator>::value))
      : base_type(initial_capacity_t(), internal_capacity())
   {}

   inline __attribute__ ((__always_inline__)) explicit small_vector(const allocator_type &a)
      : base_type(initial_capacity_t(), internal_capacity(), a)
   {}

   inline __attribute__ ((__always_inline__)) explicit small_vector(size_type n)
      : base_type(initial_capacity_t(), internal_capacity())
   { this->resize(n); }

   inline __attribute__ ((__always_inline__)) small_vector(size_type n, const allocator_type &a)
      : base_type(initial_capacity_t(), internal_capacity(), a)
   { this->resize(n); }

   inline __attribute__ ((__always_inline__)) small_vector(size_type n, default_init_t)
      : base_type(initial_capacity_t(), internal_capacity())
   { this->resize(n, default_init_t()); }

   inline __attribute__ ((__always_inline__)) small_vector(size_type n, default_init_t, const allocator_type &a)
      : base_type(initial_capacity_t(), internal_capacity(), a)
   { this->resize(n, default_init_t()); }

   inline __attribute__ ((__always_inline__)) small_vector(size_type n, const value_type &v)
      : base_type(initial_capacity_t(), internal_capacity())
   { this->resize(n, v); }

   inline __attribute__ ((__always_inline__)) small_vector(size_type n, const value_type &v, const allocator_type &a)
      : base_type(initial_capacity_t(), internal_capacity(), a)
   { this->resize(n, v); }

   template <class InIt>
   inline __attribute__ ((__always_inline__)) small_vector(InIt first, InIt last
      , typename dtl::disable_if_c < dtl::is_convertible<InIt , size_type>::value , dtl::nat >::type * = 0


      )
      : base_type(initial_capacity_t(), internal_capacity())
   { this->assign(first, last); }

   template <class InIt>
   inline __attribute__ ((__always_inline__)) small_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


      )
      : base_type(initial_capacity_t(), internal_capacity(), a)
   { this->assign(first, last); }

   inline __attribute__ ((__always_inline__)) small_vector(const small_vector &other)
      : base_type( initial_capacity_t(), internal_capacity()
                 , allocator_traits_type::select_on_container_copy_construction(other.get_stored_allocator()))
   { this->assign(other.cbegin(), other.cend()); }

   inline __attribute__ ((__always_inline__)) small_vector(const small_vector &other, const allocator_type &a)
      : base_type(initial_capacity_t(), internal_capacity(), a)
   { this->assign(other.cbegin(), other.cend()); }

   inline __attribute__ ((__always_inline__)) explicit small_vector(const base_type &other)
      : base_type( initial_capacity_t(), internal_capacity()
                 , allocator_traits_type::select_on_container_copy_construction(other.get_stored_allocator()))
   { this->assign(other.cbegin(), other.cend()); }

   inline __attribute__ ((__always_inline__)) explicit small_vector(base_type && other)
      : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()))
   { this->move_construct_impl(other, other.get_stored_allocator()); }

   inline __attribute__ ((__always_inline__)) small_vector(small_vector && other)
      : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()))
   { this->move_construct_impl(other, other.get_stored_allocator()); }

   inline __attribute__ ((__always_inline__)) small_vector(small_vector && other, const allocator_type &a)
      : base_type(initial_capacity_t(), internal_capacity(), a)
   { this->move_construct_impl(other, a); }


   inline __attribute__ ((__always_inline__)) small_vector(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
      : base_type(initial_capacity_t(), internal_capacity(), a)
   {
      this->assign(il.begin(), il.end());
   }


   inline __attribute__ ((__always_inline__)) small_vector& operator=(const small_vector & other)
   { return static_cast<small_vector&>(this->base_type::operator=(static_cast<base_type const&>(other))); }

   inline __attribute__ ((__always_inline__)) small_vector& operator=(small_vector && other)
   { return static_cast<small_vector&>(this->base_type::operator=(::boost::move((base_type&)(other)))); }

   inline __attribute__ ((__always_inline__)) small_vector& operator=(const base_type &other)
   { return static_cast<small_vector&>(this->base_type::operator=(other)); }

   inline __attribute__ ((__always_inline__)) small_vector& operator=(base_type && other)
   { return static_cast<small_vector&>(this->base_type::operator=(boost::move(other))); }

   inline __attribute__ ((__always_inline__)) void swap(small_vector &other)
   { return this->base_type::swap(other); }
};

}}
# 629 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 630 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/small_vector.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional_io.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/optional/optional_io.hpp" 3 4
namespace boost
{

template<class CharType, class CharTrait>
inline
std::basic_ostream<CharType, CharTrait>&
operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t)
{
  if (out.good())
  {
    out << "--";
  }

  return out;
}

template<class CharType, class CharTrait, class T>
inline
std::basic_ostream<CharType, CharTrait>&
operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v)
{
  if (out.good())
  {
    if (!v)
         out << "--" ;
    else out << ' ' << *v ;
  }

  return out;
}

template<class CharType, class CharTrait, class T>
inline
std::basic_istream<CharType, CharTrait>&
operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v)
{
  if (in.good())
  {
    int d = in.get();
    if (d == ' ')
    {
      T x;
      in >> x;

      v = boost::move(x);



    }
    else
    {
      if (d == '-')
      {
        d = in.get();

        if (d == '-')
        {
          v = none;
          return in;
        }
      }

      in.setstate( std::ios::failbit );
    }
  }

  return in;
}

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/tuple.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/tuple.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/cv_traits.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/cv_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_cv.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_cv.hpp" 3 4
namespace boost {
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/add_cv.hpp" 3 4
template <class T> struct add_cv{ typedef T const volatile type; };





template <class T> struct add_cv<T&>{ typedef T& type; };



   template <class T> using add_cv_t = typename add_cv<T>::type;



}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/cv_traits.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/remove_volatile.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;



}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/cv_traits.hpp" 2 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/swap.hpp" 1 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 2 3 4




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"


namespace boost {
namespace tuples {


struct null_type {};


namespace detail {
  inline const null_type cnull() { return null_type(); }





template <bool If, class Then, class Else> struct IF { typedef Then RET; };

template <class Then, class Else> struct IF<false, Then, Else> {
  typedef Else RET;
};

}


template <class HT, class TT> struct cons;



template <
  class T0 = null_type, class T1 = null_type, class T2 = null_type,
  class T3 = null_type, class T4 = null_type, class T5 = null_type,
  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type>
class tuple;


template<class T> struct length;



namespace detail {



template<class T>
class generate_error;

template<int N>
struct drop_front {
    template<class Tuple>
    struct apply {
        typedef typename drop_front<N-1>::template
            apply<Tuple> next;
        typedef typename next::type::tail_type type;
        static const type& call(const Tuple& tup) {
            return next::call(tup).tail;
        }
    };
};

template<>
struct drop_front<0> {
    template<class Tuple>
    struct apply {
        typedef Tuple type;
        static const type& call(const Tuple& tup) {
            return tup;
        }
    };
};

}
# 129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template<int N, class T>
struct element
{
  typedef typename detail::drop_front<N>::template
      apply<T>::type::head_type type;
};

template<int N, class T>
struct element<N, const T>
{
private:
  typedef typename detail::drop_front<N>::template
      apply<T>::type::head_type unqualified_type;
public:



  typedef typename boost::add_const<unqualified_type>::type type;

};
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template <class T> struct access_traits {
  typedef const T& const_type;
  typedef T& non_const_type;

  typedef const typename boost::remove_cv<T>::type& parameter_type;






};

template <class T> struct access_traits<T&> {

  typedef T& const_type;
  typedef T& non_const_type;

  typedef T& parameter_type;
};



template<int N, class HT, class TT>
inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::non_const_type
get(cons<HT, TT>& c) {
  typedef typename detail::drop_front<N>::template
      apply<cons<HT, TT> > impl;
  typedef typename impl::type cons_element;
  return const_cast<cons_element&>(impl::call(c)).head;
}




template<int N, class HT, class TT>
inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::const_type
get(const cons<HT, TT>& c) {
  typedef typename detail::drop_front<N>::template
      apply<cons<HT, TT> > impl;
  return impl::call(c).head;
}


namespace detail {







template <class T> class non_storeable_type {
  non_storeable_type();
};

template <class T> struct wrap_non_storeable_type {
  typedef typename IF<
    ::boost::is_function<T>::value, non_storeable_type<T>, T
  >::RET type;
};
template <> struct wrap_non_storeable_type<void> {
  typedef non_storeable_type<void> type;
};

}

template <class HT, class TT>
struct cons {

  typedef HT head_type;
  typedef TT tail_type;

  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;

  stored_head_type head;
  tail_type tail;

  typename access_traits<stored_head_type>::non_const_type
  get_head() { return head; }

  typename access_traits<tail_type>::non_const_type
  get_tail() { return tail; }

  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }

  typename access_traits<tail_type>::const_type
  get_tail() const { return tail; }

  cons() : head(), tail() {}







  cons(typename access_traits<stored_head_type>::parameter_type h,
       const tail_type& t)
    : head (h), tail(t) {}

  template <class T1, class T2, class T3, class T4, class T5,
            class T6, class T7, class T8, class T9, class T10>
  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
    : head (t1),
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
      {}

  template <class T2, class T3, class T4, class T5,
            class T6, class T7, class T8, class T9, class T10>
  cons( const null_type& , T2& t2, T3& t3, T4& t4, T5& t5,
        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
    : head (),
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
      {}


  template <class HT2, class TT2>
  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

  template <class HT2, class TT2>
  cons& operator=( const cons<HT2, TT2>& u ) {
    head=u.head; tail=u.tail; return *this;
  }



  cons& operator=(const cons& u) {
    head = u.head; tail = u.tail; return *this;
  }

  template <class T1, class T2>
  cons& operator=( const std::pair<T1, T2>& u ) {
    static_assert(length<cons>::value == 2, "length<cons>::value == 2");
    head = u.first; tail.head = u.second; return *this;
  }


  template <int N>
  typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::non_const_type
  get() {
    return boost::tuples::get<N>(*this);
  }

  template <int N>
  typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::const_type
  get() const {
    return boost::tuples::get<N>(*this);
  }
};

template <class HT>
struct cons<HT, null_type> {

  typedef HT head_type;
  typedef null_type tail_type;
  typedef cons<HT, null_type> self_type;

  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
  stored_head_type head;

  typename access_traits<stored_head_type>::non_const_type
  get_head() { return head; }

  null_type get_tail() { return null_type(); }

  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }

  const null_type get_tail() const { return null_type(); }


  cons() : head() {}

  cons(typename access_traits<stored_head_type>::parameter_type h,
       const null_type& = null_type())
    : head (h) {}

  template<class T1>
  cons(T1& t1, const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head (t1) {}

  cons(const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head () {}

  template <class HT2>
  cons( const cons<HT2, null_type>& u ) : head(u.head) {}

  template <class HT2>
  cons& operator=(const cons<HT2, null_type>& u )
  { head = u.head; return *this; }



  cons& operator=(const cons& u) { head = u.head; return *this; }

  template <int N>
  typename access_traits<
             typename element<N, self_type>::type
            >::non_const_type
  get() {
    return boost::tuples::get<N>(*this);
  }

  template <int N>
  typename access_traits<
             typename element<N, self_type>::type
           >::const_type
  get() const {
    return boost::tuples::get<N>(*this);
  }

};



template<class T>
struct length {
  static const int value = 1 + length<typename T::tail_type>::value;
};

template<>
struct length<tuple<> > {
  static const int value = 0;
};

template<>
struct length<tuple<> const> {
  static const int value = 0;
};

template<>
struct length<null_type> {
  static const int value = 0;
};

template<>
struct length<null_type const> {
  static const int value = 0;
};

namespace detail {


template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
struct map_tuple_to_cons
{
  typedef cons<T0,
               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
                                          T6, T7, T8, T9, null_type>::type
              > type;
};


template <>
struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
{
  typedef null_type type;
};

}



template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>

class tuple :
  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
{
public:
  typedef typename
    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
  typedef typename inherited::head_type head_type;
  typedef typename inherited::tail_type tail_type;



  tuple() {}

  explicit tuple(typename access_traits<T0>::parameter_type t0)
    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1)
    : inherited(t0, t1, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2)
    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3)
    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4)
    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5)
    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6)
    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7,
        typename access_traits<T8>::parameter_type t8)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7,
        typename access_traits<T8>::parameter_type t8,
        typename access_traits<T9>::parameter_type t9)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}


  template<class U1, class U2>
  tuple(const cons<U1, U2>& p) : inherited(p) {}

  template <class U1, class U2>
  tuple& operator=(const cons<U1, U2>& k) {
    inherited::operator=(k);
    return *this;
  }

  template <class U1, class U2>
  tuple& operator=(const std::pair<U1, U2>& k) {
    static_assert(length<tuple>::value == 2, "length<tuple>::value == 2");
    this->head = k.first;
    this->tail.head = k.second;
    return *this;
  }

};


template <>
class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
  public null_type
{
public:
  typedef null_type inherited;
};



namespace detail {

struct swallow_assign;
typedef void (detail::swallow_assign::*ignore_t)();
struct swallow_assign {
  swallow_assign(ignore_t(*)(ignore_t)) {}
  template<typename T>
  swallow_assign const& operator=(const T&) const {
    return *this;
  }
};


}


inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
# 640 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template<class T>
struct make_tuple_traits {
  typedef T type;







};
# 664 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template<class T>
struct make_tuple_traits<T&> {
  typedef typename
     detail::generate_error<T&>::
       do_not_use_with_reference_type error;
};





template<class T, int n> struct make_tuple_traits <T[n]> {
  typedef const T (&type)[n];
};

template<class T, int n>
struct make_tuple_traits<const T[n]> {
  typedef const T (&type)[n];
};

template<class T, int n> struct make_tuple_traits<volatile T[n]> {
  typedef const volatile T (&type)[n];
};

template<class T, int n>
struct make_tuple_traits<const volatile T[n]> {
  typedef const volatile T (&type)[n];
};

template<class T>
struct make_tuple_traits<reference_wrapper<T> >{
  typedef T& type;
};

template<class T>
struct make_tuple_traits<const reference_wrapper<T> >{
  typedef T& type;
};

template<>
struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
  typedef detail::swallow_assign type;
};



namespace detail {



template <
  class T0 = null_type, class T1 = null_type, class T2 = null_type,
  class T3 = null_type, class T4 = null_type, class T5 = null_type,
  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type
>
struct make_tuple_mapper {
  typedef
    tuple<typename make_tuple_traits<T0>::type,
          typename make_tuple_traits<T1>::type,
          typename make_tuple_traits<T2>::type,
          typename make_tuple_traits<T3>::type,
          typename make_tuple_traits<T4>::type,
          typename make_tuple_traits<T5>::type,
          typename make_tuple_traits<T6>::type,
          typename make_tuple_traits<T7>::type,
          typename make_tuple_traits<T8>::type,
          typename make_tuple_traits<T9>::type> type;
};

}


inline tuple<> make_tuple() {
  return tuple<>();
}

template<class T0>
inline typename detail::make_tuple_mapper<T0>::type
make_tuple(const T0& t0) {
  typedef typename detail::make_tuple_mapper<T0>::type t;
  return t(t0);
}

template<class T0, class T1>
inline typename detail::make_tuple_mapper<T0, T1>::type
make_tuple(const T0& t0, const T1& t1) {
  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
  return t(t0, t1);
}

template<class T0, class T1, class T2>
inline typename detail::make_tuple_mapper<T0, T1, T2>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
  return t(t0, t1, t2);
}

template<class T0, class T1, class T2, class T3>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
  return t(t0, t1, t2, t3);
}

template<class T0, class T1, class T2, class T3, class T4>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
  return t(t0, t1, t2, t3, t4);
}

template<class T0, class T1, class T2, class T3, class T4, class T5>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
  return t(t0, t1, t2, t3, t4, t5);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8>
inline typename detail::make_tuple_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                  const T8& t8) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8, class T9>
inline typename detail::make_tuple_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                  const T8& t8, const T9& t9) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
}

namespace detail {

template<class T>
struct tie_traits {
  typedef T& type;
};

template<>
struct tie_traits<ignore_t(ignore_t)> {
  typedef swallow_assign type;
};

template<>
struct tie_traits<void> {
  typedef null_type type;
};

template <
  class T0 = void, class T1 = void, class T2 = void,
  class T3 = void, class T4 = void, class T5 = void,
  class T6 = void, class T7 = void, class T8 = void,
  class T9 = void
>
struct tie_mapper {
  typedef
    tuple<typename tie_traits<T0>::type,
          typename tie_traits<T1>::type,
          typename tie_traits<T2>::type,
          typename tie_traits<T3>::type,
          typename tie_traits<T4>::type,
          typename tie_traits<T5>::type,
          typename tie_traits<T6>::type,
          typename tie_traits<T7>::type,
          typename tie_traits<T8>::type,
          typename tie_traits<T9>::type> type;
};

}


template<class T0>
inline typename detail::tie_mapper<T0>::type
tie(T0& t0) {
  typedef typename detail::tie_mapper<T0>::type t;
  return t(t0);
}

template<class T0, class T1>
inline typename detail::tie_mapper<T0, T1>::type
tie(T0& t0, T1& t1) {
  typedef typename detail::tie_mapper<T0, T1>::type t;
  return t(t0, t1);
}

template<class T0, class T1, class T2>
inline typename detail::tie_mapper<T0, T1, T2>::type
tie(T0& t0, T1& t1, T2& t2) {
  typedef typename detail::tie_mapper<T0, T1, T2>::type t;
  return t(t0, t1, t2);
}

template<class T0, class T1, class T2, class T3>
inline typename detail::tie_mapper<T0, T1, T2, T3>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3) {
  typedef typename detail::tie_mapper<T0, T1, T2, T3>::type t;
  return t(t0, t1, t2, t3);
}

template<class T0, class T1, class T2, class T3, class T4>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4) {
  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4>::type t;
  return t(t0, t1, t2, t3, t4);
}

template<class T0, class T1, class T2, class T3, class T4, class T5>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5) {
  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type t;
  return t(t0, t1, t2, t3, t4, t5);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6, T7& t7) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8>
inline typename detail::tie_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6, T7& t7,
                  T8& t8) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8, class T9>
inline typename detail::tie_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6, T7& t7,
                  T8& t8, T9& t9) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
}

template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
inline void swap(null_type&, null_type&) {}
template<class HH>
inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
  ::boost::swap(lhs.head, rhs.head);
}
template<class HH, class TT>
inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
  ::boost::swap(lhs.head, rhs.head);
  ::boost::tuples::swap(lhs.tail, rhs.tail);
}
template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
  typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
  typedef typename tuple_type::inherited base;
  ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
}

}
}



#pragma GCC diagnostic pop
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/tuple.hpp" 2 3 4


namespace boost {

using tuples::tuple;
using tuples::make_tuple;
using tuples::tie;

using tuples::get;
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tuple/tuple.hpp" 3 4
}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/unordered_map.h" 1






# 6 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/unordered_map.h"
namespace ceph {
  using std::unordered_map;
  using std::unordered_multimap;
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/unordered_set.h" 1



# 1 "/usr/include/c++/10/unordered_set" 1 3
# 32 "/usr/include/c++/10/unordered_set" 3
       
# 33 "/usr/include/c++/10/unordered_set" 3
# 47 "/usr/include/c++/10/unordered_set" 3
# 1 "/usr/include/c++/10/bits/unordered_set.h" 1 3
# 33 "/usr/include/c++/10/bits/unordered_set.h" 3

# 33 "/usr/include/c++/10/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;
# 93 "/usr/include/c++/10/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;
# 144 "/usr/include/c++/10/bits/unordered_set.h" 3
      explicit
      unordered_set(size_type __n,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
      : _M_h(__n, __hf, __eql, __a)
      { }
# 165 "/usr/include/c++/10/bits/unordered_set.h" 3
      template<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)
      : _M_h(std::move(__uset._M_h), __a)
      { }
# 220 "/usr/include/c++/10/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;
# 282 "/usr/include/c++/10/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(); }
# 318 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      begin() noexcept
      { return _M_h.begin(); }

      const_iterator
      begin() const noexcept
      { return _M_h.begin(); }







      iterator
      end() noexcept
      { return _M_h.end(); }

      const_iterator
      end() const noexcept
      { return _M_h.end(); }






      const_iterator
      cbegin() const noexcept
      { return _M_h.begin(); }





      const_iterator
      cend() const noexcept
      { return _M_h.end(); }
# 374 "/usr/include/c++/10/bits/unordered_set.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 400 "/usr/include/c++/10/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)...); }
# 419 "/usr/include/c++/10/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)); }
# 448 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __x); }

      iterator
      insert(const_iterator __hint, value_type&& __x)
      { return _M_h.insert(__hint, std::move(__x)); }
# 466 "/usr/include/c++/10/bits/unordered_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 478 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/unordered_set.h", 487, __PRETTY_FUNCTION__, "__pos != end()"); } 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; }
# 521 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 543 "/usr/include/c++/10/bits/unordered_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 561 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_h.erase(__first, __last); }







      void
      clear() noexcept
      { _M_h.clear(); }
# 584 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      swap(unordered_set& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }


      template<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(); }
# 648 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }
# 666 "/usr/include/c++/10/bits/unordered_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }
# 690 "/usr/include/c++/10/bits/unordered_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }





      size_type
      bucket_count() const noexcept
      { return _M_h.bucket_count(); }


      size_type
      max_bucket_count() const noexcept
      { return _M_h.max_bucket_count(); }






      size_type
      bucket_size(size_type __n) const
      { return _M_h.bucket_size(__n); }






      size_type
      bucket(const key_type& __key) const
      { return _M_h.bucket(__key); }
# 736 "/usr/include/c++/10/bits/unordered_set.h" 3
      local_iterator
      begin(size_type __n)
      { return _M_h.begin(__n); }

      const_local_iterator
      begin(size_type __n) const
      { return _M_h.begin(__n); }

      const_local_iterator
      cbegin(size_type __n) const
      { return _M_h.cbegin(__n); }
# 756 "/usr/include/c++/10/bits/unordered_set.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }

      const_local_iterator
      end(size_type __n) const
      { return _M_h.end(__n); }

      const_local_iterator
      cend(size_type __n) const
      { return _M_h.cend(__n); }





      float
      load_factor() const noexcept
      { return _M_h.load_factor(); }



      float
      max_load_factor() const noexcept
      { return _M_h.max_load_factor(); }





      void
      max_load_factor(float __z)
      { _M_h.max_load_factor(__z); }
# 797 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 808 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      reserve(size_type __n)
      { _M_h.reserve(__n); }

      template<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>;
# 908 "/usr/include/c++/10/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;
# 958 "/usr/include/c++/10/bits/unordered_set.h" 3
      explicit
      unordered_multiset(size_type __n,
    const hasher& __hf = hasher(),
    const key_equal& __eql = key_equal(),
    const allocator_type& __a = allocator_type())
      : _M_h(__n, __hf, __eql, __a)
      { }
# 979 "/usr/include/c++/10/bits/unordered_set.h" 3
      template<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;
# 1005 "/usr/include/c++/10/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)
      : _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)
      { }
# 1096 "/usr/include/c++/10/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(); }
# 1132 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      begin() noexcept
      { return _M_h.begin(); }

      const_iterator
      begin() const noexcept
      { return _M_h.begin(); }







      iterator
      end() noexcept
      { return _M_h.end(); }

      const_iterator
      end() const noexcept
      { return _M_h.end(); }






      const_iterator
      cbegin() const noexcept
      { return _M_h.begin(); }





      const_iterator
      cend() const noexcept
      { return _M_h.end(); }
# 1180 "/usr/include/c++/10/bits/unordered_set.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 1202 "/usr/include/c++/10/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)...); }
# 1215 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_h.insert(__x); }

      iterator
      insert(value_type&& __x)
      { return _M_h.insert(std::move(__x)); }
# 1241 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __x); }

      iterator
      insert(const_iterator __hint, value_type&& __x)
      { return _M_h.insert(__hint, std::move(__x)); }
# 1258 "/usr/include/c++/10/bits/unordered_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 1270 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (! (__pos != end())) std::__replacement_assert("/usr/include/c++/10/bits/unordered_set.h", 1279, __PRETTY_FUNCTION__, "__pos != end()"); } 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)); }
# 1314 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 1337 "/usr/include/c++/10/bits/unordered_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 1357 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_h.erase(__first, __last); }
# 1368 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      clear() noexcept
      { _M_h.clear(); }
# 1381 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      swap(unordered_multiset& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }


      template<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(); }
# 1447 "/usr/include/c++/10/bits/unordered_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }







      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }
# 1483 "/usr/include/c++/10/bits/unordered_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }





      size_type
      bucket_count() const noexcept
      { return _M_h.bucket_count(); }


      size_type
      max_bucket_count() const noexcept
      { return _M_h.max_bucket_count(); }






      size_type
      bucket_size(size_type __n) const
      { return _M_h.bucket_size(__n); }






      size_type
      bucket(const key_type& __key) const
      { return _M_h.bucket(__key); }
# 1529 "/usr/include/c++/10/bits/unordered_set.h" 3
      local_iterator
      begin(size_type __n)
      { return _M_h.begin(__n); }

      const_local_iterator
      begin(size_type __n) const
      { return _M_h.begin(__n); }

      const_local_iterator
      cbegin(size_type __n) const
      { return _M_h.cbegin(__n); }
# 1549 "/usr/include/c++/10/bits/unordered_set.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }

      const_local_iterator
      end(size_type __n) const
      { return _M_h.end(__n); }

      const_local_iterator
      cend(size_type __n) const
      { return _M_h.cend(__n); }





      float
      load_factor() const noexcept
      { return _M_h.load_factor(); }



      float
      max_load_factor() const noexcept
      { return _M_h.max_load_factor(); }





      void
      max_load_factor(float __z)
      { _M_h.max_load_factor(__z); }
# 1590 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1601 "/usr/include/c++/10/bits/unordered_set.h" 3
      void
      reserve(size_type __n)
      { _M_h.reserve(__n); }

      template<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); }

  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 == __y); }

  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); }

  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 == __y); }





  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; }
    };
# 1791 "/usr/include/c++/10/bits/unordered_set.h" 3

}
# 48 "/usr/include/c++/10/unordered_set" 2 3
# 56 "/usr/include/c++/10/unordered_set" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Tp> class polymorphic_allocator;
    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>>;
  }

}
# 5 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/unordered_set.h" 2


# 6 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/unordered_set.h"
namespace ceph {
  using std::unordered_set;
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
# 1 "/usr/include/c++/10/chrono" 1 3
# 33 "/usr/include/c++/10/chrono" 3
       
# 34 "/usr/include/c++/10/chrono" 3





# 1 "/usr/include/c++/10/ratio" 1 3
# 33 "/usr/include/c++/10/ratio" 3
       
# 34 "/usr/include/c++/10/ratio" 3
# 42 "/usr/include/c++/10/ratio" 3

# 42 "/usr/include/c++/10/ratio" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 56 "/usr/include/c++/10/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 <= 0x7fffffffffffffffL,
      "overflow in multiplication");
      static_assert((__a0 * __b1 + __b0 * __a1) * __c
      <= 0x7fffffffffffffffL - __b0 * __a0,
      "overflow in multiplication");

    public:
      static const intmax_t value = _Pn * _Qn;
    };



  template<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");
    };
# 265 "/usr/include/c++/10/ratio" 3
  template<intmax_t _Num, intmax_t _Den = 1>
    struct ratio
    {
      static_assert(_Den != 0, "denominator cannot be zero");
      static_assert(_Num >= -0x7fffffffffffffffL && _Den >= -0x7fffffffffffffffL,
      "out of range");


      static constexpr intmax_t num =
        _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;

      static constexpr intmax_t den =
        __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;

      typedef ratio<num, den> type;
    };

  template<intmax_t _Num, intmax_t _Den>
    constexpr intmax_t ratio<_Num, _Den>::num;

  template<intmax_t _Num, intmax_t _Den>
    constexpr intmax_t ratio<_Num, _Den>::den;



  template<typename _R1, typename _R2>
    struct __ratio_multiply
    {
    private:
      static const intmax_t __gcd1 =
        __static_gcd<_R1::num, _R2::den>::value;
      static const intmax_t __gcd2 =
        __static_gcd<_R2::num, _R1::den>::value;

    public:
      typedef ratio<
        __safe_multiply<(_R1::num / __gcd1),
                        (_R2::num / __gcd2)>::value,
        __safe_multiply<(_R1::den / __gcd2),
                        (_R2::den / __gcd1)>::value> type;

      static constexpr intmax_t num = type::num;
      static constexpr intmax_t den = type::den;
    };

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_multiply<_R1, _R2>::num;

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_multiply<_R1, _R2>::den;




  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;
    };

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_divide<_R1, _R2>::num;

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_divide<_R1, _R2>::den;




  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>
    { };


  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
    { };


  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 <= 0x7fffffffffffffffL, "overflow in addition");
      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
      static_assert(__d_final::__hi == 0 &&
        __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition");
    public:
      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
    };

  template<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 <= 0x7fffffffffffffffL, "overflow in addition");
      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
      static_assert(__d_final::__hi == 0 &&
        __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition");
    public:
      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
    };

  template<typename _R1, typename _R2>
    struct __ratio_add
    {
      typedef typename __ratio_add_impl<_R1, _R2>::type type;
      static constexpr intmax_t num = type::num;
      static constexpr intmax_t den = type::den;
    };

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_add<_R1, _R2>::num;

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_add<_R1, _R2>::den;




  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;
    };

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_subtract<_R1, _R2>::num;

  template<typename _R1, typename _R2>
    constexpr intmax_t __ratio_subtract<_R1, _R2>::den;




  template<typename _R1, typename _R2>
    using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;


  typedef ratio<1, 1000000000000000000> atto;
  typedef ratio<1, 1000000000000000> femto;
  typedef ratio<1, 1000000000000> pico;
  typedef ratio<1, 1000000000> nano;
  typedef ratio<1, 1000000> micro;
  typedef ratio<1, 1000> milli;
  typedef ratio<1, 100> centi;
  typedef ratio<1, 10> deci;
  typedef ratio< 10, 1> deca;
  typedef ratio< 100, 1> hecto;
  typedef ratio< 1000, 1> kilo;
  typedef ratio< 1000000, 1> mega;
  typedef ratio< 1000000000, 1> giga;
  typedef ratio< 1000000000000, 1> tera;
  typedef ratio< 1000000000000000, 1> peta;
  typedef ratio< 1000000000000000000, 1> exa;



}
# 40 "/usr/include/c++/10/chrono" 2 3


# 1 "/usr/include/c++/10/ctime" 1 3
# 39 "/usr/include/c++/10/ctime" 3
       
# 40 "/usr/include/c++/10/ctime" 3
# 43 "/usr/include/c++/10/chrono" 2 3


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

# 60 "/usr/include/c++/10/chrono" 3
  namespace chrono
  {
    template<typename _Rep, typename _Period = ratio<1>>
      struct duration;

    template<typename _Clock, typename _Dur = typename _Clock::duration>
      struct time_point;
  }





  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, __r>;
    };

  template<typename _Period1, typename _Period2>
    struct __duration_common_type<__failure_type, _Period1, _Period2>
    { typedef __failure_type 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>, _Period1, _Period2>
    { };





  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>
    { };



  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 _ToDur, typename _Rep, typename _Period>
      constexpr __enable_if_is_duration<_ToDur>
      duration_cast(const duration<_Rep, _Period>& __d)
      {
 typedef typename _ToDur::period __to_period;
 typedef typename _ToDur::rep __to_rep;
 typedef ratio_divide<_Period, __to_period> __cf;
 typedef typename common_type<__to_rep, _Rep, intmax_t>::type
          __cr;
 typedef __duration_cast_impl<_ToDur, __cf, __cr,
          __cf::num == 1, __cf::den == 1> __dc;
 return __dc::__cast(__d);
      }


    template<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<typename _ToDur, typename _Rep, typename _Period>
      constexpr __enable_if_is_duration<_ToDur>
      floor(const duration<_Rep, _Period>& __d)
      {
 auto __to = chrono::duration_cast<_ToDur>(__d);
 if (__to > __d)
   return __to - _ToDur{1};
 return __to;
      }

    template<typename _ToDur, typename _Rep, typename _Period>
      constexpr __enable_if_is_duration<_ToDur>
      ceil(const duration<_Rep, _Period>& __d)
      {
 auto __to = chrono::duration_cast<_ToDur>(__d);
 if (__to < __d)
   return __to + _ToDur{1};
 return __to;
      }

    template <typename _ToDur, typename _Rep, typename _Period>
      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>
      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;
      }



    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 _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 _Rep, typename _Period>
      struct duration
      {
      private:
 template<typename _Rep2>
   using __is_float = treat_as_floating_point<_Rep2>;


 template<typename _Period2>
   using __is_harmonic
     = __bool_constant<ratio_divide<_Period2, _Period>::den == 1>;

      public:

 typedef _Rep rep;
 typedef _Period period;

 static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
 static_assert(__is_ratio<_Period>::value,
        "period must be a specialization of ratio");
 static_assert(_Period::num > 0, "period must be positive");


 constexpr duration() = default;

 duration(const duration&) = default;



 template<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<
   __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
 operator+() const
 { return *this; }

 constexpr duration
 operator-() const
 { return duration(-__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
   typename enable_if<!treat_as_floating_point<_Rep2>::value,
        duration&>::type
   operator%=(const rep& __rhs)
   {
     __r %= __rhs;
     return *this;
   }

 template<typename _Rep2 = rep>
   constexpr
   typename enable_if<!treat_as_floating_point<_Rep2>::value,
        duration&>::type
   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());
      }
# 513 "/usr/include/c++/10/chrono" 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;






    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());
      }



    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>
      constexpr bool
      operator!=(const duration<_Rep1, _Period1>& __lhs,
   const duration<_Rep2, _Period2>& __rhs)
      { return !(__lhs == __rhs); }

    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); }
# 651 "/usr/include/c++/10/chrono" 3
    typedef duration<int64_t, nano> nanoseconds;


    typedef duration<int64_t, micro> microseconds;


    typedef duration<int64_t, milli> milliseconds;


    typedef duration<int64_t> seconds;


    typedef duration<int64_t, ratio< 60>> minutes;


    typedef duration<int64_t, ratio<3600>> hours;




    template<typename _Clock, typename _Dur>
      struct time_point
      {
 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+=(const duration& __dur)
 {
   __d += __dur;
   return *this;
 }

 constexpr time_point&
 operator-=(const duration& __dur)
 {
   __d -= __dur;
   return *this;
 }


 static constexpr time_point
 min() noexcept
 { return time_point(duration::min()); }

 static constexpr time_point
 max() noexcept
 { return time_point(duration::max()); }

      private:
 duration __d;
      };


    template<typename _ToDur, typename _Clock, typename _Dur>
      constexpr typename enable_if<__is_duration<_ToDur>::value,
       time_point<_Clock, _ToDur>>::type
      time_point_cast(const time_point<_Clock, _Dur>& __t)
      {
 typedef time_point<_Clock, _ToDur> __time_point;
 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
      }


    template<typename _ToDur, typename _Clock, typename _Dur>
      constexpr
      enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
      floor(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::floor<_ToDur>(__tp.time_since_epoch())};
      }

    template<typename _ToDur, typename _Clock, typename _Dur>
      constexpr
      enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
      ceil(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::ceil<_ToDur>(__tp.time_since_epoch())};
      }

    template<typename _ToDur, typename _Clock, typename _Dur>
      constexpr enable_if_t<
 __and_<__is_duration<_ToDur>,
        __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
 time_point<_Clock, _ToDur>>
      round(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::round<_ToDur>(__tp.time_since_epoch())};
      }





    template<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, typename _Dur2>
      constexpr bool
      operator!=(const time_point<_Clock, _Dur1>& __lhs,
   const time_point<_Clock, _Dur2>& __rhs)
      { return !(__lhs == __rhs); }

    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); }
# 878 "/usr/include/c++/10/chrono" 3
    inline namespace _V2 {







    struct system_clock
    {
      typedef chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<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)));
      }
    };
# 926 "/usr/include/c++/10/chrono" 3
    struct steady_clock
    {
      typedef chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<steady_clock, duration> time_point;

      static constexpr bool is_steady = true;

      static time_point
      now() noexcept;
    };
# 948 "/usr/include/c++/10/chrono" 3
    using high_resolution_clock = system_clock;

    }

  }





  inline namespace literals
  {
# 983 "/usr/include/c++/10/chrono" 3
  inline namespace chrono_literals
  {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"

    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;
  }




}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 2
# 1 "/usr/include/c++/10/iostream" 1 3
# 36 "/usr/include/c++/10/iostream" 3
       
# 37 "/usr/include/c++/10/iostream" 3





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

# 60 "/usr/include/c++/10/iostream" 3
  extern istream cin;
  extern ostream cout;
  extern ostream cerr;
  extern ostream clog;


  extern wistream wcin;
  extern wostream wcout;
  extern wostream wcerr;
  extern wostream wclog;




  static ios_base::Init __ioinit;


}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 2

# 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;
  };
# 66 "/usr/include/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
    void *__restrict __tz) throw () __attribute__ ((__nonnull__ (1)));







extern int settimeofday (const struct timeval *__tv,
    const struct timezone *__tz)
     throw ();





extern int adjtime (const struct timeval *__delta,
      struct timeval *__olddelta) throw ();




enum __itimer_which
  {

    ITIMER_REAL = 0,


    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) throw ();




extern int setitimer (__itimer_which_t __which,
        const struct itimerval *__restrict __new,
        struct itimerval *__restrict __old) throw ();




extern int utimes (const char *__file, const struct timeval __tvp[2])
     throw () __attribute__ ((__nonnull__ (1)));



extern int lutimes (const char *__file, const struct timeval __tvp[2])
     throw () __attribute__ ((__nonnull__ (1)));


extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();






extern int futimesat (int __fd, const char *__file,
        const struct timeval __tvp[2]) throw ();
# 187 "/usr/include/sys/time.h" 3 4
}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_assert.h" 1



# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 5 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_assert.h" 2
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_assert.h"

# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_assert.h"
class CephContext;

namespace ceph {

struct BackTrace;
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_assert.h"
extern void register_assert_context(CephContext *cct);

struct assert_data {
  const char *assertion;
  const char *file;
  const int line;
  const char *function;
};

extern void __ceph_assert_fail(const char *assertion, const char *file, int line, const char *function)
  __attribute__ ((__noreturn__));
extern void __ceph_assert_fail(const assert_data &ctx)
  __attribute__ ((__noreturn__));

extern void __ceph_assertf_fail(const char *assertion, const char *file, int line, const char *function, const char* msg, ...)
  __attribute__ ((__noreturn__));
extern void __ceph_assert_warn(const char *assertion, const char *file, int line, const char *function);

[[noreturn]] void __ceph_abort(const char *file, int line, const char *func,
                               const std::string& msg);

[[noreturn]] void __ceph_abortf(const char *file, int line, const char *func,
                                const char* msg, ...);
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_assert.h"
}

using namespace ceph;
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 2
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
struct ceph_timespec;

namespace ceph {
  namespace time_detail {
    using std::chrono::duration_cast;
    using std::chrono::seconds;
    using std::chrono::microseconds;
    using std::chrono::nanoseconds;







    typedef uint64_t rep;


    typedef std::chrono::duration<rep, std::nano> timespan;



    typedef int64_t signed_rep;

    typedef std::chrono::duration<signed_rep, std::nano> signedspan;
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
    class real_clock {
    public:
      typedef timespan duration;
      typedef duration::rep rep;
      typedef duration::period period;


      typedef std::chrono::time_point<real_clock> time_point;
      static constexpr const bool is_steady = false;

      static time_point now() noexcept {
 struct timespec ts;
 clock_gettime(
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 3 4
              0
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
                            , &ts);
 return from_timespec(ts);
      }

      static bool is_zero(const time_point& t) {
 return (t == time_point::min());
      }

      static time_point zero() {
        return time_point::min();
      }



      template<typename Clock, typename Duration>
      static time_point to_system_time_point(
 const std::chrono::time_point<Clock, Duration>& t) {
 return time_point(seconds(Clock::to_time_t(t)) +
     duration_cast<duration>(t.time_since_epoch() %
        seconds(1)));
      }
      template<typename Clock, typename Duration>
      static std::chrono::time_point<Clock, Duration> to_system_time_point(
 const time_point& t) {
 return (Clock::from_time_t(to_time_t(t)) +
  duration_cast<Duration>(t.time_since_epoch() % seconds(1)));
      }

      static time_t to_time_t(const time_point& t) noexcept {
 return duration_cast<seconds>(t.time_since_epoch()).count();
      }
      static time_point from_time_t(const time_t& t) noexcept {
 return time_point(seconds(t));
      }

      static void to_timespec(const time_point& t, struct timespec& ts) {
 ts.tv_sec = to_time_t(t);
 ts.tv_nsec = (t.time_since_epoch() % seconds(1)).count();
      }
      static struct timespec to_timespec(const time_point& t) {
 struct timespec ts;
 to_timespec(t, ts);
 return ts;
      }
      static time_point from_timespec(const struct timespec& ts) {
 return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
      }

      static void to_ceph_timespec(const time_point& t,
       struct ceph_timespec& ts);
      static struct ceph_timespec to_ceph_timespec(const time_point& t);
      static time_point from_ceph_timespec(const struct ceph_timespec& ts);

      static void to_timeval(const time_point& t, struct timeval& tv) {
 tv.tv_sec = to_time_t(t);
 tv.tv_usec = duration_cast<microseconds>(t.time_since_epoch() %
       seconds(1)).count();
      }
      static struct timeval to_timeval(const time_point& t) {
 struct timeval tv;
 to_timeval(t, tv);
 return tv;
      }
      static time_point from_timeval(const struct timeval& tv) {
 return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
      }

      static double to_double(const time_point& t) {
 return std::chrono::duration<double>(t.time_since_epoch()).count();
      }
      static time_point from_double(const double d) {
 return time_point(duration_cast<duration>(
       std::chrono::duration<double>(d)));
      }
    };

    class coarse_real_clock {
    public:
      typedef timespan duration;
      typedef duration::rep rep;
      typedef duration::period period;


      typedef std::chrono::time_point<coarse_real_clock> time_point;
      static constexpr const bool is_steady = false;

      static time_point now() noexcept {
 struct timespec ts;


 clock_gettime(
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 3 4
              5
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
                                   , &ts);
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
 return from_timespec(ts);
      }

      static bool is_zero(const time_point& t) {
 return (t == time_point::min());
      }

      static time_point zero() {
 return time_point::min();
      }

      static time_t to_time_t(const time_point& t) noexcept {
 return duration_cast<seconds>(t.time_since_epoch()).count();
      }
      static time_point from_time_t(const time_t t) noexcept {
 return time_point(seconds(t));
      }

      static void to_timespec(const time_point& t, struct timespec& ts) {
 ts.tv_sec = to_time_t(t);
 ts.tv_nsec = (t.time_since_epoch() % seconds(1)).count();
      }
      static struct timespec to_timespec(const time_point& t) {
 struct timespec ts;
 to_timespec(t, ts);
 return ts;
      }
      static time_point from_timespec(const struct timespec& ts) {
 return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
      }

      static void to_ceph_timespec(const time_point& t,
       struct ceph_timespec& ts);
      static struct ceph_timespec to_ceph_timespec(const time_point& t);
      static time_point from_ceph_timespec(const struct ceph_timespec& ts);

      static void to_timeval(const time_point& t, struct timeval& tv) {
 tv.tv_sec = to_time_t(t);
 tv.tv_usec = duration_cast<microseconds>(t.time_since_epoch() %
       seconds(1)).count();
      }
      static struct timeval to_timeval(const time_point& t) {
 struct timeval tv;
 to_timeval(t, tv);
 return tv;
      }
      static time_point from_timeval(const struct timeval& tv) {
 return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
      }

      static double to_double(const time_point& t) {
 return std::chrono::duration<double>(t.time_since_epoch()).count();
      }
      static time_point from_double(const double d) {
 return time_point(duration_cast<duration>(
       std::chrono::duration<double>(d)));
      }
    };

    class mono_clock {
    public:
      typedef timespan duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef std::chrono::time_point<mono_clock> time_point;
      static constexpr const bool is_steady = true;

      static time_point now() noexcept {
 struct timespec ts;
 clock_gettime(
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 3 4
              1
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
                             , &ts);
 return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
      }

      static bool is_zero(const time_point& t) {
        return (t == time_point::min());
      }

      static time_point zero() {
        return time_point::min();
      }




    };

    class coarse_mono_clock {
    public:
      typedef timespan duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef std::chrono::time_point<coarse_mono_clock> time_point;
      static constexpr const bool is_steady = true;

      static time_point now() noexcept {
 struct timespec ts;


 clock_gettime(
# 279 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h" 3 4
              6
# 279 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
                                    , &ts);
# 289 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
 return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
      }

      static bool is_zero(const time_point& t) {
        return (t == time_point::min());
      }

      static time_point zero() {
        return time_point::min();
      }
    };



    namespace {
      template<typename Rep1, typename Period1, typename Rep2,
        typename Period2>
      inline auto difference(std::chrono::duration<Rep1, Period1> minuend,
        std::chrono::duration<Rep2, Period2> subtrahend)
 -> typename std::common_type<
   std::chrono::duration<typename std::make_signed<Rep1>::type,
    Period1>,
   std::chrono::duration<typename std::make_signed<Rep2>::type,
    Period2> >::type {

 using srep =
   typename std::common_type<
     std::chrono::duration<typename std::make_signed<Rep1>::type,
      Period1>,
     std::chrono::duration<typename std::make_signed<Rep2>::type,
      Period2> >::type;
 return srep(srep(minuend).count() - srep(subtrahend).count());
      }

      template<typename Clock, typename Duration1, typename Duration2>
      inline auto difference(
 typename std::chrono::time_point<Clock, Duration1> minuend,
 typename std::chrono::time_point<Clock, Duration2> subtrahend)
 -> typename std::common_type<
   std::chrono::duration<typename std::make_signed<
      typename Duration1::rep>::type,
    typename Duration1::period>,
   std::chrono::duration<typename std::make_signed<
      typename Duration2::rep>::type,
    typename Duration2::period> >::type {
 return difference(minuend.time_since_epoch(),
     subtrahend.time_since_epoch());
      }
    }
  }






  using time_detail::timespan;



  using time_detail::signedspan;


  using time_detail::real_clock;


  using time_detail::coarse_real_clock;



  using time_detail::mono_clock;



  using time_detail::coarse_mono_clock;
# 380 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h"
  typedef real_clock::time_point real_time;
  typedef coarse_real_clock::time_point coarse_real_time;





  typedef mono_clock::time_point mono_time;
  typedef coarse_mono_clock::time_point coarse_mono_time;

  template<typename Rep1, typename Ratio1, typename Rep2, typename Ratio2>
  auto floor(const std::chrono::duration<Rep1, Ratio1>& duration,
      const std::chrono::duration<Rep2, Ratio2>& precision) ->
    typename std::common_type<std::chrono::duration<Rep1, Ratio1>,
         std::chrono::duration<Rep2, Ratio2> >::type {
    return duration - (duration % precision);
  }

  template<typename Rep1, typename Ratio1, typename Rep2, typename Ratio2>
  auto ceil(const std::chrono::duration<Rep1, Ratio1>& duration,
     const std::chrono::duration<Rep2, Ratio2>& precision) ->
    typename std::common_type<std::chrono::duration<Rep1, Ratio1>,
         std::chrono::duration<Rep2, Ratio2> >::type {
    auto tmod = duration % precision;
    return duration - tmod + (tmod > tmod.zero() ? 1 : 0) * precision;
  }

  template<typename Clock, typename Duration, typename Rep, typename Ratio>
  auto floor(const std::chrono::time_point<Clock, Duration>& timepoint,
      const std::chrono::duration<Rep, Ratio>& precision) ->
    std::chrono::time_point<Clock,
       typename std::common_type<
         Duration, std::chrono::duration<Rep, Ratio>
         >::type> {
    return std::chrono::time_point<
      Clock, typename std::common_type<
 Duration, std::chrono::duration<Rep, Ratio> >::type>(
   floor(timepoint.time_since_epoch(), precision));
  }
  template<typename Clock, typename Duration, typename Rep, typename Ratio>
  auto ceil(const std::chrono::time_point<Clock, Duration>& timepoint,
     const std::chrono::duration<Rep, Ratio>& precision) ->
    std::chrono::time_point<Clock,
       typename std::common_type<
         Duration,
         std::chrono::duration<Rep, Ratio> >::type> {
    return std::chrono::time_point<
      Clock, typename std::common_type<
 Duration, std::chrono::duration<Rep, Ratio> >::type>(
   ceil(timepoint.time_since_epoch(), precision));
  }

  namespace {
    inline timespan make_timespan(const double d) {
      return std::chrono::duration_cast<timespan>(
 std::chrono::duration<double>(d));
    }
  }

  std::ostream& operator<<(std::ostream& m, const timespan& t);
  template<typename Clock,
    typename std::enable_if<!Clock::is_steady>::type* = nullptr>
  std::ostream& operator<<(std::ostream& m,
      const std::chrono::time_point<Clock>& t);
  template<typename Clock,
    typename std::enable_if<Clock::is_steady>::type* = nullptr>
  std::ostream& operator<<(std::ostream& m,
      const std::chrono::time_point<Clock>& t);




  namespace {
    inline signedspan operator -(real_time minuend,
     real_time subtrahend) {
      return time_detail::difference(minuend, subtrahend);
    }

    inline signedspan operator -(coarse_real_time minuend,
     coarse_real_time subtrahend) {
      return time_detail::difference(minuend, subtrahend);
    }

    inline signedspan operator -(mono_time minuend,
     mono_time subtrahend) {
      return time_detail::difference(minuend, subtrahend);
    }

    inline signedspan operator -(coarse_mono_time minuend,
     coarse_mono_time subtrahend) {
      return time_detail::difference(minuend, subtrahend);
    }
  }






inline timespan abs(signedspan z) {
  return z > signedspan::zero() ?
    std::chrono::duration_cast<timespan>(z) :
    timespan(-z.count());
}
inline timespan to_timespan(signedspan z) {
  do { static const ceph::assert_data assert_data_ctx = {"z >= signedspan::zero()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_time.h", 485, __PRETTY_FUNCTION__}; ((z >= signedspan::zero()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
  return std::chrono::duration_cast<timespan>(z);
}

std::string timespan_str(timespan t);
std::string exact_timespan_str(timespan t);
std::chrono::seconds parse_timespan(const std::string& s);


template <typename Clock, typename = std::void_t<>>
struct converts_to_timespec : std::false_type {};

template <typename Clock>
struct converts_to_timespec<Clock, std::void_t<decltype(
    Clock::from_timespec(Clock::to_timespec(
        std::declval<typename Clock::time_point>()))
  )>> : std::true_type {};

template <typename Clock>
constexpr bool converts_to_timespec_v = converts_to_timespec<Clock>::value;

}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/int_types.h" 1
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h" 1
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h"
# 1 "/usr/include/c++/10/mutex" 1 3
# 32 "/usr/include/c++/10/mutex" 3
       
# 33 "/usr/include/c++/10/mutex" 3
# 43 "/usr/include/c++/10/mutex" 3
# 1 "/usr/include/c++/10/bits/std_mutex.h" 1 3
# 33 "/usr/include/c++/10/bits/std_mutex.h" 3
       
# 34 "/usr/include/c++/10/bits/std_mutex.h" 3
# 43 "/usr/include/c++/10/bits/std_mutex.h" 3

# 43 "/usr/include/c++/10/bits/std_mutex.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 57 "/usr/include/c++/10/bits/std_mutex.h" 3
  class __mutex_base
  {
  protected:
    typedef __gthread_mutex_t __native_type;


    __native_type _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_DEFAULT, 0, 0, { 0, 0 } } };

    constexpr __mutex_base() noexcept = default;
# 78 "/usr/include/c++/10/bits/std_mutex.h" 3
    __mutex_base(const __mutex_base&) = delete;
    __mutex_base& operator=(const __mutex_base&) = delete;
  };


  class mutex : private __mutex_base
  {
  public:
    typedef __native_type* native_handle_type;


    constexpr

    mutex() noexcept = default;
    ~mutex() = default;

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

    void
    lock()
    {
      int __e = __gthread_mutex_lock(&_M_mutex);


      if (__e)
 __throw_system_error(__e);
    }

    bool
    try_lock() noexcept
    {

      return !__gthread_mutex_trylock(&_M_mutex);
    }

    void
    unlock()
    {

      __gthread_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }
  };




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


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



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


  inline constexpr defer_lock_t defer_lock { };


  inline constexpr try_to_lock_t try_to_lock { };


  inline constexpr adopt_lock_t adopt_lock { };






  template<typename _Mutex>
    class lock_guard
    {
    public:
      typedef _Mutex mutex_type;

      explicit lock_guard(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m)
      { }

      ~lock_guard()
      { _M_device.unlock(); }

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

    private:
      mutex_type& _M_device;
    };



}
# 44 "/usr/include/c++/10/mutex" 2 3
# 1 "/usr/include/c++/10/bits/unique_lock.h" 1 3
# 33 "/usr/include/c++/10/bits/unique_lock.h" 3
       
# 34 "/usr/include/c++/10/bits/unique_lock.h" 3
# 42 "/usr/include/c++/10/bits/unique_lock.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 55 "/usr/include/c++/10/bits/unique_lock.h" 3
  template<typename _Mutex>
    class unique_lock
    {
    public:
      typedef _Mutex mutex_type;

      unique_lock() noexcept
      : _M_device(0), _M_owns(false)
      { }

      explicit unique_lock(mutex_type& __m)
      : _M_device(std::__addressof(__m)), _M_owns(false)
      {
 lock();
 _M_owns = true;
      }

      unique_lock(mutex_type& __m, defer_lock_t) noexcept
      : _M_device(std::__addressof(__m)), _M_owns(false)
      { }

      unique_lock(mutex_type& __m, try_to_lock_t)
      : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock())
      { }

      unique_lock(mutex_type& __m, adopt_lock_t) noexcept
      : _M_device(std::__addressof(__m)), _M_owns(true)
      {

      }

      template<typename _Clock, typename _Duration>
 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>
 unique_lock(mutex_type& __m,
      const chrono::duration<_Rep, _Period>& __rtime)
 : _M_device(std::__addressof(__m)),
   _M_owns(_M_device->try_lock_for(__rtime))
 { }

      ~unique_lock()
      {
 if (_M_owns)
   unlock();
      }

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

      unique_lock(unique_lock&& __u) noexcept
      : _M_device(__u._M_device), _M_owns(__u._M_owns)
      {
 __u._M_device = 0;
 __u._M_owns = false;
      }

      unique_lock& operator=(unique_lock&& __u) noexcept
      {
 if(_M_owns)
   unlock();

 unique_lock(std::move(__u)).swap(*this);

 __u._M_device = 0;
 __u._M_owns = false;

 return *this;
      }

      void
      lock()
      {
 if (!_M_device)
   __throw_system_error(int(errc::operation_not_permitted));
 else if (_M_owns)
   __throw_system_error(int(errc::resource_deadlock_would_occur));
 else
   {
     _M_device->lock();
     _M_owns = true;
   }
      }

      bool
      try_lock()
      {
 if (!_M_device)
   __throw_system_error(int(errc::operation_not_permitted));
 else if (_M_owns)
   __throw_system_error(int(errc::resource_deadlock_would_occur));
 else
   {
     _M_owns = _M_device->try_lock();
     return _M_owns;
   }
      }

      template<typename _Clock, typename _Duration>
 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>
 bool
 try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
 {
   if (!_M_device)
     __throw_system_error(int(errc::operation_not_permitted));
   else if (_M_owns)
     __throw_system_error(int(errc::resource_deadlock_would_occur));
   else
     {
       _M_owns = _M_device->try_lock_for(__rtime);
       return _M_owns;
     }
  }

      void
      unlock()
      {
 if (!_M_owns)
   __throw_system_error(int(errc::operation_not_permitted));
 else if (_M_device)
   {
     _M_device->unlock();
     _M_owns = false;
   }
      }

      void
      swap(unique_lock& __u) noexcept
      {
 std::swap(_M_device, __u._M_device);
 std::swap(_M_owns, __u._M_owns);
      }

      mutex_type*
      release() noexcept
      {
 mutex_type* __ret = _M_device;
 _M_device = 0;
 _M_owns = false;
 return __ret;
      }

      bool
      owns_lock() const noexcept
      { return _M_owns; }

      explicit operator bool() const noexcept
      { return owns_lock(); }

      mutex_type*
      mutex() const noexcept
      { return _M_device; }

    private:
      mutex_type* _M_device;
      bool _M_owns;
    };



  template<typename _Mutex>
    inline void
    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
    { __x.swap(__y); }


}
# 45 "/usr/include/c++/10/mutex" 2 3
# 53 "/usr/include/c++/10/mutex" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 65 "/usr/include/c++/10/mutex" 3
  class __recursive_mutex_base
  {
  protected:
    typedef __gthread_recursive_mutex_t __native_type;

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


    __native_type _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };

    __recursive_mutex_base() = default;
# 89 "/usr/include/c++/10/mutex" 3
  };


  class recursive_mutex : private __recursive_mutex_base
  {
  public:
    typedef __native_type* native_handle_type;

    recursive_mutex() = default;
    ~recursive_mutex() = default;

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

    void
    lock()
    {
      int __e = __gthread_recursive_mutex_lock(&_M_mutex);


      if (__e)
 __throw_system_error(__e);
    }

    bool
    try_lock() noexcept
    {

      return !__gthread_recursive_mutex_trylock(&_M_mutex);
    }

    void
    unlock()
    {

      __gthread_recursive_mutex_unlock(&_M_mutex);
    }

    native_handle_type
    native_handle() noexcept
    { return &_M_mutex; }
  };


  template<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)
 {



   auto __now = _Clock::now();
   do {
     auto __rtime = __atime - __now;
     if (_M_try_lock_for(__rtime))
       return true;
     __now = _Clock::now();
   } while (__atime > __now);
   return false;
 }
    };


  class timed_mutex
  : private __mutex_base, public __timed_mutex_impl<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);
    }

    bool
    try_lock() noexcept
    {

      return !__gthread_mutex_trylock(&_M_mutex);
    }

    template <class _Rep, class _Period>
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      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); }

  };


  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);
    }

    bool
    try_lock() noexcept
    {

      return !__gthread_recursive_mutex_trylock(&_M_mutex);
    }

    template <class _Rep, class _Period>
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      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); }

  };
# 510 "/usr/include/c++/10/mutex" 3
  template<typename _Lock>
    inline unique_lock<_Lock>
    __try_to_lock(_Lock& __l)
    { return unique_lock<_Lock>{__l, try_to_lock}; }

  template<int _Idx, bool _Continue = true>
    struct __try_lock_impl
    {
      template<typename... _Lock>
 static void
 __do_try_lock(tuple<_Lock&...>& __locks, int& __idx)
 {
          __idx = _Idx;
          auto __lock = std::__try_to_lock(std::get<_Idx>(__locks));
          if (__lock.owns_lock())
            {
       constexpr bool __cont = _Idx + 2 < sizeof...(_Lock);
       using __try_locker = __try_lock_impl<_Idx + 1, __cont>;
       __try_locker::__do_try_lock(__locks, __idx);
              if (__idx == -1)
                __lock.release();
            }
 }
    };

  template<int _Idx>
    struct __try_lock_impl<_Idx, false>
    {
      template<typename... _Lock>
 static void
 __do_try_lock(tuple<_Lock&...>& __locks, int& __idx)
 {
          __idx = _Idx;
          auto __lock = std::__try_to_lock(std::get<_Idx>(__locks));
          if (__lock.owns_lock())
            {
              __idx = -1;
              __lock.release();
            }
 }
    };
# 563 "/usr/include/c++/10/mutex" 3
  template<typename _Lock1, typename _Lock2, typename... _Lock3>
    int
    try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3)
    {
      int __idx;
      auto __locks = std::tie(__l1, __l2, __l3...);
      __try_lock_impl<0>::__do_try_lock(__locks, __idx);
      return __idx;
    }
# 584 "/usr/include/c++/10/mutex" 3
  template<typename _L1, typename _L2, typename... _L3>
    void
    lock(_L1& __l1, _L2& __l2, _L3&... __l3)
    {
      while (true)
        {
          using __try_locker = __try_lock_impl<0, sizeof...(_L3) != 0>;
          unique_lock<_L1> __first(__l1);
          int __idx;
          auto __locks = std::tie(__l2, __l3...);
          __try_locker::__do_try_lock(__locks, __idx);
          if (__idx == -1)
            {
              __first.release();
              return;
            }
        }
    }
# 610 "/usr/include/c++/10/mutex" 3
  template<typename... _MutexTypes>
    class scoped_lock
    {
    public:
      explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m...))
      { std::lock(__m...); }

      explicit scoped_lock(adopt_lock_t, _MutexTypes&... __m) noexcept
      : _M_devices(std::tie(__m...))
      { }

      ~scoped_lock()
      { std::apply([](auto&... __m) { (__m.unlock(), ...); }, _M_devices); }

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

    private:
      tuple<_MutexTypes&...> _M_devices;
    };

  template<>
    class scoped_lock<>
    {
    public:
      explicit scoped_lock() = default;
      explicit scoped_lock(adopt_lock_t) noexcept { }
      ~scoped_lock() = default;

      scoped_lock(const scoped_lock&) = delete;
      scoped_lock& operator=(const scoped_lock&) = delete;
    };

  template<typename _Mutex>
    class scoped_lock<_Mutex>
    {
    public:
      using mutex_type = _Mutex;

      explicit scoped_lock(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      explicit scoped_lock(adopt_lock_t, mutex_type& __m) noexcept
      : _M_device(__m)
      { }

      ~scoped_lock()
      { _M_device.unlock(); }

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

    private:
      mutex_type& _M_device;
    };




  struct once_flag
  {
  private:
    typedef __gthread_once_t __native_type;
    __native_type _M_once = 0;

  public:

    constexpr once_flag() noexcept = default;


    once_flag(const once_flag&) = delete;

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

    template<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)();
# 703 "/usr/include/c++/10/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_callable = std::__addressof(__callable);
      __once_call = []{ (*(decltype(__callable)*)__once_callable)(); };






      int __e = __gthread_once(&__once._M_once, &__once_proxy);
# 739 "/usr/include/c++/10/mutex" 3
      if (__e)
 __throw_system_error(__e);
    }




}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h" 2


# 1 "/usr/include/c++/10/shared_mutex" 1 3
# 32 "/usr/include/c++/10/shared_mutex" 3
       
# 33 "/usr/include/c++/10/shared_mutex" 3




# 1 "/usr/include/c++/10/condition_variable" 1 3
# 32 "/usr/include/c++/10/condition_variable" 3
       
# 33 "/usr/include/c++/10/condition_variable" 3
# 56 "/usr/include/c++/10/condition_variable" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 69 "/usr/include/c++/10/condition_variable" 3
  enum class cv_status { no_timeout, timeout };


  class condition_variable
  {
    using steady_clock = chrono::steady_clock;
    using system_clock = chrono::system_clock;

    using __clock_t = steady_clock;



    typedef __gthread_cond_t __native_type;


    __native_type _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } };




  public:
    typedef __native_type* native_handle_type;

    condition_variable() noexcept;
    ~condition_variable() noexcept;

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

    void
    notify_one() noexcept;

    void
    notify_all() noexcept;

    void
    wait(unique_lock<mutex>& __lock) noexcept;

    template<typename _Predicate>
      void
      wait(unique_lock<mutex>& __lock, _Predicate __p)
      {
 while (!__p())
   wait(__lock);
      }


    template<typename _Duration>
      cv_status
      wait_until(unique_lock<mutex>& __lock,
   const chrono::time_point<steady_clock, _Duration>& __atime)
      { return __wait_until_impl(__lock, __atime); }


    template<typename _Duration>
      cv_status
      wait_until(unique_lock<mutex>& __lock,
   const chrono::time_point<system_clock, _Duration>& __atime)
      { return __wait_until_impl(__lock, __atime); }

    template<typename _Clock, typename _Duration>
      cv_status
      wait_until(unique_lock<mutex>& __lock,
   const chrono::time_point<_Clock, _Duration>& __atime)
      {
 const typename _Clock::time_point __c_entry = _Clock::now();
 const __clock_t::time_point __s_entry = __clock_t::now();
 const auto __delta = __atime - __c_entry;
 const auto __s_atime = __s_entry + __delta;

 if (__wait_until_impl(__lock, __s_atime) == cv_status::no_timeout)
   return cv_status::no_timeout;



 if (_Clock::now() < __atime)
   return cv_status::no_timeout;
 return cv_status::timeout;
      }

    template<typename _Clock, typename _Duration, typename _Predicate>
      bool
      wait_until(unique_lock<mutex>& __lock,
   const chrono::time_point<_Clock, _Duration>& __atime,
   _Predicate __p)
      {
 while (!__p())
   if (wait_until(__lock, __atime) == cv_status::timeout)
     return __p();
 return true;
      }

    template<typename _Rep, typename _Period>
      cv_status
      wait_for(unique_lock<mutex>& __lock,
        const chrono::duration<_Rep, _Period>& __rtime)
      {
 using __dur = typename steady_clock::duration;
 auto __reltime = chrono::duration_cast<__dur>(__rtime);
 if (__reltime < __rtime)
   ++__reltime;
 return wait_until(__lock, steady_clock::now() + __reltime);
      }

    template<typename _Rep, typename _Period, typename _Predicate>
      bool
      wait_for(unique_lock<mutex>& __lock,
        const chrono::duration<_Rep, _Period>& __rtime,
        _Predicate __p)
      {
 using __dur = typename steady_clock::duration;
 auto __reltime = chrono::duration_cast<__dur>(__rtime);
 if (__reltime < __rtime)
   ++__reltime;
 return wait_until(__lock, steady_clock::now() + __reltime,
     std::move(__p));
      }

    native_handle_type
    native_handle()
    { return &_M_cond; }

  private:

    template<typename _Dur>
      cv_status
      __wait_until_impl(unique_lock<mutex>& __lock,
   const chrono::time_point<steady_clock, _Dur>& __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())
   };

 pthread_cond_clockwait(&_M_cond, __lock.mutex()->native_handle(),
      1,
      &__ts);

 return (steady_clock::now() < __atime
  ? cv_status::no_timeout : cv_status::timeout);
      }


    template<typename _Dur>
      cv_status
      __wait_until_impl(unique_lock<mutex>& __lock,
   const chrono::time_point<system_clock, _Dur>& __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())
   };

 __gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(),
     &__ts);

 return (system_clock::now() < __atime
  ? cv_status::no_timeout : cv_status::timeout);
      }
  };

  void
  notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);

  struct __at_thread_exit_elt
  {
    __at_thread_exit_elt* _M_next;
    void (*_M_cb)(void*);
  };

  inline namespace _V2 {



  class condition_variable_any
  {

    using __clock_t = chrono::steady_clock;



    condition_variable _M_cond;
    shared_ptr<mutex> _M_mutex;


    template<typename _Lock>
      struct _Unlock
      {
 explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); }

 ~_Unlock() noexcept(false)
 {
   if (uncaught_exception())
     {
       try
       { _M_lock.lock(); }
       catch(const __cxxabiv1::__forced_unwind&)
       { throw; }
       catch(...)
       { }
     }
   else
     _M_lock.lock();
 }

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

 _Lock& _M_lock;
      };

  public:
    condition_variable_any() : _M_mutex(std::make_shared<mutex>()) { }
    ~condition_variable_any() = default;

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

    void
    notify_one() noexcept
    {
      lock_guard<mutex> __lock(*_M_mutex);
      _M_cond.notify_one();
    }

    void
    notify_all() noexcept
    {
      lock_guard<mutex> __lock(*_M_mutex);
      _M_cond.notify_all();
    }

    template<typename _Lock>
      void
      wait(_Lock& __lock)
      {
 shared_ptr<mutex> __mutex = _M_mutex;
 unique_lock<mutex> __my_lock(*__mutex);
 _Unlock<_Lock> __unlock(__lock);


 unique_lock<mutex> __my_lock2(std::move(__my_lock));
 _M_cond.wait(__my_lock2);
      }


    template<typename _Lock, typename _Predicate>
      void
      wait(_Lock& __lock, _Predicate __p)
      {
 while (!__p())
   wait(__lock);
      }

    template<typename _Lock, typename _Clock, typename _Duration>
      cv_status
      wait_until(_Lock& __lock,
   const chrono::time_point<_Clock, _Duration>& __atime)
      {
 shared_ptr<mutex> __mutex = _M_mutex;
 unique_lock<mutex> __my_lock(*__mutex);
 _Unlock<_Lock> __unlock(__lock);


 unique_lock<mutex> __my_lock2(std::move(__my_lock));
 return _M_cond.wait_until(__my_lock2, __atime);
      }

    template<typename _Lock, typename _Clock,
      typename _Duration, typename _Predicate>
      bool
      wait_until(_Lock& __lock,
   const chrono::time_point<_Clock, _Duration>& __atime,
   _Predicate __p)
      {
 while (!__p())
   if (wait_until(__lock, __atime) == cv_status::timeout)
     return __p();
 return true;
      }

    template<typename _Lock, typename _Rep, typename _Period>
      cv_status
      wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime)
      { return wait_until(__lock, __clock_t::now() + __rtime); }

    template<typename _Lock, typename _Rep,
      typename _Period, typename _Predicate>
      bool
      wait_for(_Lock& __lock,
        const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p)
      { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); }
# 447 "/usr/include/c++/10/condition_variable" 3
  };

  }



}
# 38 "/usr/include/c++/10/shared_mutex" 2 3


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

# 53 "/usr/include/c++/10/shared_mutex" 3
  class shared_mutex;



  class shared_timed_mutex;
# 73 "/usr/include/c++/10/shared_mutex" 3
  static __typeof(pthread_rwlock_rdlock) __gthrw_pthread_rwlock_rdlock __attribute__ ((__weakref__("pthread_rwlock_rdlock"), __copy__ (pthread_rwlock_rdlock))); ; static inline int __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_rdlock (__rwlock); else return 0; }
  static __typeof(pthread_rwlock_tryrdlock) __gthrw_pthread_rwlock_tryrdlock __attribute__ ((__weakref__("pthread_rwlock_tryrdlock"), __copy__ (pthread_rwlock_tryrdlock))); ; static inline int __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_tryrdlock (__rwlock); else return 0; }
  static __typeof(pthread_rwlock_wrlock) __gthrw_pthread_rwlock_wrlock __attribute__ ((__weakref__("pthread_rwlock_wrlock"), __copy__ (pthread_rwlock_wrlock))); ; static inline int __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_wrlock (__rwlock); else return 0; }
  static __typeof(pthread_rwlock_trywrlock) __gthrw_pthread_rwlock_trywrlock __attribute__ ((__weakref__("pthread_rwlock_trywrlock"), __copy__ (pthread_rwlock_trywrlock))); ; static inline int __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_trywrlock (__rwlock); else return 0; }
  static __typeof(pthread_rwlock_unlock) __gthrw_pthread_rwlock_unlock __attribute__ ((__weakref__("pthread_rwlock_unlock"), __copy__ (pthread_rwlock_unlock))); ; static inline int __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_unlock (__rwlock); else return 0; }
# 91 "/usr/include/c++/10/shared_mutex" 3
   static __typeof(pthread_rwlock_timedrdlock) __gthrw_pthread_rwlock_timedrdlock __attribute__ ((__weakref__("pthread_rwlock_timedrdlock"), __copy__ (pthread_rwlock_timedrdlock))); ;
  static inline int
  __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
    const timespec *__ts)
  {
    if (__gthread_active_p ())
      return __gthrw_pthread_rwlock_timedrdlock (__rwlock, __ts);
    else
      return 0;
  }
   static __typeof(pthread_rwlock_timedwrlock) __gthrw_pthread_rwlock_timedwrlock __attribute__ ((__weakref__("pthread_rwlock_timedwrlock"), __copy__ (pthread_rwlock_timedwrlock))); ;
  static inline int
  __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
    const timespec *__ts)
  {
    if (__gthread_active_p ())
      return __gthrw_pthread_rwlock_timedwrlock (__rwlock, __ts);
    else
      return 0;
  }
# 147 "/usr/include/c++/10/shared_mutex" 3
  class __shared_mutex_pthread
  {
    friend class shared_timed_mutex;


    pthread_rwlock_t _M_rwlock = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0 }, 0, PTHREAD_RWLOCK_DEFAULT_NP } };

  public:
    __shared_mutex_pthread() = default;
    ~__shared_mutex_pthread() = default;
# 182 "/usr/include/c++/10/shared_mutex" 3
    __shared_mutex_pthread(const __shared_mutex_pthread&) = delete;
    __shared_mutex_pthread& operator=(const __shared_mutex_pthread&) = delete;

    void
    lock()
    {
      int __ret = __glibcxx_rwlock_wrlock(&_M_rwlock);
      if (__ret == 35)
 __throw_system_error(int(errc::resource_deadlock_would_occur));

      do { if (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 192, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
    }

    bool
    try_lock()
    {
      int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock);
      if (__ret == 16) return false;

      do { if (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 201, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
      return true;
    }

    void
    unlock()
    {
      int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock);

      do { if (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 210, __PRETTY_FUNCTION__, "__ret == 0"); } 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 (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 229, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
    }

    bool
    try_lock_shared()
    {
      int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock);



      if (__ret == 16 || __ret == 11) return false;

      do { if (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 241, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
      return true;
    }

    void
    unlock_shared()
    {
      unlock();
    }

    void* native_handle() { return &_M_rwlock; }
  };
# 404 "/usr/include/c++/10/shared_mutex" 3
  class shared_mutex
  {
  public:
    shared_mutex() = default;
    ~shared_mutex() = default;

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



    void lock() { _M_impl.lock(); }
    bool try_lock() { return _M_impl.try_lock(); }
    void unlock() { _M_impl.unlock(); }



    void lock_shared() { _M_impl.lock_shared(); }
    bool try_lock_shared() { return _M_impl.try_lock_shared(); }
    void unlock_shared() { _M_impl.unlock_shared(); }


    typedef void* native_handle_type;
    native_handle_type native_handle() { return _M_impl.native_handle(); }

  private:
    __shared_mutex_pthread _M_impl;




  };




  using __shared_timed_mutex_base = __shared_mutex_pthread;






  class shared_timed_mutex
  : private __shared_timed_mutex_base
  {
    using _Base = __shared_timed_mutex_base;



    using __clock_t = chrono::steady_clock;




  public:
    shared_timed_mutex() = default;
    ~shared_timed_mutex() = default;

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



    void lock() { _Base::lock(); }
    bool try_lock() { return _Base::try_lock(); }
    void unlock() { _Base::unlock(); }

    template<typename _Rep, typename _Period>
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      {
 auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime);
 if (ratio_greater<__clock_t::period, _Period>())
   ++__rt;
 return try_lock_until(__clock_t::now() + __rt);
      }



    void lock_shared() { _Base::lock_shared(); }
    bool try_lock_shared() { return _Base::try_lock_shared(); }
    void unlock_shared() { _Base::unlock_shared(); }

    template<typename _Rep, typename _Period>
      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>
      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 (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 522, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
 return true;
      }


    template<typename _Duration>
      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 (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 548, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
 return true;
      }


    template<typename _Clock, typename _Duration>
      bool
      try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
      {



 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>
      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;
# 600 "/usr/include/c++/10/shared_mutex" 3
 do
   __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts);
 while (__ret == 11 || __ret == 35);
 if (__ret == 110)
   return false;

 do { if (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 606, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
 return true;
      }


    template<typename _Duration>
      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 (! (__ret == 0)) std::__replacement_assert("/usr/include/c++/10/shared_mutex", 632, __PRETTY_FUNCTION__, "__ret == 0"); } while (false);
 return true;
      }


    template<typename _Clock, typename _Duration>
      bool
      try_lock_shared_until(const chrono::time_point<_Clock,
           _Duration>& __atime)
      {



 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;
      }
# 699 "/usr/include/c++/10/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;
      }

      bool
      try_lock()
      {
 _M_lockable();
 return _M_owns = _M_pm->try_lock_shared();
      }

      template<typename _Rep, typename _Period>
 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>
 bool
 try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
 {
   _M_lockable();
   return _M_owns = _M_pm->try_lock_shared_until(__abs_time);
 }

      void
      unlock()
      {
 if (!_M_owns)
   __throw_system_error(int(errc::resource_deadlock_would_occur));
 _M_pm->unlock_shared();
 _M_owns = false;
      }



      void
      swap(shared_lock& __u) noexcept
      {
 std::swap(_M_pm, __u._M_pm);
 std::swap(_M_owns, __u._M_owns);
      }

      mutex_type*
      release() noexcept
      {
 _M_owns = false;
 return std::exchange(_M_pm, nullptr);
      }



      bool owns_lock() const noexcept { return _M_owns; }

      explicit operator bool() const noexcept { return _M_owns; }

      mutex_type* mutex() const noexcept { return _M_pm; }

    private:
      void
      _M_lockable() const
      {
 if (_M_pm == nullptr)
   __throw_system_error(int(errc::operation_not_permitted));
 if (_M_owns)
   __throw_system_error(int(errc::resource_deadlock_would_occur));
      }

      mutex_type* _M_pm;
      bool _M_owns;
    };



  template<typename _Mutex>
    void
    swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
    { __x.swap(__y); }



}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h" 2
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h"

# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h"
namespace ceph {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h"
template<typename T, typename F>
auto maybe_do(const boost::optional<T>& t, F&& f) ->
  boost::optional<std::result_of_t<F(const std::decay_t<T>)>>
{
  if (t)
    return { std::forward<F>(f)(*t) };
  else
    return boost::none;
}





template<typename T, typename F, typename U>
auto maybe_do_or(const boost::optional<T>& t, F&& f, U&& u) ->
  std::result_of_t<F(const std::decay_t<T>)>
{
  static_assert(std::is_convertible_v<U, std::result_of_t<F(T)>>,
  "Alternate value must be convertible to function return type.");
  if (t)
    return std::forward<F>(f)(*t);
  else
    return std::forward<U>(u);
}




template<typename T, typename F>
auto maybe_do(const std::optional<T>& t, F&& f) ->
  std::optional<std::result_of_t<F(const std::decay_t<T>)>>
{
  if (t)
    return { std::forward<F>(f)(*t) };
  else
    return std::nullopt;
}





template<typename T, typename F, typename U>
auto maybe_do_or(const std::optional<T>& t, F&& f, U&& u) ->
  std::result_of_t<F(const std::decay_t<T>)>
{
  static_assert(std::is_convertible_v<U, std::result_of_t<F(T)>>,
  "Alternate value must be convertible to function return type.");
  if (t)
    return std::forward<F>(f)(*t);
  else
    return std::forward<U>(u);
}

namespace _convenience {
template<typename... Ts, typename F, std::size_t... Is>
inline void for_each_helper(const std::tuple<Ts...>& t, const F& f,
       std::index_sequence<Is...>) {
  (f(std::get<Is>(t)), ..., void());
}
template<typename... Ts, typename F, std::size_t... Is>
inline void for_each_helper(std::tuple<Ts...>& t, const F& f,
       std::index_sequence<Is...>) {
  (f(std::get<Is>(t)), ..., void());
}
template<typename... Ts, typename F, std::size_t... Is>
inline void for_each_helper(const std::tuple<Ts...>& t, F& f,
       std::index_sequence<Is...>) {
  (f(std::get<Is>(t)), ..., void());
}
template<typename... Ts, typename F, std::size_t... Is>
inline void for_each_helper(std::tuple<Ts...>& t, F& f,
       std::index_sequence<Is...>) {
  (f(std::get<Is>(t)), ..., void());
}
}

template<typename... Ts, typename F>
inline void for_each(const std::tuple<Ts...>& t, const F& f) {
  _convenience::for_each_helper(t, f, std::index_sequence_for<Ts...>{});
}
template<typename... Ts, typename F>
inline void for_each(std::tuple<Ts...>& t, const F& f) {
  _convenience::for_each_helper(t, f, std::index_sequence_for<Ts...>{});
}
template<typename... Ts, typename F>
inline void for_each(const std::tuple<Ts...>& t, F& f) {
  _convenience::for_each_helper(t, f, std::index_sequence_for<Ts...>{});
}
template<typename... Ts, typename F>
inline void for_each(std::tuple<Ts...>& t, F& f) {
  _convenience::for_each_helper(t, f, std::index_sequence_for<Ts...>{});
}
}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
# 1 "/usr/include/c++/10/stdlib.h" 1 3
# 36 "/usr/include/c++/10/stdlib.h" 3
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 37 "/usr/include/c++/10/stdlib.h" 2 3


# 38 "/usr/include/c++/10/stdlib.h" 3
using std::abort;
using std::atexit;
using std::exit;


  using std::at_quick_exit;


  using std::quick_exit;




using std::div_t;
using std::ldiv_t;

using std::abs;
using std::atof;
using std::atoi;
using std::atol;
using std::bsearch;
using std::calloc;
using std::div;
using std::free;
using std::getenv;
using std::labs;
using std::ldiv;
using std::malloc;

using std::mblen;
using std::mbstowcs;
using std::mbtowc;

using std::qsort;
using std::rand;
using std::realloc;
using std::srand;
using std::strtod;
using std::strtol;
using std::strtoul;
using std::system;

using std::wcstombs;
using std::wctomb;
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2

# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2






# 1 "/usr/include/sys/uio.h" 1 3 4
# 23 "/usr/include/sys/uio.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/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 24 "/usr/include/bits/types/struct_iovec.h" 2 3 4


struct iovec
  {
    void *iov_base;
    size_t iov_len;
  };
# 24 "/usr/include/sys/uio.h" 2 3 4







extern "C" {
# 41 "/usr/include/sys/uio.h" 3 4
extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
  __attribute__ ((__warn_unused_result__));
# 52 "/usr/include/sys/uio.h" 3 4
extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
  __attribute__ ((__warn_unused_result__));
# 84 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "preadv64")

                __attribute__ ((__warn_unused_result__));
extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "pwritev64")

                 __attribute__ ((__warn_unused_result__));
# 106 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
    __off64_t __offset) __attribute__ ((__warn_unused_result__));
# 118 "/usr/include/sys/uio.h" 3 4
extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
     __off64_t __offset) __attribute__ ((__warn_unused_result__));
# 136 "/usr/include/sys/uio.h" 3 4
extern ssize_t pwritev2 (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset, int __flags) __asm__ ("" "pwritev64v2")


                   __attribute__ ((__warn_unused_result__));
extern ssize_t preadv2 (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset, int __flags) __asm__ ("" "preadv64v2")


                  __attribute__ ((__warn_unused_result__));
# 152 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv64v2 (int __fp, const struct iovec *__iovec,
      int __count, __off64_t __offset,
      int ___flags) __attribute__ ((__warn_unused_result__));


extern ssize_t pwritev64v2 (int __fd, const struct iovec *__iodev,
       int __count, __off64_t __offset,
       int __flags) __attribute__ ((__warn_unused_result__));



}




# 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)
  throw ();


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)
  throw ();
# 51 "/usr/include/bits/uio-ext.h" 3 4
}
# 169 "/usr/include/sys/uio.h" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2


# 1 "/usr/include/malloc.h" 1 3 4
# 23 "/usr/include/malloc.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 24 "/usr/include/malloc.h" 2 3 4
# 35 "/usr/include/malloc.h" 3 4
extern "C" {


extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__))
     __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_result__));


extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) __attribute__ ((__warn_unused_result__));






extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));






extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2, 3)));


extern void free (void *__ptr) throw ();


extern void *memalign (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) __attribute__ ((__warn_unused_result__));


extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__))
     __attribute__ ((__alloc_size__ (1))) __attribute__ ((__warn_unused_result__));



extern void *pvalloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));



extern void *(*__morecore) (ptrdiff_t __size);


extern void *__default_morecore (ptrdiff_t __size)
throw () __attribute__ ((__malloc__));



struct mallinfo
{
  int arena;
  int ordblks;
  int smblks;
  int hblks;
  int hblkhd;
  int usmblks;
  int fsmblks;
  int uordblks;
  int fordblks;
  int keepcost;
};


extern struct mallinfo mallinfo (void) throw ();
# 128 "/usr/include/malloc.h" 3 4
extern int mallopt (int __param, int __val) throw ();



extern int malloc_trim (size_t __pad) throw ();



extern size_t malloc_usable_size (void *__ptr) throw ();


extern void malloc_stats (void) throw ();


extern int malloc_info (int __options, FILE *__fp) throw ();


extern void (*volatile __free_hook) (void *__ptr,
                                                   const void *)
__attribute__ ((__deprecated__));
extern void *(*volatile __malloc_hook)(size_t __size,
                                                     const void *)
__attribute__ ((__deprecated__));
extern void *(*volatile __realloc_hook)(void *__ptr,
                                                      size_t __size,
                                                      const void *)
__attribute__ ((__deprecated__));
extern void *(*volatile __memalign_hook)(size_t __alignment,
                                                       size_t __size,
                                                       const void *)
__attribute__ ((__deprecated__));
extern void (*volatile __after_morecore_hook) (void);


}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2







# 1 "/usr/include/sys/mman.h" 1 3 4
# 25 "/usr/include/sys/mman.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 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
# 31 "/usr/include/bits/mman.h" 3 4
# 1 "/usr/include/bits/mman-map-flags-generic.h" 1 3 4
# 32 "/usr/include/bits/mman.h" 2 3 4


# 1 "/usr/include/bits/mman-linux.h" 1 3 4
# 113 "/usr/include/bits/mman-linux.h" 3 4
# 1 "/usr/include/bits/mman-shared.h" 1 3 4
# 46 "/usr/include/bits/mman-shared.h" 3 4
extern "C" {



int memfd_create (const char *__name, unsigned int __flags) throw ();



int mlock2 (const void *__addr, size_t __length, unsigned int __flags) throw ();





int pkey_alloc (unsigned int __flags, unsigned int __access_rights) throw ();



int pkey_set (int __key, unsigned int __access_rights) throw ();



int pkey_get (int __key) throw ();



int pkey_free (int __key) throw ();



int pkey_mprotect (void *__addr, size_t __len, int __prot, int __pkey) throw ();

}
# 114 "/usr/include/bits/mman-linux.h" 2 3 4
# 35 "/usr/include/bits/mman.h" 2 3 4
# 42 "/usr/include/sys/mman.h" 2 3 4




extern "C" {
# 61 "/usr/include/sys/mman.h" 3 4
extern void * mmap (void *__addr, size_t __len, int __prot, int __flags, int __fd, __off64_t __offset) throw () __asm__ ("" "mmap64")


                ;





extern void *mmap64 (void *__addr, size_t __len, int __prot,
       int __flags, int __fd, __off64_t __offset) throw ();




extern int munmap (void *__addr, size_t __len) throw ();




extern int mprotect (void *__addr, size_t __len, int __prot) throw ();







extern int msync (void *__addr, size_t __len, int __flags);




extern int madvise (void *__addr, size_t __len, int __advice) throw ();



extern int posix_madvise (void *__addr, size_t __len, int __advice) throw ();




extern int mlock (const void *__addr, size_t __len) throw ();


extern int munlock (const void *__addr, size_t __len) throw ();




extern int mlockall (int __flags) throw ();



extern int munlockall (void) throw ();







extern int mincore (void *__start, size_t __len, unsigned char *__vec)
     throw ();
# 133 "/usr/include/sys/mman.h" 3 4
extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
       int __flags, ...) throw ();



extern int remap_file_pages (void *__start, size_t __size, int __prot,
        size_t __pgoff, int __flags) throw ();




extern int shm_open (const char *__name, int __oflag, mode_t __mode);


extern int shm_unlink (const char *__name);

}
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2



# 1 "/usr/include/c++/10/iomanip" 1 3
# 36 "/usr/include/c++/10/iomanip" 3
       
# 37 "/usr/include/c++/10/iomanip" 3
# 45 "/usr/include/c++/10/iomanip" 3
# 1 "/usr/include/c++/10/bits/quoted_string.h" 1 3
# 33 "/usr/include/c++/10/bits/quoted_string.h" 3
       
# 34 "/usr/include/c++/10/bits/quoted_string.h" 3






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


  namespace __detail {



    template<typename _String, typename _CharT>
      struct _Quoted_string
      {
 static_assert(is_reference<_String>::value
     || is_pointer<_String>::value,
        "String type must be pointer or reference");

 _Quoted_string(_String __str, _CharT __del, _CharT __esc)
 : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
 { }

 _Quoted_string&
 operator=(_Quoted_string&) = delete;

 _String _M_string;
 _CharT _M_delim;
 _CharT _M_escape;
      };


    template<typename _CharT, typename _Traits>
      struct _Quoted_string<basic_string_view<_CharT, _Traits>, _CharT>
      {
 _Quoted_string(basic_string_view<_CharT, _Traits> __str,
         _CharT __del, _CharT __esc)
 : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
 { }

 _Quoted_string&
 operator=(_Quoted_string&) = delete;

 basic_string_view<_CharT, _Traits> _M_string;
 _CharT _M_delim;
 _CharT _M_escape;
      };
# 91 "/usr/include/c++/10/bits/quoted_string.h" 3
    template<typename _CharT, typename _Traits>
      std::basic_ostream<_CharT, _Traits>&
      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
   const _Quoted_string<const _CharT*, _CharT>& __str)
      {
 std::basic_ostringstream<_CharT, _Traits> __ostr;
 __ostr << __str._M_delim;
 for (const _CharT* __c = __str._M_string; *__c; ++__c)
   {
     if (*__c == __str._M_delim || *__c == __str._M_escape)
       __ostr << __str._M_escape;
     __ostr << *__c;
   }
 __ostr << __str._M_delim;

 return __os << __ostr.str();
      }







    template<typename _CharT, typename _Traits, typename _String>
      std::basic_ostream<_CharT, _Traits>&
      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
   const _Quoted_string<_String, _CharT>& __str)
      {
 std::basic_ostringstream<_CharT, _Traits> __ostr;
 __ostr << __str._M_delim;
 for (auto __c : __str._M_string)
   {
     if (__c == __str._M_delim || __c == __str._M_escape)
       __ostr << __str._M_escape;
     __ostr << __c;
   }
 __ostr << __str._M_delim;

 return __os << __ostr.str();
      }





    template<typename _CharT, typename _Traits, typename _Alloc>
      std::basic_istream<_CharT, _Traits>&
      operator>>(std::basic_istream<_CharT, _Traits>& __is,
   const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
          _CharT>& __str)
      {
 _CharT __c;
 __is >> __c;
 if (!__is.good())
   return __is;
 if (__c != __str._M_delim)
   {
     __is.unget();
     __is >> __str._M_string;
     return __is;
   }
 __str._M_string.clear();
 std::ios_base::fmtflags __flags
   = __is.flags(__is.flags() & ~std::ios_base::skipws);
 do
   {
     __is >> __c;
     if (!__is.good())
       break;
     if (__c == __str._M_escape)
       {
  __is >> __c;
  if (!__is.good())
    break;
       }
     else if (__c == __str._M_delim)
       break;
     __str._M_string += __c;
   }
 while (true);
 __is.setf(__flags);

 return __is;
      }
  }


}
# 46 "/usr/include/c++/10/iomanip" 2 3



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





  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
# 65 "/usr/include/c++/10/iomanip" 3
  inline _Resetiosflags
  resetiosflags(ios_base::fmtflags __mask)
  { return { __mask }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
    {
      __is.setf(ios_base::fmtflags(0), __f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
    {
      __os.setf(ios_base::fmtflags(0), __f._M_mask);
      return __os;
    }


  struct _Setiosflags { ios_base::fmtflags _M_mask; };
# 95 "/usr/include/c++/10/iomanip" 3
  inline _Setiosflags
  setiosflags(ios_base::fmtflags __mask)
  { return { __mask }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
    {
      __is.setf(__f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
    {
      __os.setf(__f._M_mask);
      return __os;
    }


  struct _Setbase { int _M_base; };
# 126 "/usr/include/c++/10/iomanip" 3
  inline _Setbase
  setbase(int __base)
  { return { __base }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
    {
      __is.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
    {
      __os.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __os;
    }


  template<typename _CharT>
    struct _Setfill { _CharT _M_c; };
# 163 "/usr/include/c++/10/iomanip" 3
  template<typename _CharT>
    inline _Setfill<_CharT>
    setfill(_CharT __c)
    { return { __c }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
    {
      __is.fill(__f._M_c);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
    {
      __os.fill(__f._M_c);
      return __os;
    }


  struct _Setprecision { int _M_n; };
# 194 "/usr/include/c++/10/iomanip" 3
  inline _Setprecision
  setprecision(int __n)
  { return { __n }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
    {
      __is.precision(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
    {
      __os.precision(__f._M_n);
      return __os;
    }


  struct _Setw { int _M_n; };
# 224 "/usr/include/c++/10/iomanip" 3
  inline _Setw
  setw(int __n)
  { return { __n }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
    {
      __is.width(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
    {
      __os.width(__f._M_n);
      return __os;
    }



  template<typename _MoneyT>
    struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
# 257 "/usr/include/c++/10/iomanip" 3
  template<typename _MoneyT>
    inline _Get_money<_MoneyT>
    get_money(_MoneyT& __mon, bool __intl = false)
    { return { __mon, __intl }; }

  template<typename _CharT, typename _Traits, typename _MoneyT>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
    {
      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       typedef istreambuf_iterator<_CharT, _Traits> _Iter;
       typedef money_get<_CharT, _Iter> _MoneyGet;

       const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
       __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
         __is, __err, __f._M_mon);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __is._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __is._M_setstate(ios_base::badbit); }
   if (__err)
     __is.setstate(__err);
 }
      return __is;
    }


  template<typename _MoneyT>
    struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
# 304 "/usr/include/c++/10/iomanip" 3
  template<typename _MoneyT>
    inline _Put_money<_MoneyT>
    put_money(const _MoneyT& __mon, bool __intl = false)
    { return { __mon, __intl }; }

  template<typename _CharT, typename _Traits, typename _MoneyT>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
    {
      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
       typedef money_put<_CharT, _Iter> _MoneyPut;

       const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
       if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
      __os.fill(), __f._M_mon).failed())
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __os._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __os._M_setstate(ios_base::badbit); }
   if (__err)
     __os.setstate(__err);
 }
      return __os;
    }

  template<typename _CharT>
    struct _Put_time
    {
      const std::tm* _M_tmb;
      const _CharT* _M_fmt;
    };
# 356 "/usr/include/c++/10/iomanip" 3
  template<typename _CharT>
    inline _Put_time<_CharT>
    put_time(const std::tm* __tmb, const _CharT* __fmt)
    { return { __tmb, __fmt }; }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f)
    {
      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
              typedef time_put<_CharT, _Iter> _TimePut;

              const _CharT* const __fmt_end = __f._M_fmt +
                _Traits::length(__f._M_fmt);

              const _TimePut& __mp = use_facet<_TimePut>(__os.getloc());
              if (__mp.put(_Iter(__os.rdbuf()), __os, __os.fill(),
                           __f._M_tmb, __f._M_fmt, __fmt_end).failed())
                __err |= ios_base::badbit;
            }
          catch(__cxxabiv1::__forced_unwind&)
            {
              __os._M_setstate(ios_base::badbit);
              throw;
            }
          catch(...)
            { __os._M_setstate(ios_base::badbit); }
          if (__err)
            __os.setstate(__err);
        }
      return __os;
    }

  template<typename _CharT>
    struct _Get_time
    {
      std::tm* _M_tmb;
      const _CharT* _M_fmt;
    };
# 411 "/usr/include/c++/10/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;
    }
# 459 "/usr/include/c++/10/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);
    }
# 508 "/usr/include/c++/10/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);




}
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/page.h" 1




# 4 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/page.h"
namespace ceph {

  extern unsigned _page_size;
  extern unsigned long _page_mask;
  extern unsigned _page_shift;
}
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/crc32c.h" 1






extern "C" {


typedef uint32_t (*ceph_crc32c_func_t)(uint32_t crc, unsigned char const *data, unsigned length);





extern ceph_crc32c_func_t ceph_crc32c_func;

extern ceph_crc32c_func_t ceph_choose_crc32(void);
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/crc32c.h"
uint32_t ceph_crc32c_zeros(uint32_t crc, unsigned length);
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/crc32c.h"
static inline uint32_t ceph_crc32c(uint32_t crc, unsigned char const *data, unsigned length)
{

  if (!data && length > 16)
    return ceph_crc32c_zeros(crc, length);


  return ceph_crc32c_func(crc, data, length);
}


}
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer_fwd.h" 1



namespace ceph {
  namespace buffer {
    inline namespace v14_2_0 {
      class ptr;
      class list;
    }
    class hash;
  }

  using bufferptr = buffer::ptr;
  using bufferlist = buffer::list;
  using bufferhash = buffer::hash;
}
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/inline_memory.h" 1
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/inline_memory.h"
static inline void *maybe_inline_memcpy(void *dest, const void *src, size_t l,
           size_t inline_len)
  __attribute__((always_inline));

void *maybe_inline_memcpy(void *dest, const void *src, size_t l,
    size_t inline_len)
{
  if (l > inline_len) {
    return memcpy(dest, src, l);
  }
  switch (l) {
  case 8:
    return __builtin_memcpy(dest, src, 8);
  case 4:
    return __builtin_memcpy(dest, src, 4);
  case 3:
    return __builtin_memcpy(dest, src, 3);
  case 2:
    return __builtin_memcpy(dest, src, 2);
  case 1:
    return __builtin_memcpy(dest, src, 1);
  default:
    int cursor = 0;
    while (l >= sizeof(uint64_t)) {
      __builtin_memcpy((char*)dest + cursor, (char*)src + cursor,
         sizeof(uint64_t));
      cursor += sizeof(uint64_t);
      l -= sizeof(uint64_t);
    }
    while (l >= sizeof(uint32_t)) {
      __builtin_memcpy((char*)dest + cursor, (char*)src + cursor,
         sizeof(uint32_t));
      cursor += sizeof(uint32_t);
      l -= sizeof(uint32_t);
    }
    while (l > 0) {
      *((char*)dest + cursor) = *((char*)src + cursor);
      cursor++;
      l--;
    }
  }
  return dest;
}
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/inline_memory.h"
namespace ceph {
typedef unsigned uint128_t __attribute__ ((mode (TI)));
}
using ceph::uint128_t;

static inline bool mem_is_zero(const char *data, size_t len)
  __attribute__((always_inline));

bool mem_is_zero(const char *data, size_t len)
{


  if (len / sizeof(uint128_t) > 0) {



    while (((unsigned long long)data) & 15) {
      if (*(uint8_t*)data != 0) {
 return false;
      }
      data += sizeof(uint8_t);
      --len;
    }

    const char* data_start = data;
    const char* max128 = data + (len / sizeof(uint128_t))*sizeof(uint128_t);

    while (data < max128) {
      if (*(uint128_t*)data != 0) {
 return false;
      }
      data += sizeof(uint128_t);
    }
    len -= (data - data_start);
  }

  const char* max = data + len;
  const char* max32 = data + (len / sizeof(uint32_t))*sizeof(uint32_t);
  while (data < max32) {
    if (*(uint32_t*)data != 0) {
      return false;
    }
    data += sizeof(uint32_t);
  }
  while (data < max) {
    if (*(uint8_t*)data != 0) {
      return false;
    }
    data += sizeof(uint8_t);
  }
  return true;
}
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 2
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
class deleter;
template<uint8_t S>
struct sha_digest_t;
using sha1_digest_t = sha_digest_t<20>;

namespace ceph {

template <class T>
struct nop_delete {
  void operator()(T*) {}
};
# 101 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
template <class T>
struct unique_leakable_ptr : public std::unique_ptr<T, ceph::nop_delete<T>> {
  using std::unique_ptr<T, ceph::nop_delete<T>>::unique_ptr;
};

namespace buffer {
inline namespace v14_2_0 {





  struct error : public std::exception{
    const char *what() const throw () override;
  };
  struct bad_alloc : public error {
    const char *what() const throw () override;
  };
  struct end_of_buffer : public error {
    const char *what() const throw () override;
  };
  struct malformed_input : public error {
    explicit malformed_input(const std::string& w) {
      snprintf(buf, sizeof(buf), "buffer::malformed_input: %s", w.c_str());
    }
    const char *what() const throw () override;
  private:
    char buf[256];
  };
  struct error_code : public malformed_input {
    explicit error_code(int error);
    int code;
  };



  int get_cached_crc();

  int get_cached_crc_adjusted();

  int get_missed_crc();

  void track_cached_crc(bool b);




  class raw;
  class raw_malloc;
  class raw_static;
  class raw_posix_aligned;
  class raw_hack_aligned;
  class raw_char;
  class raw_claimed_char;
  class raw_unshareable;
  class raw_combined;
  class raw_claim_buffer;


  class xio_mempool;
  class xio_msg_buffer;




  ceph::unique_leakable_ptr<raw> copy(const char *c, unsigned len);
  ceph::unique_leakable_ptr<raw> create(unsigned len);
  ceph::unique_leakable_ptr<raw> create_in_mempool(unsigned len, int mempool);
  raw* claim_char(unsigned len, char *buf);
  raw* create_malloc(unsigned len);
  raw* claim_malloc(unsigned len, char *buf);
  raw* create_static(unsigned len, char *buf);
  ceph::unique_leakable_ptr<raw> create_aligned(unsigned len, unsigned align);
  ceph::unique_leakable_ptr<raw> create_aligned_in_mempool(unsigned len, unsigned align, int mempool);
  ceph::unique_leakable_ptr<raw> create_page_aligned(unsigned len);
  ceph::unique_leakable_ptr<raw> create_small_page_aligned(unsigned len);
  raw* create_unshareable(unsigned len);
  raw* create_static(unsigned len, char *buf);
  raw* claim_buffer(unsigned len, char *buf, deleter del);
# 197 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
  class ptr {
    raw *_raw;
  public:
    unsigned _off, _len;
  private:

    void release();

    template<bool is_const>
    class iterator_impl {
      const ptr *bp;
      const char *start;
      const char *pos;
      const char *end_ptr;
      const bool deep;

      iterator_impl(typename std::conditional<is_const, const ptr*, ptr*>::type p,
      size_t offset, bool d)
 : bp(p),
   start(p->c_str() + offset),
   pos(start),
   end_ptr(p->end_c_str()),
   deep(d)
      {}

      friend class ptr;

    public:
      using pointer = typename std::conditional<is_const, const char*, char *>::type;
      pointer get_pos_add(size_t n) {
 auto r = pos;
 advance(n);
 return r;
      }
      ptr get_ptr(size_t len) {
 if (deep) {
   return buffer::copy(get_pos_add(len), len);
 } else {
   size_t off = pos - bp->c_str();
   advance(len);
   return ptr(*bp, off, len);
 }
      }

      void advance(size_t len) {
 pos += len;
 if (pos > end_ptr)
   throw end_of_buffer();
      }

      const char *get_pos() {
 return pos;
      }
      const char *get_end() {
 return end_ptr;
      }

      size_t get_offset() {
 return pos - start;
      }

      bool end() const {
 return pos == end_ptr;
      }
    };

  public:
    using const_iterator = iterator_impl<true>;
    using iterator = iterator_impl<false>;

    ptr() : _raw(nullptr), _off(0), _len(0) {}

    ptr(raw* r);
    ptr(ceph::unique_leakable_ptr<raw> r);

    ptr(unsigned l);
    ptr(const char *d, unsigned l);
    ptr(const ptr& p);
    ptr(ptr&& p) noexcept;
    ptr(const ptr& p, unsigned o, unsigned l);
    ptr(const ptr& p, ceph::unique_leakable_ptr<raw> r);
    ptr& operator= (const ptr& p);
    ptr& operator= (ptr&& p) noexcept;
    ~ptr() {


      release();
    }

    bool have_raw() const { return _raw ? true:false; }

    ceph::unique_leakable_ptr<raw> clone();
    void swap(ptr& other) noexcept;

    iterator begin(size_t offset=0) {
      return iterator(this, offset, false);
    }
    const_iterator begin(size_t offset=0) const {
      return const_iterator(this, offset, false);
    }
    const_iterator cbegin() const {
      return begin();
    }
    const_iterator begin_deep(size_t offset=0) const {
      return const_iterator(this, offset, true);
    }


    bool is_aligned(unsigned align) const {
      return ((long)c_str() & (align-1)) == 0;
    }
    bool is_page_aligned() const { return is_aligned(ceph::_page_size); }
    bool is_n_align_sized(unsigned align) const
    {
      return (length() % align) == 0;
    }
    bool is_n_page_sized() const { return is_n_align_sized(ceph::_page_size); }
    bool is_partial() const {
      return have_raw() && (start() > 0 || end() < raw_length());
    }

    int get_mempool() const;
    void reassign_to_mempool(int pool);
    void try_assign_to_mempool(int pool);


    raw *get_raw() const { return _raw; }
    const char *c_str() const;
    char *c_str();
    const char *end_c_str() const;
    char *end_c_str();
    unsigned length() const { return _len; }
    unsigned offset() const { return _off; }
    unsigned start() const { return _off; }
    unsigned end() const { return _off + _len; }
    unsigned unused_tail_length() const;
    const char& operator[](unsigned n) const;
    char& operator[](unsigned n);

    const char *raw_c_str() const;
    unsigned raw_length() const;
    int raw_nref() const;

    void copy_out(unsigned o, unsigned l, char *dest) const;

    unsigned wasted() const;

    int cmp(const ptr& o) const;
    bool is_zero() const;


    void set_offset(unsigned o) {

      do { static const ceph::assert_data assert_data_ctx = {"raw_length() >= o", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h", 350, __PRETTY_FUNCTION__}; ((raw_length() >= o) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);



      _off = o;
    }
    void set_length(unsigned l) {

      do { static const ceph::assert_data assert_data_ctx = {"raw_length() >= l", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h", 358, __PRETTY_FUNCTION__}; ((raw_length() >= l) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);



      _len = l;
    }

    unsigned append(char c);
    unsigned append(const char *p, unsigned l);

    inline unsigned append(std::string_view s) {
      return append(s.data(), s.length());
    }

    void copy_in(unsigned o, unsigned l, const char *src, bool crc_reset = true);
    void zero(bool crc_reset = true);
    void zero(unsigned o, unsigned l, bool crc_reset = true);
    unsigned append_zeros(unsigned l);
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
  };


  struct ptr_hook {
    mutable ptr_hook* next;

    ptr_hook() = default;
    ptr_hook(ptr_hook* const next)
      : next(next) {
    }
  };

  class ptr_node : public ptr_hook, public ptr {
  public:
    struct cloner {
      ptr_node* operator()(const ptr_node& clone_this);
    };
    struct disposer {
      void operator()(ptr_node* const delete_this) {
 if (!dispose_if_hypercombined(delete_this)) {
   delete delete_this;
 }
      }
    };

    ~ptr_node() = default;

    static std::unique_ptr<ptr_node, disposer>
    create(ceph::unique_leakable_ptr<raw> r) {
      return create_hypercombined(std::move(r));
    }
    static std::unique_ptr<ptr_node, disposer> create(raw* const r) {
      return create_hypercombined(r);
    }
    static std::unique_ptr<ptr_node, disposer> create(const unsigned l) {
      return create_hypercombined(buffer::create(l));
    }
    template <class... Args>
    static std::unique_ptr<ptr_node, disposer> create(Args&&... args) {
      return std::unique_ptr<ptr_node, disposer>(
 new ptr_node(std::forward<Args>(args)...));
    }

    static ptr_node* copy_hypercombined(const ptr_node& copy_this);

  private:
    template <class... Args>
    ptr_node(Args&&... args) : ptr(std::forward<Args>(args)...) {
    }
    ptr_node(const ptr_node&) = default;

    ptr& operator= (const ptr& p) = delete;
    ptr& operator= (ptr&& p) noexcept = delete;
    ptr_node& operator= (const ptr_node& p) = delete;
    ptr_node& operator= (ptr_node&& p) noexcept = delete;
    void swap(ptr& other) noexcept = delete;
    void swap(ptr_node& other) noexcept = delete;

    static bool dispose_if_hypercombined(ptr_node* delete_this);
    static std::unique_ptr<ptr_node, disposer> create_hypercombined(
      buffer::raw* r);
    static std::unique_ptr<ptr_node, disposer> create_hypercombined(
      ceph::unique_leakable_ptr<raw> r);
  };




  class list {
  public:




    class buffers_t {

      ptr_hook _root;
      ptr_hook* _tail;
      std::size_t _size;

    public:
      template <class T>
      class buffers_iterator {
 typename std::conditional<
   std::is_const<T>::value, const ptr_hook*, ptr_hook*>::type cur;
 template <class U> friend class buffers_iterator;
      public:
 using value_type = T;
 using reference = typename std::add_lvalue_reference<T>::type;
 using pointer = typename std::add_pointer<T>::type;
 using difference_type = std::ptrdiff_t;
 using iterator_category = std::forward_iterator_tag;

 template <class U>
 buffers_iterator(U* const p)
   : cur(p) {
 }
 template <class U>
 buffers_iterator(const buffers_iterator<U>& other)
   : cur(other.cur) {
 }
 buffers_iterator() = default;

 T& operator*() const {
   return *reinterpret_cast<T*>(cur);
 }
 T* operator->() const {
   return reinterpret_cast<T*>(cur);
 }

 buffers_iterator& operator++() {
   cur = cur->next;
   return *this;
 }
 buffers_iterator operator++(int) {
   const auto temp(*this);
   ++*this;
   return temp;
 }

 template <class U>
 buffers_iterator& operator=(buffers_iterator<U>& other) {
   cur = other.cur;
   return *this;
 }

 bool operator==(const buffers_iterator& rhs) const {
   return cur == rhs.cur;
 }
 bool operator!=(const buffers_iterator& rhs) const {
   return !(*this==rhs);
 }

 using citer_t = buffers_iterator<typename std::add_const<T>::type>;
 operator citer_t() const {
   return citer_t(cur);
 }
      };

      typedef buffers_iterator<const ptr_node> const_iterator;
      typedef buffers_iterator<ptr_node> iterator;

      typedef const ptr_node& const_reference;
      typedef ptr_node& reference;

      buffers_t()
        : _root(&_root),
   _tail(&_root),
   _size(0) {
      }
      buffers_t(const buffers_t&) = delete;
      buffers_t(buffers_t&& other)
 : _root(other._root.next == &other._root ? &_root : other._root.next),
   _tail(other._tail == &other._root ? &_root : other._tail),
   _size(other._size) {
 other._root.next = &other._root;
 other._tail = &other._root;
 other._size = 0;

 _tail->next = &_root;
      }
      buffers_t& operator=(buffers_t&& other) {
 if (&other != this) {
   clear_and_dispose();
   swap(other);
 }
 return *this;
      }

      void push_back(reference item) {
 item.next = &_root;

 _tail->next = &item;
 _tail = &item;
 _size++;
      }

      void push_front(reference item) {
 item.next = _root.next;
 _root.next = &item;
 _tail = _tail == &_root ? &item : _tail;
 _size++;
      }


      iterator erase_after(const_iterator it) {
 const auto* to_erase = it->next;

 it->next = to_erase->next;
 _root.next = _root.next == to_erase ? to_erase->next : _root.next;
 _tail = _tail == to_erase ? (ptr_hook*)&*it : _tail;
 _size--;
 return it->next;
      }

      void insert_after(const_iterator it, reference item) {
 item.next = it->next;
 it->next = &item;
 _root.next = it == end() ? &item : _root.next;
 _tail = const_iterator(_tail) == it ? &item : _tail;
 _size++;
      }

      void splice_back(buffers_t& other) {
 if (other._size == 0) {
   return;
 }

 other._tail->next = &_root;

 _tail->next = other._root.next;
 _tail = other._tail;
 _size += other._size;

 other._root.next = &other._root;
 other._tail = &other._root;
 other._size = 0;
      }

      std::size_t size() const { return _size; }
      bool empty() const { return _tail == &_root; }

      const_iterator begin() const {
 return _root.next;
      }
      const_iterator before_begin() const {
 return &_root;
      }
      const_iterator end() const {
 return &_root;
      }
      iterator begin() {
 return _root.next;
      }
      iterator before_begin() {
 return &_root;
      }
      iterator end() {
 return &_root;
      }

      reference front() {
 return reinterpret_cast<reference>(*_root.next);
      }
      reference back() {
 return reinterpret_cast<reference>(*_tail);
      }
      const_reference front() const {
 return reinterpret_cast<const_reference>(*_root.next);
      }
      const_reference back() const {
 return reinterpret_cast<const_reference>(*_tail);
      }

      void clone_from(const buffers_t& other) {
 clear_and_dispose();
 for (auto& node : other) {
   ptr_node* clone = ptr_node::cloner()(node);
   push_back(*clone);
 }
      }
      void clear_and_dispose() {
 for (auto it = begin(); it != end(); ) {
   auto& node = *it;
   it = it->next;
   ptr_node::disposer()(&node);
 }
 _root.next = &_root;
 _tail = &_root;
 _size = 0;
      }
      iterator erase_after_and_dispose(iterator it) {
 auto* to_dispose = &*std::next(it);
 auto ret = erase_after(it);
 ptr_node::disposer()(to_dispose);
 return ret;
      }

      void swap(buffers_t& other) {
 const auto copy_root = _root;
 _root.next =
   other._root.next == &other._root ? &this->_root : other._root.next;
 other._root.next =
   copy_root.next == &_root ? &other._root : copy_root.next;

 const auto copy_tail = _tail;
 _tail = other._tail == &other._root ? &this->_root : other._tail;
 other._tail = copy_tail == &_root ? &other._root : copy_tail;

 _tail->next = &_root;
 other._tail->next = &other._root;
 std::swap(_size, other._size);
      }
    };

    class iterator;

  private:

    buffers_t _buffers;




    ptr* _carriage;
    unsigned _len;
    unsigned _memcopy_count;

    template <bool is_const>
    class iterator_impl {
    protected:
      typedef typename std::conditional<is_const,
     const list,
     list>::type bl_t;
      typedef typename std::conditional<is_const,
     const buffers_t,
     buffers_t >::type list_t;
      typedef typename std::conditional<is_const,
     typename buffers_t::const_iterator,
     typename buffers_t::iterator>::type list_iter_t;
      bl_t* bl;
      list_t* ls;
      list_iter_t p;
      unsigned off;
      unsigned p_off;
      friend class iterator_impl<true>;

    public:
      using iterator_category = std::forward_iterator_tag;
      using value_type = typename std::conditional<is_const, const char, char>::type;
      using difference_type = std::ptrdiff_t;
      using pointer = typename std::add_pointer<value_type>::type;
      using reference = typename std::add_lvalue_reference<value_type>::type;


      iterator_impl()
 : bl(0), ls(0), off(0), p_off(0) {}
      iterator_impl(bl_t *l, unsigned o=0);
      iterator_impl(bl_t *l, unsigned o, list_iter_t ip, unsigned po)
 : bl(l), ls(&bl->_buffers), p(ip), off(o), p_off(po) {}
      iterator_impl(const list::iterator& i);


      unsigned get_off() const { return off; }


      unsigned get_remaining() const { return bl->length() - off; }


      bool end() const {
 return p == ls->end();

      }

      void advance(int o) = delete;
      void advance(unsigned o);
      void advance(size_t o) { advance(static_cast<unsigned>(o)); }
      void seek(unsigned o);
      char operator*() const;
      iterator_impl& operator++();
      ptr get_current_ptr() const;
      bool is_pointing_same_raw(const ptr& other) const;

      bl_t& get_bl() const { return *bl; }



      void copy(unsigned len, char *dest);

      void copy(unsigned len, ptr &dest) __attribute__((deprecated));
      void copy_deep(unsigned len, ptr &dest);
      void copy_shallow(unsigned len, ptr &dest);
      void copy(unsigned len, list &dest);
      void copy(unsigned len, std::string &dest);
      void copy_all(list &dest);




      size_t get_ptr_and_advance(size_t want, const char **p);


      uint32_t crc32c(size_t length, uint32_t crc);

      friend bool operator==(const iterator_impl& lhs,
        const iterator_impl& rhs) {
 return &lhs.get_bl() == &rhs.get_bl() && lhs.get_off() == rhs.get_off();
      }
      friend bool operator!=(const iterator_impl& lhs,
        const iterator_impl& rhs) {
 return &lhs.get_bl() != &rhs.get_bl() || lhs.get_off() != rhs.get_off();
      }
    };

  public:
    typedef iterator_impl<true> const_iterator;

    class iterator : public iterator_impl<false> {
    public:
      iterator() = default;
      iterator(bl_t *l, unsigned o=0);
      iterator(bl_t *l, unsigned o, list_iter_t ip, unsigned po);

      void copy_in(unsigned len, const char *src, bool crc_reset = true);
      void copy_in(unsigned len, const list& otherl);
    };

    struct reserve_t {
      char* bp_data;
      unsigned* bp_len;
      unsigned* bl_len;
    };

    class contiguous_appender {
      ceph::bufferlist& bl;
      ceph::bufferlist::reserve_t space;
      char* pos;
      bool deep;


      size_t out_of_band_offset = 0;

      contiguous_appender(bufferlist& bl, size_t len, bool d)
 : bl(bl),
   space(bl.obtain_contiguous_space(len)),
   pos(space.bp_data),
   deep(d) {
      }

      void flush_and_continue() {
 const size_t l = pos - space.bp_data;
 *space.bp_len += l;
 *space.bl_len += l;
 space.bp_data = pos;
      }

      friend class list;

    public:
      ~contiguous_appender() {
 flush_and_continue();
      }

      size_t get_out_of_band_offset() const {
 return out_of_band_offset;
      }
      void append(const char* __restrict__ p, size_t l) {
 maybe_inline_memcpy(pos, p, l, 16);
 pos += l;
      }
      char *get_pos_add(size_t len) {
 char *r = pos;
 pos += len;
 return r;
      }
      char *get_pos() {
 return pos;
      }

      void append(const bufferptr& p) {
 const auto plen = p.length();
 if (!plen) {
   return;
 }
 if (deep) {
   append(p.c_str(), plen);
 } else {
   flush_and_continue();
   bl.append(p);
   space = bl.obtain_contiguous_space(0);
   out_of_band_offset += plen;
 }
      }
      void append(const bufferlist& l) {
 if (deep) {
   for (const auto &p : l._buffers) {
     append(p.c_str(), p.length());
   }
 } else {
   flush_and_continue();
   bl.append(l);
   space = bl.obtain_contiguous_space(0);
   out_of_band_offset += l.length();
 }
      }

      size_t get_logical_offset() {
 return out_of_band_offset + (pos - space.bp_data);
      }
    };

    contiguous_appender get_contiguous_appender(size_t len, bool deep=false) {
      return contiguous_appender(*this, len, deep);
    }

    class contiguous_filler {
      friend buffer::list;
      char* pos;

      contiguous_filler(char* const pos) : pos(pos) {}

    public:
      void advance(const unsigned len) {
 pos += len;
      }
      void copy_in(const unsigned len, const char* const src) {
 memcpy(pos, src, len);
 advance(len);
      }
      char* c_str() {
        return pos;
      }
    };


    static_assert(sizeof(contiguous_filler) == sizeof(char*),
    "contiguous_filler should be no costlier than pointer");

    class page_aligned_appender {
      bufferlist *pbl;
      unsigned min_alloc;
      ptr buffer;
      char *pos, *end;

      page_aligned_appender(list *l, unsigned min_pages)
 : pbl(l),
   min_alloc(min_pages * ceph::_page_size),
   pos(nullptr), end(nullptr) {}

      friend class list;

    public:
      ~page_aligned_appender() {
 flush();
      }

      void flush() {
 if (pos && pos != buffer.c_str()) {
   size_t len = pos - buffer.c_str();
   pbl->append(buffer, 0, len);
   buffer.set_length(buffer.length() - len);
   buffer.set_offset(buffer.offset() + len);
 }
      }

      void append(const char *buf, size_t len) {
 while (len > 0) {
   if (!pos) {
     size_t alloc = (len + ceph::_page_size - 1) & ceph::_page_mask;
     if (alloc < min_alloc) {
       alloc = min_alloc;
     }
     buffer = create_page_aligned(alloc);
     pos = buffer.c_str();
     end = buffer.end_c_str();
   }
   size_t l = len;
   if (l > (size_t)(end - pos)) {
     l = end - pos;
   }
   memcpy(pos, buf, l);
   pos += l;
   buf += l;
   len -= l;
   if (pos == end) {
     pbl->append(buffer, 0, buffer.length());
     pos = end = nullptr;
   }
 }
      }
    };

    page_aligned_appender get_page_aligned_appender(unsigned min_pages=1) {
      return page_aligned_appender(this, min_pages);
    }

  private:
    mutable iterator last_p;




    static ptr always_empty_bptr;
    ptr_node& refill_append_space(const unsigned len);

  public:

    list()
      : _carriage(&always_empty_bptr),
        _len(0),
        _memcopy_count(0),
        last_p(this) {
    }


    list(unsigned prealloc)
      : _carriage(&always_empty_bptr),
        _len(0),
        _memcopy_count(0),
 last_p(this) {
      reserve(prealloc);
    }

    list(const list& other)
      : _carriage(&always_empty_bptr),
        _len(other._len),
        _memcopy_count(other._memcopy_count),
        last_p(this) {
      _buffers.clone_from(other._buffers);
    }
    list(list&& other) noexcept;

    ~list() {
      _buffers.clear_and_dispose();
    }

    list& operator= (const list& other) {
      if (this != &other) {
        _carriage = &always_empty_bptr;
        _buffers.clone_from(other._buffers);
        _len = other._len;
      }
      return *this;
    }
    list& operator= (list&& other) noexcept {
      _buffers = std::move(other._buffers);
      _carriage = other._carriage;
      _len = other._len;
      _memcopy_count = other._memcopy_count;
      last_p = begin();
      other.clear();
      return *this;
    }

    uint64_t get_wasted_space() const;
    unsigned get_num_buffers() const { return _buffers.size(); }
    const ptr_node& front() const { return _buffers.front(); }
    const ptr_node& back() const { return _buffers.back(); }

    int get_mempool() const;
    void reassign_to_mempool(int pool);
    void try_assign_to_mempool(int pool);

    size_t get_append_buffer_unused_tail_length() const {
      return _carriage->unused_tail_length();
    }

    unsigned get_memcopy_count() const {return _memcopy_count; }
    const buffers_t& buffers() const { return _buffers; }
    void swap(list& other) noexcept;
    unsigned length() const {
# 1049 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
      return _len;
    }

    bool contents_equal(const buffer::list& other) const;

    bool is_provided_buffer(const char *dst) const;
    bool is_aligned(unsigned align) const;
    bool is_page_aligned() const;
    bool is_n_align_sized(unsigned align) const;
    bool is_n_page_sized() const;
    bool is_aligned_size_and_memory(unsigned align_size,
        unsigned align_memory) const;

    bool is_zero() const;


    void clear() noexcept {
      _carriage = &always_empty_bptr;
      _buffers.clear_and_dispose();
      _len = 0;
      _memcopy_count = 0;
      last_p = begin();
    }
    void push_back(const ptr& bp) {
      if (bp.length() == 0)
 return;
      _buffers.push_back(*ptr_node::create(bp).release());
      _len += bp.length();
    }
    void push_back(ptr&& bp) {
      if (bp.length() == 0)
 return;
      _len += bp.length();
      _buffers.push_back(*ptr_node::create(std::move(bp)).release());
      _carriage = &always_empty_bptr;
    }
    void push_back(const ptr_node&) = delete;
    void push_back(ptr_node&) = delete;
    void push_back(ptr_node&&) = delete;
    void push_back(std::unique_ptr<ptr_node, ptr_node::disposer> bp) {
      if (bp->length() == 0)
 return;
      _carriage = bp.get();
      _len += bp->length();
      _buffers.push_back(*bp.release());
    }
    void push_back(raw* const r) {
      _buffers.push_back(*ptr_node::create(r).release());
      _carriage = &_buffers.back();
      _len += _buffers.back().length();
    }
    void push_back(ceph::unique_leakable_ptr<raw> r) {
      push_back(r.release());
    }

    void zero();
    void zero(unsigned o, unsigned l);

    bool is_contiguous() const;
    void rebuild();
    void rebuild(std::unique_ptr<ptr_node, ptr_node::disposer> nb);
    bool rebuild_aligned(unsigned align);


    bool rebuild_aligned_size_and_memory(unsigned align_size,
      unsigned align_memory,
      unsigned max_buffers = 0);
    bool rebuild_page_aligned();

    void reserve(size_t prealloc);


    const static unsigned int CLAIM_DEFAULT = 0;
    const static unsigned int CLAIM_ALLOW_NONSHAREABLE = 1;

    void claim(list& bl, unsigned int flags = CLAIM_DEFAULT);
    void claim_append(list& bl, unsigned int flags = CLAIM_DEFAULT);

    void claim_append_piecewise(list& bl);


    void share(const list& bl)
    {
      if (this != &bl) {
        clear();
 for (const auto& bp : bl._buffers) {
          _buffers.push_back(*ptr_node::create(bp).release());
        }
        _len = bl._len;
      }
    }






    iterator begin() {
      return iterator(this, 0);
    }
    iterator end() {
      return iterator(this, _len, _buffers.end(), 0);
    }

    const_iterator begin() const {
      return const_iterator(this, 0);
    }
    const_iterator cbegin() const {
      return begin();
    }
    const_iterator end() const {
      return const_iterator(this, _len, _buffers.end(), 0);
    }



    void copy(unsigned off, unsigned len, char *dest) const;
    void copy(unsigned off, unsigned len, list &dest) const;
    void copy(unsigned off, unsigned len, std::string& dest) const;
    void copy_in(unsigned off, unsigned len, const char *src, bool crc_reset = true);
    void copy_in(unsigned off, unsigned len, const list& src);

    void append(char c);
    void append(const char *data, unsigned len);
    void append(std::string s) {
      append(s.data(), s.length());
    }



    template<std::size_t N>
    void append(const char (&s)[N]) {
      append(s, N);
    }
    void append(const char* s) {
      append(s, strlen(s));
    }
    void append(std::string_view s) {
      append(s.data(), s.length());
    }

    void append(const ptr& bp);
    void append(ptr&& bp);
    void append(const ptr& bp, unsigned off, unsigned len);
    void append(const list& bl);
    void append(std::istream& in);
    contiguous_filler append_hole(unsigned len);
    void append_zero(unsigned len);
    void prepend_zero(unsigned len);

    reserve_t obtain_contiguous_space(unsigned len);




    const char& operator[](unsigned n) const;
    char *c_str();
    std::string to_str() const;

    void substr_of(const list& other, unsigned off, unsigned len);


    void splice(unsigned off, unsigned len, list *claim_by=0 );
    void write(int off, int len, std::ostream& out) const;

    void encode_base64(list& o);
    void decode_base64(list& o);

    void write_stream(std::ostream &out) const;
    void hexdump(std::ostream &out, bool trailing_newline = true) const;
    int read_file(const char *fn, std::string *error);
    ssize_t read_fd(int fd, size_t len);
    int write_file(const char *fn, int mode=0644);
    int write_fd(int fd) const;
    int write_fd(int fd, uint64_t offset) const;
    template<typename VectorT>
    void prepare_iov(VectorT *piov) const {

      do { static const ceph::assert_data assert_data_ctx = {"_buffers.size() <= 1024", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h", 1227, __PRETTY_FUNCTION__}; ((_buffers.size() <= 
# 1227 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 3 4
     1024
# 1227 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h"
     ) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);



      piov->resize(_buffers.size());
      unsigned n = 0;
      for (auto& p : _buffers) {
 (*piov)[n].iov_base = (void *)p.c_str();
 (*piov)[n].iov_len = p.length();
 ++n;
      }
    }
    uint32_t crc32c(uint32_t crc) const;
    void invalidate_crc();
    sha1_digest_t sha1();




    static list static_from_mem(char* c, size_t l);
    static list static_from_cstring(char* c);
    static list static_from_string(std::string& s);
  };

}





  class hash {
    uint32_t crc;

  public:
    hash() : crc(0) { }

    hash(uint32_t init) : crc(init) { }

    void update(const buffer::list& bl) {
      crc = bl.crc32c(crc);
    }

    uint32_t digest() {
      return crc;
    }
  };

inline bool operator>(bufferlist& l, bufferlist& r) {
  for (unsigned p = 0; ; p++) {
    if (l.length() > p && r.length() == p) return true;
    if (l.length() == p) return false;
    if (l[p] > r[p]) return true;
    if (l[p] < r[p]) return false;
  }
}
inline bool operator>=(bufferlist& l, bufferlist& r) {
  for (unsigned p = 0; ; p++) {
    if (l.length() > p && r.length() == p) return true;
    if (r.length() == p && l.length() == p) return true;
    if (l.length() == p && r.length() > p) return false;
    if (l[p] > r[p]) return true;
    if (l[p] < r[p]) return false;
  }
}

inline bool operator==(const bufferlist &l, const bufferlist &r) {
  if (l.length() != r.length())
    return false;
  for (unsigned p = 0; p < l.length(); p++) {
    if (l[p] != r[p])
      return false;
  }
  return true;
}
inline bool operator<(bufferlist& l, bufferlist& r) {
  return r > l;
}
inline bool operator<=(bufferlist& l, bufferlist& r) {
  return r >= l;
}


std::ostream& operator<<(std::ostream& out, const buffer::ptr& bp);

std::ostream& operator<<(std::ostream& out, const buffer::raw &r);

std::ostream& operator<<(std::ostream& out, const buffer::list& bl);

std::ostream& operator<<(std::ostream& out, const buffer::error& e);

inline bufferhash& operator<<(bufferhash& l, const bufferlist &r) {
  l.update(r);
  return l;
}

}





}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 1
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h"
# 1 "/usr/include/c++/10/cstring" 1 3
# 39 "/usr/include/c++/10/cstring" 3
       
# 40 "/usr/include/c++/10/cstring" 3
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 2







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/minimal_pair_header.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/minimal_pair_header.hpp" 3 4
         
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 2 3 4




# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
namespace boost {
namespace tuples {

struct null_type;

template <
  class T0, class T1, class T2,
  class T3, class T4, class T5,
  class T6, class T7, class T8,
  class T9>
class tuple;

}
}

namespace boost {
namespace container {
namespace pair_impl {

template <class TupleClass>
struct is_boost_tuple
{
   static const bool value = false;
};

template <
  class T0, class T1, class T2,
  class T3, class T4, class T5,
  class T6, class T7, class T8,
  class T9>
struct is_boost_tuple< boost::tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
{
   static const bool value = true;
};

template<class Tuple>
struct disable_if_boost_tuple
   : boost::container::dtl::disable_if< is_boost_tuple<Tuple> >
{};

template<class T>
struct is_tuple_null
{
   static const bool value = false;
};

template<>
struct is_tuple_null<boost::tuples::null_type>
{
   static const bool value = true;
};

}}}
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
namespace boost {
namespace container {



   template <int Dummy = 0>
   struct std_piecewise_construct_holder
   {
      static ::std::piecewise_construct_t *dummy;
   };

   template <int Dummy>
   ::std::piecewise_construct_t *std_piecewise_construct_holder<Dummy>::dummy =
      reinterpret_cast< ::std::piecewise_construct_t *>(0x01234);

typedef const std::piecewise_construct_t & piecewise_construct_t;

struct try_emplace_t{};
# 132 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
static piecewise_construct_t piecewise_construct = *std_piecewise_construct_holder<>::dummy;



namespace dtl {

struct piecewise_construct_use
{

   piecewise_construct_use()
   { (void)&::boost::container::piecewise_construct; }
};

template <class T1, class T2>
struct pair;

template <class T>
struct is_pair
{
   static const bool value = false;
};

template <class T1, class T2>
struct is_pair< pair<T1, T2> >
{
   static const bool value = true;
};

template <class T1, class T2>
struct is_pair< std::pair<T1, T2> >
{
   static const bool value = true;
};

template <class T>
struct is_not_pair
{
   static const bool value = !is_pair<T>::value;
};

template <class T>
struct is_std_pair
{
   static const bool value = false;
};

template <class T1, class T2>
struct is_std_pair< std::pair<T1, T2> >
{
   static const bool value = true;
};

struct pair_nat;

template<typename T, typename U, typename V>
void get(T);



template <class T1, class T2>
struct pair
{
   private:
  

   public:
   typedef T1 first_type;
   typedef T2 second_type;

   T1 first;
   T2 second;


   pair()
      : first(), second()
   {}


   pair(const pair& x)
      : first(x.first), second(x.second)
   {}


   pair(pair && p)
      : first(::boost::move(p.first)), second(::boost::move(p.second))
   {}

   template <class D, class S>
   pair(const pair<D, S> &p)
      : first(p.first), second(p.second)
   {}

   template <class D, class S>
   pair( pair<D, S> && p)
      : first(::boost::move(p.first)), second(::boost::move(p.second))
   {}


   pair(const T1 &t1, const T2 &t2)
      : first(t1)
      , second(t2)
   {}

   template<class U, class V>
   pair(U && u, V && v)
      : first(::boost::forward<U>(u))
      , second(::boost::forward<V>(v))
   {}


   pair(const std::pair<T1, T2>& x)
      : first(x.first), second(x.second)
   {}

   template <class D, class S>
   pair(const std::pair<D, S>& p)
      : first(p.first), second(p.second)
   {}

   pair( std::pair<T1, T2> && p)
      : first(::boost::move(p.first)), second(::boost::move(p.second))
   {}

   template <class D, class S>
   pair( std::pair<D, S> && p)
      : first(::boost::move(p.first)), second(::boost::move(p.second))
   {}


   template< class KeyType, class ...Args>
   pair(try_emplace_t, KeyType && k, Args && ...args)
      : first(boost::forward<KeyType>(k)), second(::boost::forward<Args>(args)...)
   {}
# 294 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
   template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<void>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P0>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P1>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P2>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P3>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P4>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P5>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P6>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7 , ::boost::tuples::null_type, ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P7>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple< ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<void>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second() { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q0>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q1>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1, class Q2 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q2>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1, class Q2, class Q3 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q3>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1, class Q2, class Q3, class Q4 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q4>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q5>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6 , ::boost::tuples::null_type, ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q6>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7 , ::boost::tuples::null_type, ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q7>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>()) { (void)p; (void)q; } template< template<class, class, class, class, class, class, class, class, class, class> class BoostTuple , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8 , class Q0, class Q1, class Q2, class Q3, class Q4, class Q5, class Q6, class Q7, class Q8 > pair( piecewise_construct_t , BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> p , BoostTuple<Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7, Q8 , ::boost::tuples::null_type> q , typename dtl::enable_if_c < pair_impl::is_boost_tuple< BoostTuple<P0, P1, P2, P3, P4, P5, P6, P7, P8 , ::boost::tuples::null_type> >::value && !(pair_impl::is_tuple_null<P8>::value || pair_impl::is_tuple_null<Q8>::value) >::type* = 0 ) : first(p.template get<0>(), p.template get<1>(), p.template get<2>(), p.template get<3>(), p.template get<4>(), p.template get<5>(), p.template get<6>(), p.template get<7>(), p.template get<8>()), second(q.template get<0>(), q.template get<1>(), q.template get<2>(), q.template get<3>(), q.template get<4>(), q.template get<5>(), q.template get<6>(), q.template get<7>(), q.template get<8>()) { (void)p; (void)q; }





      private:
      template<template<class ...> class Tuple, class... Args1, class... Args2, size_t... Indexes1, size_t... Indexes2>
      pair(Tuple<Args1...>& t1, Tuple<Args2...>& t2, index_tuple<Indexes1...>, index_tuple<Indexes2...>)
         : first (::boost::forward<Args1>(get<Indexes1>(t1))...)
         , second(::boost::forward<Args2>(get<Indexes2>(t2))...)
      { (void) t1; (void)t2; }

      public:
      template< template<class ...> class Tuple, class... Args1, class... Args2
              , class = typename pair_impl::disable_if_boost_tuple< Tuple<Args1...> >::type>
      pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
         : pair(t1, t2, typename build_number_seq<sizeof...(Args1)>::type(), typename build_number_seq<sizeof...(Args2)>::type())
      {}
# 368 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
   pair& operator=(const pair & p)
   {
      first = p.first;
      second = p.second;
      return *this;
   }


   pair& operator=(pair && p)
   {
      first = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }

   template <class D, class S>
   typename ::boost::container::dtl::disable_if_or
      < pair &
      , ::boost::container::dtl::is_same<T1, D>
      , ::boost::container::dtl::is_same<T2, S>
      >::type
      operator=(const pair<D, S>&p)
   {
      first = p.first;
      second = p.second;
      return *this;
   }

   template <class D, class S>
   typename ::boost::container::dtl::disable_if_or
      < pair &
      , ::boost::container::dtl::is_same<T1, D>
      , ::boost::container::dtl::is_same<T2, S>
      >::type
      operator=( pair<D, S> && p)
   {
      first = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }

   pair& operator=(const std::pair<T1, T2> &p)
   {
      first = p.first;
      second = p.second;
      return *this;
   }

   template <class D, class S>
   pair& operator=(const std::pair<D, S> &p)
   {
      first = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }


   pair& operator=( std::pair<T1, T2> && p)
   {
      first = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }

   template <class D, class S>
   pair& operator=( std::pair<D, S> && p)
   {
      first = ::boost::move(p.first);
      second = ::boost::move(p.second);
      return *this;
   }


   void swap(pair& p)
   {
      ::boost::adl_move_swap(this->first, p.first);
      ::boost::adl_move_swap(this->second, p.second);
   }
};

template <class T1, class T2>
inline bool operator==(const pair<T1,T2>& x, const pair<T1,T2>& y)
{ return static_cast<bool>(x.first == y.first && x.second == y.second); }

template <class T1, class T2>
inline bool operator< (const pair<T1,T2>& x, const pair<T1,T2>& y)
{ return static_cast<bool>(x.first < y.first ||
                         (!(y.first < x.first) && x.second < y.second)); }

template <class T1, class T2>
inline bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y)
{ return static_cast<bool>(!(x == y)); }

template <class T1, class T2>
inline bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y)
{ return y < x; }

template <class T1, class T2>
inline bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y)
{ return static_cast<bool>(!(x < y)); }

template <class T1, class T2>
inline bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y)
{ return static_cast<bool>(!(y < x)); }

template <class T1, class T2>
inline pair<T1, T2> make_pair(T1 x, T2 y)
{ return pair<T1, T2>(x, y); }

template <class T1, class T2>
inline void swap(pair<T1, T2>& x, pair<T1, T2>& y)
{ x.swap(y); }

}
}
# 494 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 3 4
namespace move_detail{

template<class T>
struct is_class_or_union;

template <class T1, class T2>
struct is_class_or_union< ::boost::container::dtl::pair<T1, T2> >


{
   static const bool value = true;
};

template <class T1, class T2>
struct is_class_or_union< std::pair<T1, T2> >


{
   static const bool value = true;
};

template<class T>
struct is_union;

template <class T1, class T2>
struct is_union< ::boost::container::dtl::pair<T1, T2> >


{
   static const bool value = false;
};

template <class T1, class T2>
struct is_union< std::pair<T1, T2> >


{
   static const bool value = false;
};

template<class T>
struct is_class;

template <class T1, class T2>
struct is_class< ::boost::container::dtl::pair<T1, T2> >


{
   static const bool value = true;
};

template <class T1, class T2>
struct is_class< std::pair<T1, T2> >


{
   static const bool value = true;
};

}

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 558 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/pair.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_sorted.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_sorted.hpp" 3 4
         


namespace boost {
namespace container {
namespace dtl {

template <class ForwardIterator, class Pred>
bool is_sorted (ForwardIterator first, ForwardIterator last, Pred pred)
{
   if(first != last){
      ForwardIterator next = first;
      while (++next != last){
         if(pred(*next, *first))
            return false;
         ++first;
      }
   }
   return true;
}

template <class ForwardIterator, class Pred>
bool is_sorted_and_unique (ForwardIterator first, ForwardIterator last, Pred pred)
{
   if(first != last){
      ForwardIterator next = first;
      while (++next != last){
         if(!pred(*first, *next))
            return false;
         ++first;
      }
   }
   return true;
}

}
}
}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_contiguous_container.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_contiguous_container.hpp" 3 4
         
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_contiguous_container.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
namespace boost { namespace container { namespace is_contiguous_container_detail {



   template<typename Fun, class ...Args>
   struct has_member_function_callable_with_data
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         data(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_contiguous_container.hpp" 2 3 4

namespace boost {
namespace container {
namespace dtl {

template <class Container>
struct is_contiguous_container
{
   static const bool value =
      boost::container::is_contiguous_container_detail::
         has_member_function_callable_with_data<Container>::value &&
      boost::container::is_contiguous_container_detail::
         has_member_function_callable_with_data<const Container>::value;
};

}
}
}
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_container.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_container.hpp" 3 4
         
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_container.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
namespace boost { namespace container { namespace is_container_detail {



   template<typename Fun, class ...Args>
   struct has_member_function_callable_with_empty
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         empty(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_container.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
namespace boost { namespace container { namespace is_container_detail {



   template<typename Fun, class ...Args>
   struct has_member_function_callable_with_size
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         size(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/is_container.hpp" 2 3 4

namespace boost {
namespace container {
namespace dtl {

template <class Container>
struct is_container
{
   static const bool value =
      boost::container::is_container_detail::
         has_member_function_callable_with_size <const Container>::value &&
      boost::container::is_container_detail::
         has_member_function_callable_with_empty<const Container>::value;
};

}
}
}
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/make_unique.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/make_unique.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/make_unique.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 3 4
         






namespace boost {

namespace movelib {

template <class T>
struct default_delete;

}






namespace move_upmu {




struct nat{};




template <class T> struct natify{};




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>
{};


template <bool B, class T = nat>
struct enable_if_c
{
   typedef T type;
};




template <class T>
struct enable_if_c<false, T> {};




template <class Cond, class T = nat>
struct enable_if : public enable_if_c<Cond::value, T> {};




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;
};
# 145 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 3 4
template< class T >
struct remove_const
{
   typedef T type;
};

template< class T >
struct remove_const<const T>
{
   typedef T type;
};




template< class T >
struct remove_volatile
{
   typedef T type;
};

template< class T >
struct remove_volatile<volatile T>
{
   typedef T type;
};




template< class T >
struct remove_cv
{
    typedef typename remove_volatile
      <typename remove_const<T>::type>::type type;
};




template<class T>
struct remove_extent
{
   typedef T type;
};

template<class T>
struct remove_extent<T[]>
{
   typedef T type;
};

template<class T, std::size_t N>
struct remove_extent<T[N]>
{
   typedef T type;
};





template<class T, unsigned N = 0>
struct extent
{
   static const std::size_t value = 0;
};

template<class T>
struct extent<T[], 0>
{
   static const std::size_t value = 0;
};

template<class T, unsigned N>
struct extent<T[], N>
{
   static const std::size_t value = extent<T, N-1>::value;
};

template<class T, std::size_t N>
struct extent<T[N], 0>
{
   static const std::size_t value = N;
};

template<class T, std::size_t I, unsigned N>
struct extent<T[I], N>
{
   static const std::size_t value = extent<T, N-1>::value;
};




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 const t_unreferenced t_unreferenced_const;
   typedef typename add_lvalue_reference
      <t_unreferenced_const>::type 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 >
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_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_lvalue_reference
{
    static const bool value = false;
};

template<class T>
struct is_lvalue_reference<T&>
{
    static const bool value = true;
};




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 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;
};




template <class T, class D, bool = has_pointer_type<D>::value>
struct pointer_type_imp
{
    typedef typename D::pointer type;
};

template <class T, class D>
struct pointer_type_imp<T, D, false>
{
    typedef T* type;
};

template <class T, class D>
struct pointer_type
{
    typedef typename pointer_type_imp
      <typename remove_extent<T>::type, typename remove_reference<D>::type>::type type;
};
# 425 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_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);
};
# 453 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 3 4
template <typename T>
struct is_unary_function_impl
{ static const bool value = false; };




template <typename R>
struct is_unary_function_impl<R (*)()>
{ static const bool value = true; };

template <typename R>
struct is_unary_function_impl<R (*)(...)>
{ static const bool value = true; };
# 495 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 3 4
template <typename R, class T0>
struct is_unary_function_impl<R (*)(T0)>
{ static const bool value = true; };

template <typename R, class T0>
struct is_unary_function_impl<R (*)(T0...)>
{ static const bool value = true; };
# 527 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 3 4
template <typename T>
struct is_unary_function_impl<T&>
{ static const bool value = false; };

template<typename T>
struct is_unary_function
{ static const bool value = is_unary_function_impl<T>::value; };
# 554 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 3 4
   template<class T>
   struct has_virtual_destructor{ static const bool value = __has_virtual_destructor(T); };
# 566 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/unique_ptr_meta_utils.hpp" 3 4
template< class T, class U
        , bool enable = is_convertible< U*, T*>::value &&
                        !is_array<T>::value &&
                        !is_same<typename remove_cv<T>::type, void>::value &&
                        !is_same<typename remove_cv<U>::type, typename remove_cv<T>::type>::value
        >
struct missing_virtual_destructor_default_delete
{ static const bool value = !has_virtual_destructor<T>::value; };

template<class T, class U>
struct missing_virtual_destructor_default_delete<T, U, false>
{ static const bool value = false; };

template<class Deleter, class U>
struct missing_virtual_destructor
{ static const bool value = false; };

template<class T, class U>
struct missing_virtual_destructor< ::boost::movelib::default_delete<T>, U >
   : missing_virtual_destructor_default_delete<T, U>
{};

}
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 3 4
namespace boost{

namespace move_upd {

namespace bmupmu = ::boost::move_upmu;
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 3 4
template<class U, class T>
struct def_del_compatible_cond
   : bmupmu::is_convertible<U*, T*>
{};

template<class U, class T, std::size_t N>
struct def_del_compatible_cond<U[N], T[]>
   : def_del_compatible_cond<U[], T[]>
{};

template<class U, class T, class Type = bmupmu::nat>
struct enable_def_del
   : bmupmu::enable_if_c<def_del_compatible_cond<U, T>::value, Type>
{};
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 3 4
template<class U, class T, class Type = bmupmu::nat>
struct enable_defdel_call
   : public enable_def_del<U, T, Type>
{};

template<class U, class T, class Type>
struct enable_defdel_call<U, T[], Type>
   : public enable_def_del<U[], T[], Type>
{};

template<class U, class T, class Type, std::size_t N>
struct enable_defdel_call<U, T[N], Type>
   : public enable_def_del<U[N], T[N], Type>
{};





struct bool_conversion {int for_bool; int for_arg(); };
typedef int bool_conversion::* explicit_bool_arg;


   typedef decltype(nullptr) nullptr_type;






template<bool B>
struct is_array_del
{};

template<class T>
void call_delete(T *p, is_array_del<true>)
{
   delete [] p;
}

template<class T>
void call_delete(T *p, is_array_del<false>)
{
   delete p;
}

}


namespace movelib {

namespace bmupd = boost::move_upd;
namespace bmupmu = ::boost::move_upmu;





template <class T>
struct default_delete
{


   constexpr default_delete()





   = default;
# 151 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 3 4
   typedef typename bmupmu::remove_extent<T>::type element_type;







   template <class U>
   default_delete(const default_delete<U>&
      , typename bmupd::enable_def_del<U , T>::type* =0
      ) noexcept
   {


      static_assert(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ), "( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value )");
   }






   template <class U>
   typename bmupd::enable_def_del<U , T , default_delete &>::type

      operator=(const default_delete<U>&) noexcept
   {


      static_assert(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ), "( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value )");
      return *this;
   }
# 193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 3 4
   template <class U>
   typename bmupd::enable_defdel_call<U , T , void>::type
      operator()(U* ptr) const noexcept
   {

      static_assert(sizeof(U) > 0, "sizeof(U) > 0");


      static_assert(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ), "( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value )");
      element_type * const p = static_cast<element_type*>(ptr);
      move_upd::call_delete(p, move_upd::is_array_del<bmupmu::is_array<T>::value>());
   }



   void operator()(bmupd::nullptr_type) const noexcept
   { static_assert(sizeof(element_type) > 0, "sizeof(element_type) > 0"); }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 216 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/default_delete.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
namespace boost{

namespace move_upd {
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
template <class D>
struct deleter_types
{
   typedef typename bmupmu::add_lvalue_reference<D>::type del_ref;
   typedef typename bmupmu::add_const_lvalue_reference<D>::type del_cref;

   typedef typename bmupmu::if_c
      < bmupmu::is_lvalue_reference<D>::value, D, del_cref >::type deleter_arg_type1;
   typedef typename bmupmu::remove_reference<D>::type && deleter_arg_type2;







};




template <class P, class D, bool = bmupmu::is_unary_function<D>::value || bmupmu::is_reference<D>::value >
struct unique_ptr_data
{
   typedef typename deleter_types<D>::deleter_arg_type1 deleter_arg_type1;
   typedef typename deleter_types<D>::del_ref del_ref;
   typedef typename deleter_types<D>::del_cref del_cref;

   inline __attribute__ ((__always_inline__)) unique_ptr_data() noexcept
      : m_p(), d()
   {}

   inline __attribute__ ((__always_inline__)) explicit unique_ptr_data(P p) noexcept
      : m_p(p), d()
   {}

   inline __attribute__ ((__always_inline__)) unique_ptr_data(P p, deleter_arg_type1 d1) noexcept
      : m_p(p), d(d1)
   {}

   template <class U>
   inline __attribute__ ((__always_inline__)) unique_ptr_data(P p, U && d1) noexcept
      : m_p(p), d(::boost::forward<U>(d1))
   {}

   inline __attribute__ ((__always_inline__)) del_ref deleter() { return d; }
   inline __attribute__ ((__always_inline__)) del_cref deleter() const{ return d; }

   P m_p;
   D d;

   private:
   unique_ptr_data& operator=(const unique_ptr_data&);
   unique_ptr_data(const unique_ptr_data&);
};

template <class P, class D>
struct unique_ptr_data<P, D, false>
   : private D
{
   typedef typename deleter_types<D>::deleter_arg_type1 deleter_arg_type1;
   typedef typename deleter_types<D>::del_ref del_ref;
   typedef typename deleter_types<D>::del_cref del_cref;

   inline __attribute__ ((__always_inline__)) unique_ptr_data() noexcept
      : D(), m_p()
   {}

   inline __attribute__ ((__always_inline__)) explicit unique_ptr_data(P p) noexcept
      : D(), m_p(p)
   {}

   inline __attribute__ ((__always_inline__)) unique_ptr_data(P p, deleter_arg_type1 d1) noexcept
      : D(d1), m_p(p)
   {}

   template <class U>
   inline __attribute__ ((__always_inline__)) unique_ptr_data(P p, U && d) noexcept
      : D(::boost::forward<U>(d)), m_p(p)
   {}

   inline __attribute__ ((__always_inline__)) del_ref deleter() noexcept { return static_cast<del_ref>(*this); }
   inline __attribute__ ((__always_inline__)) del_cref deleter() const noexcept { return static_cast<del_cref>(*this); }

   P m_p;

   private:
   unique_ptr_data& operator=(const unique_ptr_data&);
   unique_ptr_data(const unique_ptr_data&);
};







template <typename T>
struct get_element_type
{
   struct DefaultWrap { typedef bmupmu::natify<T> element_type; };
   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)));
   typedef typename bmupmu::if_c<value, T, DefaultWrap>::type::element_type type;
};

template<class T>
struct get_element_type<T*>
{
   typedef T type;
};

template<class T>
struct get_cvelement
   : bmupmu::remove_cv<typename get_element_type<T>::type>
{};

template <class P1, class P2>
struct is_same_cvelement_and_convertible
{
   typedef typename bmupmu::remove_reference<P1>::type arg1;
   typedef typename bmupmu::remove_reference<P2>::type arg2;
   static const bool same_cvless =
      bmupmu::is_same<typename get_cvelement<arg1>::type,typename get_cvelement<arg2>::type>::value;
   static const bool value = same_cvless && bmupmu::is_convertible<arg1, arg2>::value;
};

template<bool IsArray, class FromPointer, class ThisPointer>
struct is_unique_ptr_convertible
   : is_same_cvelement_and_convertible<FromPointer, ThisPointer>
{};

template<class FromPointer, class ThisPointer>
struct is_unique_ptr_convertible<false, FromPointer, ThisPointer>
   : bmupmu::is_convertible<FromPointer, ThisPointer>
{};





template<class T, class FromPointer, class ThisPointer, class Type = bmupmu::nat>
struct enable_up_ptr
   : bmupmu::enable_if_c< is_unique_ptr_convertible
      < bmupmu::is_array<T>::value, FromPointer, ThisPointer>::value, Type>
{};





template<class T, class D, class U, class E>
struct unique_moveconvert_assignable
{
   static const bool t_is_array = bmupmu::is_array<T>::value;
   static const bool value =
      t_is_array == bmupmu::is_array<U>::value &&
      bmupmu::extent<T>::value == bmupmu::extent<U>::value &&
      is_unique_ptr_convertible
         < t_is_array
         , typename bmupmu::pointer_type<U, E>::type, typename bmupmu::pointer_type<T, D>::type
         >::value;
};

template<class T, class D, class U, class E, std::size_t N>
struct unique_moveconvert_assignable<T[], D, U[N], E>
   : unique_moveconvert_assignable<T[], D, U[], E>
{};

template<class T, class D, class U, class E, class Type = bmupmu::nat>
struct enable_up_moveconv_assign
   : bmupmu::enable_if_c<unique_moveconvert_assignable<T, D, U, E>::value, Type>
{};





template<class D, class E, bool IsReference = bmupmu::is_reference<D>::value>
struct unique_deleter_is_initializable
   : bmupmu::is_same<D, E>
{};

template <class T, class U>
class is_rvalue_convertible
{

   typedef typename bmupmu::remove_reference<T>::type&& t_from;
# 265 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   typedef char true_t;
   class false_t { char dummy[2]; };
   static false_t dispatch(...);
   static true_t dispatch(U);
   static t_from trigger();
   public:
   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
};

template<class D, class E>
struct unique_deleter_is_initializable<D, E, false>
{
# 287 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   static const bool value = is_rvalue_convertible<E, D>::value;







};

template<class T, class D, class U, class E, class Type = bmupmu::nat>
struct enable_up_moveconv_constr
   : bmupmu::enable_if_c
      < unique_moveconvert_assignable<T, D, U, E>::value && unique_deleter_is_initializable<D, E>::value
      , Type>
{};

}


namespace movelib {
# 353 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
template <class T, class D = default_delete<T> >
class unique_ptr
{






   public: unique_ptr(unique_ptr const &) = delete; unique_ptr& operator=(unique_ptr const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   typedef bmupmu::pointer_type<T, D > pointer_type_obtainer;
   typedef bmupd::unique_ptr_data
      <typename pointer_type_obtainer::type, D> data_type;
   typedef typename bmupd::deleter_types<D>::deleter_arg_type1 deleter_arg_type1;
   typedef typename bmupd::deleter_types<D>::deleter_arg_type2 deleter_arg_type2;
   data_type m_data;


   public:



   typedef typename pointer_type_obtainer::type pointer;


   typedef typename bmupmu::remove_extent<T>::type element_type;
   typedef D deleter_type;
# 392 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   inline __attribute__ ((__always_inline__)) constexpr unique_ptr() noexcept
      : m_data()
   {


      static_assert(!bmupmu::is_pointer<D>::value, "!bmupmu::is_pointer<D>::value");
      static_assert(!bmupmu::is_reference<D>::value, "!bmupmu::is_reference<D>::value");
   }



   inline __attribute__ ((__always_inline__)) constexpr unique_ptr(bmupd::nullptr_type) noexcept
      : m_data()
   {


      static_assert(!bmupmu::is_pointer<D>::value, "!bmupmu::is_pointer<D>::value");
      static_assert(!bmupmu::is_reference<D>::value, "!bmupmu::is_reference<D>::value");
   }
# 425 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   template<class Pointer>
   inline __attribute__ ((__always_inline__)) explicit unique_ptr(Pointer p
      , typename bmupd::enable_up_ptr<T , Pointer , pointer>::type* =0
                 ) noexcept
      : m_data(p)
   {


      static_assert(( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value ), "( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value )")
                                                                                          ;


      static_assert(!bmupmu::is_pointer<D>::value, "!bmupmu::is_pointer<D>::value");
      static_assert(!bmupmu::is_reference<D>::value, "!bmupmu::is_reference<D>::value");
   }
# 463 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   template<class Pointer>
   inline __attribute__ ((__always_inline__)) unique_ptr(Pointer p, deleter_arg_type1 d1
      , typename bmupd::enable_up_ptr<T , Pointer , pointer>::type* =0
              ) noexcept
      : m_data(p, d1)
   {


      static_assert(( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value ), "( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value )")
                                                                                          ;
   }



   inline __attribute__ ((__always_inline__)) unique_ptr(bmupd::nullptr_type, deleter_arg_type1 d1) noexcept
      : m_data(pointer(), d1)
   {}
# 501 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   template<class Pointer>
   inline __attribute__ ((__always_inline__)) unique_ptr(Pointer p, deleter_arg_type2 d2
      , typename bmupd::enable_up_ptr<T , Pointer , pointer>::type* =0
             ) noexcept
      : m_data(p, ::boost::move(d2))
   {


      static_assert(( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value ), "( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value )")
                                                                                          ;
   }



   inline __attribute__ ((__always_inline__)) unique_ptr(bmupd::nullptr_type, deleter_arg_type2 d2) noexcept
      : m_data(pointer(), ::boost::move(d2))
   {}
# 529 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   inline __attribute__ ((__always_inline__)) unique_ptr(unique_ptr && u) noexcept
      : m_data(u.release(), ::boost::move_if_not_lvalue_reference<D>(u.get_deleter()))
   {}
# 548 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   template <class U, class E>
   inline __attribute__ ((__always_inline__)) unique_ptr( unique_ptr<U, E> && u
      , typename bmupd::enable_up_moveconv_constr<T , D , U , E>::type* =0
      ) noexcept
      : m_data(u.release(), ::boost::move_if_not_lvalue_reference<E>(u.get_deleter()))
   {


      static_assert(( !::boost::move_upmu::missing_virtual_destructor <D, typename unique_ptr<U, E>::pointer>::value ), "( !::boost::move_upmu::missing_virtual_destructor <D, typename unique_ptr<U, E>::pointer>::value )")
                                                                             ;
   }







   ~unique_ptr()
   { if(m_data.m_p) m_data.deleter()(m_data.m_p); }
# 578 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   unique_ptr& operator=(unique_ptr && u) noexcept
   {
      this->reset(u.release());
      m_data.deleter() = ::boost::move_if_not_lvalue_reference<D>(u.get_deleter());
      return *this;
   }
# 597 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   template <class U, class E>
   typename bmupd::enable_up_moveconv_assign <T , D , U , E , unique_ptr &>::type

      operator=( unique_ptr<U, E> && u) noexcept
   {
      this->reset(u.release());
      m_data.deleter() = ::boost::move_if_not_lvalue_reference<E>(u.get_deleter());
      return *this;
   }






   unique_ptr& operator=(bmupd::nullptr_type) noexcept
   { this->reset(); return *this; }






   typename bmupmu::add_lvalue_reference<element_type>::type
      operator*() const noexcept
   {
      static_assert((!bmupmu::is_array<T>::value), "(!bmupmu::is_array<T>::value)");
      return *m_data.m_p;
   }






   inline __attribute__ ((__always_inline__)) typename bmupmu::add_lvalue_reference<element_type>::type
      operator[](std::size_t i) const noexcept
   {
      (static_cast<void> (0));
      (static_cast<void> (0));
      return m_data.m_p[i];
   }
# 647 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   inline __attribute__ ((__always_inline__)) pointer operator->() const noexcept
   {
      static_assert((!bmupmu::is_array<T>::value), "(!bmupmu::is_array<T>::value)");
      (static_cast<void> (0));
      return m_data.m_p;
   }



   inline __attribute__ ((__always_inline__)) pointer get() const noexcept
   { return m_data.m_p; }



   inline __attribute__ ((__always_inline__)) typename bmupmu::add_lvalue_reference<D>::type
      get_deleter() noexcept
   { return m_data.deleter(); }



   inline __attribute__ ((__always_inline__)) typename bmupmu::add_const_lvalue_reference<D>::type
      get_deleter() const noexcept
   { return m_data.deleter(); }






   inline __attribute__ ((__always_inline__)) operator bmupd::explicit_bool_arg

      ()const noexcept
   {
      return m_data.m_p
         ? &bmupd::bool_conversion::for_bool
         : bmupd::explicit_bool_arg(0);
   }




   inline __attribute__ ((__always_inline__)) pointer release() noexcept
   {
      const pointer tmp = m_data.m_p;
      m_data.m_p = pointer();
      return tmp;
   }
# 708 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   template<class Pointer>
   typename bmupd::enable_up_ptr<T , Pointer , pointer , void>::type
      reset(Pointer p) noexcept
   {


      static_assert(( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value ), "( !::boost::move_upmu::missing_virtual_destructor <D, typename bmupd::get_element_type<Pointer>::type>::value )")
                                                                                          ;
      pointer tmp = m_data.m_p;
      m_data.m_p = p;
      if(tmp) m_data.deleter()(tmp);
   }
# 730 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 3 4
   void reset() noexcept
   { this->reset(pointer()); }



   void reset(bmupd::nullptr_type) noexcept
   { this->reset(); }




   void swap(unique_ptr& u) noexcept
   {
      ::boost::adl_move_swap(m_data.m_p, u.m_data.m_p);
      ::boost::adl_move_swap(m_data.deleter(), u.m_data.deleter());
   }
};



template <class T, class D>
inline __attribute__ ((__always_inline__)) void swap(unique_ptr<T, D> &x, unique_ptr<T, D> &y) noexcept
{ x.swap(y); }



template <class T1, class D1, class T2, class D2>
inline __attribute__ ((__always_inline__)) bool operator==(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
{ return x.get() == y.get(); }



template <class T1, class D1, class T2, class D2>
inline __attribute__ ((__always_inline__)) bool operator!=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
{ return x.get() != y.get(); }





template <class T1, class D1, class T2, class D2>
inline __attribute__ ((__always_inline__)) bool operator<(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
{ return x.get() < y.get(); }



template <class T1, class D1, class T2, class D2>
inline __attribute__ ((__always_inline__)) bool operator<=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
{ return !(y < x); }



template <class T1, class D1, class T2, class D2>
inline __attribute__ ((__always_inline__)) bool operator>(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
{ return y < x; }



template <class T1, class D1, class T2, class D2>
inline __attribute__ ((__always_inline__)) bool operator>=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
{ return !(x < y); }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator==(const unique_ptr<T, D> &x, bmupd::nullptr_type) noexcept
{ return !x; }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator==(bmupd::nullptr_type, const unique_ptr<T, D> &x) noexcept
{ return !x; }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator!=(const unique_ptr<T, D> &x, bmupd::nullptr_type) noexcept
{ return !!x; }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator!=(bmupd::nullptr_type, const unique_ptr<T, D> &x) noexcept
{ return !!x; }




template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator<(const unique_ptr<T, D> &x, bmupd::nullptr_type)
{ return x.get() < typename unique_ptr<T, D>::pointer(); }




template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator<(bmupd::nullptr_type, const unique_ptr<T, D> &x)
{ return typename unique_ptr<T, D>::pointer() < x.get(); }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator>(const unique_ptr<T, D> &x, bmupd::nullptr_type)
{ return x.get() > typename unique_ptr<T, D>::pointer(); }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator>(bmupd::nullptr_type, const unique_ptr<T, D> &x)
{ return typename unique_ptr<T, D>::pointer() > x.get(); }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator<=(const unique_ptr<T, D> &x, bmupd::nullptr_type)
{ return !(bmupd::nullptr_type() < x); }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator<=(bmupd::nullptr_type, const unique_ptr<T, D> &x)
{ return !(x < bmupd::nullptr_type()); }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator>=(const unique_ptr<T, D> &x, bmupd::nullptr_type)
{ return !(x < bmupd::nullptr_type()); }



template <class T, class D>
inline __attribute__ ((__always_inline__)) bool operator>=(bmupd::nullptr_type, const unique_ptr<T, D> &x)
{ return !(bmupd::nullptr_type() < x); }

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 870 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/unique_ptr.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/make_unique.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/make_unique.hpp" 3 4
namespace std {

struct nothrow_t;

}

namespace boost{
namespace move_upmu {




template<class T>
struct unique_ptr_if
{
   typedef ::boost::movelib::unique_ptr<T> t_is_not_array;
};

template<class T>
struct unique_ptr_if<T[]>
{
   typedef ::boost::movelib::unique_ptr<T[]> t_is_array_of_unknown_bound;
};

template<class T, std::size_t N>
struct unique_ptr_if<T[N]>
{
   typedef void t_is_array_of_known_bound;
};

template <int Dummy = 0>
struct nothrow_holder
{
   static std::nothrow_t *pnothrow;
};

template <int Dummy>
std::nothrow_t *nothrow_holder<Dummy>::pnothrow =
   reinterpret_cast<std::nothrow_t *>(0x1234);

}
}



namespace boost{
namespace movelib {






template<class T, class... Args>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array

      make_unique(Args &&... args)
{ return unique_ptr<T>(new T(::boost::forward<Args>(args)...)); }




template<class T, class... Args>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array

      make_unique_nothrow(Args &&... args)
{ return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)T(::boost::forward<Args>(args)...)); }
# 129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/make_unique.hpp" 3 4
template<class T>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array

      make_unique_definit()
{
    return unique_ptr<T>(new T);
}




template<class T>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_not_array

      make_unique_nothrow_definit()
{
    return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)T);
}





template<class T>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound

      make_unique(std::size_t n)
{
    typedef typename ::boost::move_upmu::remove_extent<T>::type U;
    return unique_ptr<T>(new U[n]());
}





template<class T>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound

      make_unique_nothrow(std::size_t n)
{
    typedef typename ::boost::move_upmu::remove_extent<T>::type U;
    return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow)U[n]());
}





template<class T>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound

      make_unique_definit(std::size_t n)
{
    typedef typename ::boost::move_upmu::remove_extent<T>::type U;
    return unique_ptr<T>(new U[n]);
}





template<class T>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_unknown_bound

      make_unique_nothrow_definit(std::size_t n)
{
    typedef typename ::boost::move_upmu::remove_extent<T>::type U;
    return unique_ptr<T>(new (*boost::move_upmu::nothrow_holder<>::pnothrow) U[n]);
}





template<class T, class... Args>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound

      make_unique(Args && ...) = delete;



template<class T, class... Args>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound

      make_unique_definit(Args && ...) = delete;



template<class T, class... Args>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound

      make_unique_nothrow(Args && ...) = delete;



template<class T, class... Args>
inline typename ::boost::move_upmu::unique_ptr_if<T>::t_is_array_of_known_bound

      make_unique_nothrow_definit(Args && ...) = delete;



}

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/make_unique.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_sort.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_sort.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_sort.hpp" 2 3 4


namespace boost {
namespace movelib {


namespace detail_adaptive {

template<class RandIt>
void move_data_backward( RandIt cur_pos
              , typename iterator_traits<RandIt>::size_type const l_data
              , RandIt new_pos
              , bool const xbuf_used)
{

   if(xbuf_used){
      boost::move_backward(cur_pos, cur_pos+l_data, new_pos+l_data);
   }
   else{
      boost::adl_move_swap_ranges_backward(cur_pos, cur_pos+l_data, new_pos+l_data);


   }
}

template<class RandIt>
void move_data_forward( RandIt cur_pos
              , typename iterator_traits<RandIt>::size_type const l_data
              , RandIt new_pos
              , bool const xbuf_used)
{

   if(xbuf_used){
      boost::move(cur_pos, cur_pos+l_data, new_pos);
   }
   else{
      boost::adl_move_swap_ranges(cur_pos, cur_pos+l_data, new_pos);


   }
}
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_sort.hpp" 3 4
template<class RandIt, class Compare, class XBuf>
typename iterator_traits<RandIt>::size_type
   adaptive_sort_build_blocks
      ( RandIt const first
      , typename iterator_traits<RandIt>::size_type const len
      , typename iterator_traits<RandIt>::size_type const l_base
      , typename iterator_traits<RandIt>::size_type const l_build_buf
      , XBuf & xbuf
      , Compare comp)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   (static_cast<void> (0));
   (static_cast<void> (0));


   RandIt first_block = first + l_build_buf;
   size_type const elements_in_blocks = len - l_build_buf;




   size_type l_merged = 0u;

   (static_cast<void> (0));

   size_type kbuf = min_value<size_type>(l_build_buf, size_type(xbuf.capacity()));
   kbuf = kbuf < l_base ? 0 : kbuf;

   if(kbuf){

      xbuf.move_assign(first+l_build_buf-kbuf, kbuf);
      l_merged = op_insertion_sort_step_left(first_block, elements_in_blocks, l_base, comp, move_op());



      l_merged = op_merge_left_step_multiple
         ( first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, kbuf - l_merged, comp, move_op());



      if(kbuf != l_build_buf){
         boost::move(xbuf.data()+kbuf-l_merged, xbuf.data() + kbuf, first_block-l_merged+elements_in_blocks);
      }
   }
   else{
      l_merged = insertion_sort_step(first_block, elements_in_blocks, l_base, comp);
      rotate_gcd(first_block - l_merged, first_block, first_block+elements_in_blocks);
   }



   l_merged = op_merge_left_step_multiple
      (first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, l_build_buf - l_merged, comp, swap_op());

   (static_cast<void> (0));







   if(kbuf && kbuf == l_build_buf){
      op_merge_right_step_once(first, elements_in_blocks, l_build_buf, comp, move_op());


      boost::move(xbuf.data(), xbuf.data() + kbuf, first);
   }
   else{
      op_merge_right_step_once(first, elements_in_blocks, l_build_buf, comp, swap_op());
   }
   xbuf.clear();

   return min_value(elements_in_blocks, 2*l_build_buf);
}

template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class XBuf>
void adaptive_sort_combine_blocks
   ( RandItKeys const keys
   , KeyCompare key_comp
   , RandIt const first
   , typename iterator_traits<RandIt>::size_type const len
   , typename iterator_traits<RandIt>::size_type const l_prev_merged
   , typename iterator_traits<RandIt>::size_type const l_block
   , bool const use_buf
   , bool const xbuf_used
   , XBuf & xbuf
   , Compare comp
   , bool merge_left)
{
   (void)xbuf;
   typedef typename iterator_traits<RandIt>::size_type size_type;

   size_type const l_reg_combined = 2*l_prev_merged;
   size_type l_irreg_combined = 0;
   size_type const l_total_combined = calculate_total_combined(len, l_prev_merged, &l_irreg_combined);
   size_type const n_reg_combined = len/l_reg_combined;
   RandIt combined_first = first;

   (void)l_total_combined;
   (static_cast<void> (0));

   size_type const max_i = n_reg_combined + (l_irreg_combined != 0);

   if(merge_left || !use_buf) {
      for( size_type combined_i = 0; combined_i != max_i; ++combined_i, combined_first += l_reg_combined) {

         bool const is_last = combined_i==n_reg_combined;
         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;

         range_xbuf<RandIt, move_op> rbuf( (use_buf && xbuf_used) ? (combined_first-l_block) : combined_first, combined_first);
         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
         combine_params( keys, key_comp, l_cur_combined
                        , l_prev_merged, l_block, rbuf
                        , n_block_a, n_block_b, l_irreg1, l_irreg2);
         ;
         ;
            ;
         if(!use_buf){
            merge_blocks_bufferless
               (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp);
         }
         else{
            merge_blocks_left
               (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
         }
         ;
      }
   }
   else{
      combined_first += l_reg_combined*(max_i-1);
      for( size_type combined_i = max_i; combined_i--; combined_first -= l_reg_combined) {
         bool const is_last = combined_i==n_reg_combined;
         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;

         RandIt const combined_last(combined_first+l_cur_combined);
         range_xbuf<RandIt, move_op> rbuf(combined_last, xbuf_used ? (combined_last+l_block) : combined_last);
         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
         combine_params( keys, key_comp, l_cur_combined
                        , l_prev_merged, l_block, rbuf
                        , n_block_a, n_block_b, l_irreg1, l_irreg2);
         ;
         ;
         ;
         merge_blocks_right
            (keys, key_comp, combined_first, l_block, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
         ;
      }
   }
}




template<class RandIt, class Compare, class XBuf>
bool adaptive_sort_combine_all_blocks
   ( RandIt keys
   , typename iterator_traits<RandIt>::size_type &n_keys
   , RandIt const buffer
   , typename iterator_traits<RandIt>::size_type const l_buf_plus_data
   , typename iterator_traits<RandIt>::size_type l_merged
   , typename iterator_traits<RandIt>::size_type &l_intbuf
   , XBuf & xbuf
   , Compare comp)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   RandIt const first = buffer + l_intbuf;
   size_type const l_data = l_buf_plus_data - l_intbuf;
   size_type const l_unique = l_intbuf+n_keys;

   bool const common_xbuf = l_data > l_merged && l_intbuf && l_intbuf <= xbuf.capacity();
   if(common_xbuf){
      xbuf.move_assign(buffer, l_intbuf);
   }

   bool prev_merge_left = true;
   size_type l_prev_total_combined = l_merged, l_prev_block = 0;
   bool prev_use_internal_buf = true;

   for( size_type n = 0; l_data > l_merged
      ; l_merged*=2
      , ++n){





      bool use_internal_buf = false;
      size_type const l_block = lblock_for_combine(l_intbuf, n_keys, 2*l_merged, use_internal_buf);
      (static_cast<void> (0));
      (static_cast<void> (0));
      (static_cast<void> (0));

      bool const is_merge_left = (n&1) == 0;
      size_type const l_total_combined = calculate_total_combined(l_data, l_merged);
      if(n && prev_use_internal_buf && prev_merge_left){
         if(is_merge_left || !use_internal_buf){
            move_data_backward(first-l_prev_block, l_prev_total_combined, first, common_xbuf);
         }
         else{

            RandIt const buf_end = first+l_prev_total_combined;
            RandIt const buf_beg = buf_end-l_block;
            if(l_prev_total_combined > l_total_combined){
               size_type const l_diff = l_prev_total_combined - l_total_combined;
               move_data_backward(buf_beg-l_diff, l_diff, buf_end-l_diff, common_xbuf);
            }
            else if(l_prev_total_combined < l_total_combined){
               size_type const l_diff = l_total_combined - l_prev_total_combined;
               move_data_forward(buf_end, l_diff, buf_beg, common_xbuf);
            }
         }
         ;
      }


      if(n_keys){
         adaptive_sort_combine_blocks
            ( keys, comp, !use_internal_buf || is_merge_left ? first : first-l_block
            , l_data, l_merged, l_block, use_internal_buf, common_xbuf, xbuf, comp, is_merge_left);
      }
      else{
         size_type *const uint_keys = xbuf.template aligned_trailing<size_type>();
         adaptive_sort_combine_blocks
            ( uint_keys, less(), !use_internal_buf || is_merge_left ? first : first-l_block
            , l_data, l_merged, l_block, use_internal_buf, common_xbuf, xbuf, comp, is_merge_left);
      }

      ;
      prev_merge_left = is_merge_left;
      l_prev_total_combined = l_total_combined;
      l_prev_block = l_block;
      prev_use_internal_buf = use_internal_buf;
   }
   (static_cast<void> (0));
   bool const buffer_right = prev_use_internal_buf && prev_merge_left;

   l_intbuf = prev_use_internal_buf ? l_prev_block : 0u;
   n_keys = l_unique - l_intbuf;

   if(common_xbuf){
      if(buffer_right){
         boost::move(xbuf.data(), xbuf.data() + l_intbuf, buffer+l_data);
      }
      else{
         boost::move(xbuf.data(), xbuf.data() + l_intbuf, buffer);
      }
   }
   return buffer_right;
}


template<class RandIt, class Compare, class XBuf>
void adaptive_sort_final_merge( bool buffer_right
                              , RandIt const first
                              , typename iterator_traits<RandIt>::size_type const l_intbuf
                              , typename iterator_traits<RandIt>::size_type const n_keys
                              , typename iterator_traits<RandIt>::size_type const len
                              , XBuf & xbuf
                              , Compare comp)
{

   xbuf.clear();

   typedef typename iterator_traits<RandIt>::size_type size_type;
   size_type const n_key_plus_buf = l_intbuf+n_keys;
   if(buffer_right){

      stable_sort(first+len-l_intbuf, first+len, comp, xbuf);
      stable_merge(first+n_keys, first+len-l_intbuf, first+len, antistable<Compare>(comp), xbuf);
      unstable_sort(first, first+n_keys, comp, xbuf);
      stable_merge(first, first+n_keys, first+len, comp, xbuf);
   }
   else{

      stable_sort(first, first+n_key_plus_buf, comp, xbuf);
      if(xbuf.capacity() >= n_key_plus_buf){
         buffered_merge(first, first+n_key_plus_buf, first+len, comp, xbuf);
      }
      else if(xbuf.capacity() >= min_value<size_type>(l_intbuf, n_keys)){
         stable_merge(first+n_keys, first+n_key_plus_buf, first+len, comp, xbuf);
         stable_merge(first, first+n_keys, first+len, comp, xbuf);
      }
      else{
         stable_merge(first, first+n_key_plus_buf, first+len, comp, xbuf);
      }
   }
   ;
}

template<class RandIt, class Compare, class Unsigned, class XBuf>
bool adaptive_sort_build_params
   (RandIt first, Unsigned const len, Compare comp
   , Unsigned &n_keys, Unsigned &l_intbuf, Unsigned &l_base, Unsigned &l_build_buf
   , XBuf & xbuf
   )
{
   typedef Unsigned size_type;


   l_base = 0u;







   l_intbuf = size_type(ceil_sqrt_multiple(len, &l_base));


   while(xbuf.capacity() >= l_intbuf*2){
      l_intbuf *= 2;
   }




   size_type n_min_ideal_keys = l_intbuf-1;
   while(n_min_ideal_keys >= (len-l_intbuf-n_min_ideal_keys)/l_intbuf){
      --n_min_ideal_keys;
   }
   n_min_ideal_keys += 1;
   (static_cast<void> (0));

   if(xbuf.template supports_aligned_trailing<size_type>(l_intbuf, (len-l_intbuf-1)/l_intbuf+1)){
      n_keys = 0u;
      l_build_buf = l_intbuf;
   }
   else{







      bool const non_unique_buf = xbuf.capacity() >= l_intbuf;
      size_type const to_collect = non_unique_buf ? n_min_ideal_keys : l_intbuf*2;
      size_type collected = collect_unique(first, first+len, to_collect, comp, xbuf);



      if(non_unique_buf && collected == n_min_ideal_keys){
         l_build_buf = l_intbuf;
         n_keys = n_min_ideal_keys;
      }
      else if(collected == 2*l_intbuf){

         l_build_buf = l_intbuf*2;
         n_keys = l_intbuf;
      }
      else if(collected == (n_min_ideal_keys+l_intbuf)){
         l_build_buf = l_intbuf;
         n_keys = n_min_ideal_keys;
      }


      else{
         (static_cast<void> (0));
         if(collected < 4){
            return false;
         }
         n_keys = l_intbuf;
         while(n_keys&(n_keys-1)){
            n_keys &= n_keys-1;
         }
         while(n_keys > collected){
            n_keys/=2;
         }

         l_base = min_value<Unsigned>(n_keys, AdaptiveSortInsertionSortThreshold);
         l_intbuf = 0;
         l_build_buf = n_keys;
      }
      (static_cast<void> (0));
   }

   return true;
}
# 515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_sort.hpp" 3 4
template<class RandIt, class Compare, class XBuf>
void adaptive_sort_impl
   ( RandIt first
   , typename iterator_traits<RandIt>::size_type const len
   , Compare comp
   , XBuf & xbuf
   )
{
   typedef typename iterator_traits<RandIt>::size_type size_type;


   if(len <= size_type(AdaptiveSortInsertionSortThreshold)){
      insertion_sort(first, first + len, comp);
   }
   else if((len-len/2) <= xbuf.capacity()){
      merge_sort(first, first+len, comp, xbuf.data());
   }
   else{

      static_assert(AdaptiveSortInsertionSortThreshold >= 4, "AdaptiveSortInsertionSortThreshold >= 4");

      size_type l_base = 0;
      size_type l_intbuf = 0;
      size_type n_keys = 0;
      size_type l_build_buf = 0;



      if(!adaptive_sort_build_params(first, len, comp, n_keys, l_intbuf, l_base, l_build_buf, xbuf)){
         stable_sort(first, first+len, comp, xbuf);
      }
      else{
         (static_cast<void> (0));

         ;
         size_type const n_key_plus_buf = l_intbuf+n_keys;

         (static_cast<void> (0));


         size_type const l_merged = adaptive_sort_build_blocks
            (first+n_key_plus_buf-l_build_buf, len-n_key_plus_buf+l_build_buf, l_base, l_build_buf, xbuf, comp);
         ;


         bool const buffer_right = adaptive_sort_combine_all_blocks
            (first, n_keys, first+n_keys, len-n_keys, l_merged, l_intbuf, xbuf, comp);


         adaptive_sort_final_merge(buffer_right, first, l_intbuf, n_keys, len, xbuf, comp);
      }
   }
}

}
# 598 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_sort.hpp" 3 4
template<class RandIt, class RandRawIt, class Compare>
void adaptive_sort( RandIt first, RandIt last, Compare comp
               , RandRawIt uninitialized
               , std::size_t uninitialized_len)
{
   typedef typename iterator_traits<RandIt>::size_type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;

   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type, RandRawIt> xbuf(uninitialized, uninitialized_len);
   ::boost::movelib::detail_adaptive::adaptive_sort_impl(first, size_type(last - first), comp, xbuf);
}

template<class RandIt, class Compare>
void adaptive_sort( RandIt first, RandIt last, Compare comp)
{
   typedef typename iterator_traits<RandIt>::value_type value_type;
   adaptive_sort(first, last, comp, (value_type*)0, 0u);
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 621 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/adaptive_sort.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/pdqsort.hpp" 1 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/pdqsort.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/pdqsort.hpp" 2 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/pdqsort.hpp" 3 4
namespace boost {
namespace movelib {

namespace pdqsort_detail {


   template<class T1, class T2>
   struct pair
   {
      pair()
      {}

      pair(const T1 &t1, const T2 &t2)
         : first(t1), second(t2)
      {}

      T1 first;
      T2 second;
   };

    enum {

        insertion_sort_threshold = 24,


        ninther_threshold = 128,



        partial_insertion_sort_limit = 8,


        block_size = 64,


        cacheline_size = 64

    };


    template<class Unsigned>
    Unsigned log2(Unsigned n) {
        Unsigned log = 0;
        while (n >>= 1) ++log;
        return log;
    }




    template<class Iter, class Compare>
    inline bool partial_insertion_sort(Iter begin, Iter end, Compare comp) {
        typedef typename boost::movelib::iterator_traits<Iter>::value_type T;
        typedef typename boost::movelib::iterator_traits<Iter>::size_type size_type;
        if (begin == end) return true;

        size_type limit = 0;
        for (Iter cur = begin + 1; cur != end; ++cur) {
            if (limit > partial_insertion_sort_limit) return false;

            Iter sift = cur;
            Iter sift_1 = cur - 1;


            if (comp(*sift, *sift_1)) {
                T tmp = boost::move(*sift);

                do { *sift-- = boost::move(*sift_1); }
                while (sift != begin && comp(tmp, *--sift_1));

                *sift = boost::move(tmp);
                limit += size_type(cur - sift);
            }
        }

        return true;
    }

    template<class Iter, class Compare>
    inline void sort2(Iter a, Iter b, Compare comp) {
        if (comp(*b, *a)) boost::adl_move_iter_swap(a, b);
    }


    template<class Iter, class Compare>
    inline void sort3(Iter a, Iter b, Iter c, Compare comp) {
        sort2(a, b, comp);
        sort2(b, c, comp);
        sort2(a, b, comp);
    }






    template<class Iter, class Compare>
    pdqsort_detail::pair<Iter, bool> partition_right(Iter begin, Iter end, Compare comp) {
        typedef typename boost::movelib::iterator_traits<Iter>::value_type T;


        T pivot(boost::move(*begin));

        Iter first = begin;
        Iter last = end;



        while (comp(*++first, pivot));



        if (first - 1 == begin) while (first < last && !comp(*--last, pivot));
        else while ( !comp(*--last, pivot));



        bool already_partitioned = first >= last;




        while (first < last) {
            boost::adl_move_iter_swap(first, last);
            while (comp(*++first, pivot));
            while (!comp(*--last, pivot));
        }


        Iter pivot_pos = first - 1;
        *begin = boost::move(*pivot_pos);
        *pivot_pos = boost::move(pivot);

        return pdqsort_detail::pair<Iter, bool>(pivot_pos, already_partitioned);
    }





    template<class Iter, class Compare>
    inline Iter partition_left(Iter begin, Iter end, Compare comp) {
        typedef typename boost::movelib::iterator_traits<Iter>::value_type T;

        T pivot(boost::move(*begin));
        Iter first = begin;
        Iter last = end;

        while (comp(pivot, *--last));

        if (last + 1 == end) while (first < last && !comp(pivot, *++first));
        else while ( !comp(pivot, *++first));

        while (first < last) {
            boost::adl_move_iter_swap(first, last);
            while (comp(pivot, *--last));
            while (!comp(pivot, *++first));
        }

        Iter pivot_pos = last;
        *begin = boost::move(*pivot_pos);
        *pivot_pos = boost::move(pivot);

        return pivot_pos;
    }


   template<class Iter, class Compare>
   void pdqsort_loop( Iter begin, Iter end, Compare comp
                    , typename boost::movelib::iterator_traits<Iter>::size_type bad_allowed
                    , bool leftmost = true)
   {
        typedef typename boost::movelib::iterator_traits<Iter>::size_type size_type;


        while (true) {
            size_type size = size_type(end - begin);


            if (size < insertion_sort_threshold) {
                insertion_sort(begin, end, comp);
                return;
            }


            size_type s2 = size / 2;
            if (size > ninther_threshold) {
                sort3(begin, begin + s2, end - 1, comp);
                sort3(begin + 1, begin + (s2 - 1), end - 2, comp);
                sort3(begin + 2, begin + (s2 + 1), end - 3, comp);
                sort3(begin + (s2 - 1), begin + s2, begin + (s2 + 1), comp);
                boost::adl_move_iter_swap(begin, begin + s2);
            } else sort3(begin + s2, begin, end - 1, comp);






            if (!leftmost && !comp(*(begin - 1), *begin)) {
                begin = partition_left(begin, end, comp) + 1;
                continue;
            }


            pdqsort_detail::pair<Iter, bool> part_result = partition_right(begin, end, comp);
            Iter pivot_pos = part_result.first;
            bool already_partitioned = part_result.second;


            size_type l_size = size_type(pivot_pos - begin);
            size_type r_size = size_type(end - (pivot_pos + 1));
            bool highly_unbalanced = l_size < size / 8 || r_size < size / 8;


            if (highly_unbalanced) {

                if (--bad_allowed == 0) {
                    boost::movelib::heap_sort(begin, end, comp);
                    return;
                }

                if (l_size >= insertion_sort_threshold) {
                    boost::adl_move_iter_swap(begin, begin + l_size / 4);
                    boost::adl_move_iter_swap(pivot_pos - 1, pivot_pos - l_size / 4);

                    if (l_size > ninther_threshold) {
                        boost::adl_move_iter_swap(begin + 1, begin + (l_size / 4 + 1));
                        boost::adl_move_iter_swap(begin + 2, begin + (l_size / 4 + 2));
                        boost::adl_move_iter_swap(pivot_pos - 2, pivot_pos - (l_size / 4 + 1));
                        boost::adl_move_iter_swap(pivot_pos - 3, pivot_pos - (l_size / 4 + 2));
                    }
                }

                if (r_size >= insertion_sort_threshold) {
                    boost::adl_move_iter_swap(pivot_pos + 1, pivot_pos + (1 + r_size / 4));
                    boost::adl_move_iter_swap(end - 1, end - r_size / 4);

                    if (r_size > ninther_threshold) {
                        boost::adl_move_iter_swap(pivot_pos + 2, pivot_pos + (2 + r_size / 4));
                        boost::adl_move_iter_swap(pivot_pos + 3, pivot_pos + (3 + r_size / 4));
                        boost::adl_move_iter_swap(end - 2, end - (1 + r_size / 4));
                        boost::adl_move_iter_swap(end - 3, end - (2 + r_size / 4));
                    }
                }
            } else {


                if (already_partitioned && partial_insertion_sort(begin, pivot_pos, comp)
                                        && partial_insertion_sort(pivot_pos + 1, end, comp)) return;
            }



            pdqsort_loop<Iter, Compare>(begin, pivot_pos, comp, bad_allowed, leftmost);
            begin = pivot_pos + 1;
            leftmost = false;
        }
    }
}


template<class Iter, class Compare>
void pdqsort(Iter begin, Iter end, Compare comp)
{
   if (begin == end) return;
   typedef typename boost::movelib::iterator_traits<Iter>::size_type size_type;
   pdqsort_detail::pdqsort_loop<Iter, Compare>(begin, end, comp, pdqsort_detail::log2(size_type(end - begin)));
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 333 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algo/detail/pdqsort.hpp" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_merge_unique
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         merge_unique(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_merge
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         merge(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_index_of
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         index_of(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_nth
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         nth(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_reserve
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         reserve(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_capacity
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         capacity(::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4



namespace boost {
namespace container {
namespace dtl {







template <typename T> struct boost_intrusive_has_type_stored_allocator_type { template <typename X> static char test(int, typename X::stored_allocator_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_stored_allocator_type { struct DefaultWrap { typedef DefaultType stored_allocator_type; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_stored_allocator_type<T>::value , T, DefaultWrap>::type::stored_allocator_type type; };






template<class SequenceContainer, class Compare>
void flat_tree_container_inplace_merge
   (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::true_)
{
   typedef typename SequenceContainer::value_type value_type;
   value_type *const braw = boost::movelib::iterator_to_raw_pointer(dest.begin());
   value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
   value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
   boost::movelib::adaptive_merge(braw, iraw, eraw, comp, eraw, dest.capacity()- dest.size());
}

template<class SequenceContainer, class Compare>
void flat_tree_container_inplace_merge
   (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp, dtl::false_)
{
   boost::movelib::adaptive_merge(dest.begin(), it, dest.end(), comp);
}






template<class SequenceContainer, class Compare>
void flat_tree_container_inplace_sort_ending
   (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp, dtl::true_)
{
   typedef typename SequenceContainer::value_type value_type;
   value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
   value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
   boost::movelib::adaptive_sort(iraw, eraw, comp, eraw, dest.capacity()- dest.size());
}

template<class SequenceContainer, class Compare>
void flat_tree_container_inplace_sort_ending
   (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::false_)
{
   boost::movelib::adaptive_sort(it, dest.end(), comp);
}






template<class SequenceContainer, class Iterator, class Compare>
inline __attribute__ ((__always_inline__)) void flat_tree_merge_equal
   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::true_)
{
   dest.merge(first, last, comp);
}

template<class SequenceContainer, class Iterator, class Compare>
inline __attribute__ ((__always_inline__)) void flat_tree_merge_equal
   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
{
   typedef typename SequenceContainer::iterator iterator;
   iterator const it = dest.insert( dest.end(), first, last );
   dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
   (flat_tree_container_inplace_merge)(dest, it, comp, contiguous_tag);
}






template<class SequenceContainer, class Iterator, class Compare>
inline __attribute__ ((__always_inline__)) void flat_tree_merge_unique
   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::true_)
{
   dest.merge_unique(first, last, comp);
}

template<class SequenceContainer, class Iterator, class Compare>
inline __attribute__ ((__always_inline__)) void flat_tree_merge_unique
   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
{
   typedef typename SequenceContainer::iterator iterator;
   typedef typename SequenceContainer::size_type size_type;

   size_type const old_sz = dest.size();
   iterator const first_new = dest.insert(dest.cend(), first, last );
   iterator e = boost::movelib::inplace_set_difference(first_new, dest.end(), dest.begin(), first_new, comp);
   dest.erase(e, dest.end());
   dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
   (flat_tree_container_inplace_merge)(dest, dest.begin()+old_sz, comp, contiguous_tag);
}






template<class SequenceContainer, class Iterator>
inline __attribute__ ((__always_inline__)) typename SequenceContainer::size_type
   flat_tree_index_of
      (SequenceContainer& cont, Iterator p, dtl::true_)
{
   return cont.index_of(p);
}

template<class SequenceContainer, class Iterator>
inline __attribute__ ((__always_inline__)) typename SequenceContainer::size_type
   flat_tree_index_of
      (SequenceContainer& cont, Iterator p, dtl::false_)
{
   typedef typename SequenceContainer::size_type size_type;
   return static_cast<size_type>(p - cont.begin());
}






template<class Iterator, class SequenceContainer>
inline __attribute__ ((__always_inline__)) Iterator
   flat_tree_nth
      (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::true_)
{
   return cont.nth(n);
}

template<class Iterator, class SequenceContainer>
inline __attribute__ ((__always_inline__)) Iterator
   flat_tree_nth
      (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::false_)
{
   return cont.begin()+ n;
}






template<class SequenceContainer>
inline __attribute__ ((__always_inline__)) typename SequenceContainer::stored_allocator_type &
   flat_tree_get_stored_allocator
      (SequenceContainer& cont, dtl::true_)
{
   return cont.get_stored_allocator();
}

template<class SequenceContainer>
inline __attribute__ ((__always_inline__)) const typename SequenceContainer::stored_allocator_type &
   flat_tree_get_stored_allocator
      (const SequenceContainer& cont, dtl::true_)
{
   return cont.get_stored_allocator();
}

template<class SequenceContainer>
inline __attribute__ ((__always_inline__)) typename SequenceContainer::allocator_type
   flat_tree_get_stored_allocator
      (SequenceContainer& cont, dtl::false_)
{
   return cont.get_allocator();
}






template<class SequenceContainer, class Compare>
void flat_tree_sort_contiguous_to_adopt
   (SequenceContainer &tseq, SequenceContainer && seq, Compare comp)
{
   if(tseq.capacity() >= (seq.capacity() - seq.size())) {
      tseq.clear();
      boost::movelib::adaptive_sort
      (boost::movelib::iterator_to_raw_pointer(seq.begin())
         , boost::movelib::iterator_to_raw_pointer(seq.end())
         , comp
         , boost::movelib::iterator_to_raw_pointer(tseq.begin())
         , tseq.capacity());
   }
   else{
      boost::movelib::adaptive_sort
      (boost::movelib::iterator_to_raw_pointer(seq.begin())
         , boost::movelib::iterator_to_raw_pointer(seq.end())
         , comp
         , boost::movelib::iterator_to_raw_pointer(seq.end())
         , seq.capacity() - seq.size());
   }
}

template<class SequenceContainer, class Compare>
void flat_tree_adopt_sequence_equal
   (SequenceContainer &tseq, SequenceContainer && seq, Compare comp, dtl::true_)
{
   flat_tree_sort_contiguous_to_adopt(tseq, boost::move(seq), comp);
   tseq = boost::move(seq);
}

template<class SequenceContainer, class Compare>
void flat_tree_adopt_sequence_equal
   (SequenceContainer &tseq, SequenceContainer && seq, Compare comp, dtl::false_)
{
   boost::movelib::adaptive_sort(seq.begin(), seq.end(), comp);
   tseq = boost::move(seq);
}






template<class SequenceContainer, class Compare>
void flat_tree_adopt_sequence_unique
   (SequenceContainer &tseq, SequenceContainer && seq, Compare comp, dtl::true_)
{
   boost::movelib::pdqsort
      ( boost::movelib::iterator_to_raw_pointer(seq.begin())
      , boost::movelib::iterator_to_raw_pointer(seq.end())
      , comp);
   seq.erase(boost::movelib::unique
      (seq.begin(), seq.end(), boost::movelib::negate<Compare>(comp)), seq.cend());
   tseq = boost::move(seq);
}

template<class SequenceContainer, class Compare>
void flat_tree_adopt_sequence_unique
   (SequenceContainer &tseq, SequenceContainer && seq, Compare comp, dtl::false_)
{
   boost::movelib::pdqsort(seq.begin(), seq.end(), comp);
   seq.erase(boost::movelib::unique
      (seq.begin(), seq.end(), boost::movelib::negate<Compare>(comp)), seq.cend());
   tseq = boost::move(seq);
}






template<class SequenceContainer>
inline __attribute__ ((__always_inline__)) void
   flat_tree_reserve(SequenceContainer &tseq, typename SequenceContainer::size_type cap, dtl::true_)
{
   tseq.reserve(cap);
}

template<class SequenceContainer>
inline __attribute__ ((__always_inline__)) void
   flat_tree_reserve(SequenceContainer &, typename SequenceContainer::size_type, dtl::false_)
{
}






template<class SequenceContainer>
inline __attribute__ ((__always_inline__)) typename SequenceContainer::size_type
   flat_tree_capacity(const SequenceContainer &tseq, dtl::true_)
{
   return tseq.capacity();
}

template<class SequenceContainer>
inline __attribute__ ((__always_inline__)) typename SequenceContainer::size_type
   flat_tree_capacity(const SequenceContainer &tseq, dtl::false_)
{
   return tseq.size();
}







template<class Compare, class Value, class KeyOfValue>
class flat_tree_value_compare
   : private Compare
{
   typedef Value first_argument_type;
   typedef Value second_argument_type;
   typedef bool return_type;
   public:
   flat_tree_value_compare()
      : Compare()
   {}

   flat_tree_value_compare(const Compare &pred)
      : Compare(pred)
   {}

   bool operator()(const Value& lhs, const Value& rhs) const
   {
      KeyOfValue key_extract;
      return Compare::operator()(key_extract(lhs), key_extract(rhs));
   }

   const Compare &get_comp() const
      { return *this; }

   Compare &get_comp()
      { return *this; }
};






template < class Value, class AllocatorOrContainer
         , bool = boost::container::dtl::is_container<AllocatorOrContainer>::value >
struct select_container_type
{
   typedef AllocatorOrContainer type;
};

template <class Value, class AllocatorOrContainer>
struct select_container_type<Value, AllocatorOrContainer, false>
{
   typedef boost::container::vector<Value, AllocatorOrContainer> type;
};







template <class Value, class KeyOfValue,
          class Compare, class AllocatorOrContainer>
class flat_tree
{
   public:
   typedef typename select_container_type<Value, AllocatorOrContainer>::type container_type;
   typedef container_type sequence_type;

   private:
   typedef typename container_type::allocator_type allocator_t;
   typedef allocator_traits<allocator_t> allocator_traits_type;

   public:
   typedef flat_tree_value_compare<Compare, Value, KeyOfValue> value_compare;

   private:

   struct Data

      : public value_compare
   {
     

      public:
      Data()
         : value_compare(), m_seq()
      {}

      explicit Data(const allocator_t &alloc)
         : value_compare(), m_seq(alloc)
      {}

      explicit Data(const Compare &comp)
         : value_compare(comp), m_seq()
      {}

      Data(const Compare &comp, const allocator_t &alloc)
         : value_compare(comp), m_seq(alloc)
      {}

      explicit Data(const Data &d)
         : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq)
      {}

      Data(Data && d)
         : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq))
      {}

      Data(const Data &d, const allocator_t &a)
         : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq, a)
      {}

      Data(Data && d, const allocator_t &a)
         : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq), a)
      {}

      Data& operator=(const Data & d)
      {
         this->value_compare::operator=(d);
         m_seq = d.m_seq;
         return *this;
      }

      Data& operator=(Data && d)
      {
         this->value_compare::operator=(boost::move(static_cast<value_compare &>(d)));
         m_seq = boost::move(d.m_seq);
         return *this;
      }

      void swap(Data &d)
      {
         value_compare& mycomp = *this, & othercomp = d;
         boost::adl_move_swap(mycomp, othercomp);
         this->m_seq.swap(d.m_seq);
      }

      container_type m_seq;
   };

   Data m_data;
  

   public:

   typedef typename container_type::value_type value_type;
   typedef typename container_type::pointer pointer;
   typedef typename container_type::const_pointer const_pointer;
   typedef typename container_type::reference reference;
   typedef typename container_type::const_reference const_reference;
   typedef typename KeyOfValue::type key_type;
   typedef Compare key_compare;
   typedef typename container_type::allocator_type allocator_type;
   typedef typename container_type::size_type size_type;
   typedef typename container_type::difference_type difference_type;
   typedef typename container_type::iterator iterator;
   typedef typename container_type::const_iterator const_iterator;
   typedef typename container_type::reverse_iterator reverse_iterator;
   typedef typename container_type::const_reverse_iterator const_reverse_iterator;


   typedef typename boost::container::dtl:: boost_intrusive_default_type_stored_allocator_type< container_type, allocator_type >::type

                                                            stored_allocator_type;

   static const bool has_stored_allocator_type =
      boost::container::dtl:: boost_intrusive_has_type_stored_allocator_type< container_type >::value;

   private:
   typedef allocator_traits<stored_allocator_type> stored_allocator_traits;

   public:
   typedef typename dtl::if_c
      <has_stored_allocator_type, const stored_allocator_type &, allocator_type>::type get_stored_allocator_const_return_t;

   typedef typename dtl::if_c
      <has_stored_allocator_type, stored_allocator_type &, allocator_type>::type get_stored_allocator_noconst_return_t;

   inline __attribute__ ((__always_inline__)) flat_tree()
      : m_data()
   { }

   inline __attribute__ ((__always_inline__)) explicit flat_tree(const Compare& comp)
      : m_data(comp)
   { }

   inline __attribute__ ((__always_inline__)) explicit flat_tree(const allocator_type& a)
      : m_data(a)
   { }

   inline __attribute__ ((__always_inline__)) flat_tree(const Compare& comp, const allocator_type& a)
      : m_data(comp, a)
   { }

   inline __attribute__ ((__always_inline__)) flat_tree(const flat_tree& x)
      : m_data(x.m_data)
   { }

   inline __attribute__ ((__always_inline__)) flat_tree(flat_tree && x)
      noexcept((boost::container::dtl::is_nothrow_move_constructible<Compare>::value))
      : m_data(boost::move(x.m_data))
   { }

   inline __attribute__ ((__always_inline__)) flat_tree(const flat_tree& x, const allocator_type &a)
      : m_data(x.m_data, a)
   { }

   inline __attribute__ ((__always_inline__)) flat_tree(flat_tree && x, const allocator_type &a)
      : m_data(boost::move(x.m_data), a)
   { }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( ordered_range_t, InputIterator first, InputIterator last)
      : m_data()
   {
      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
      (static_cast<void> (0));
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
      : m_data(comp)
   {
      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
      (static_cast<void> (0));
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : m_data(comp, a)
   {
      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
      (static_cast<void> (0));
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last)
      : m_data()
   {
      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
      (static_cast<void> (0));
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
      : m_data(comp)
   {
      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
      (static_cast<void> (0));
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : m_data(comp, a)
   {
      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
      (static_cast<void> (0));
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( bool unique_insertion, InputIterator first, InputIterator last)
      : m_data()
   {
      this->priv_range_insertion_construct(unique_insertion, first, last);
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
            , const Compare& comp)
      : m_data(comp)
   {
      this->priv_range_insertion_construct(unique_insertion, first, last);
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
            , const allocator_type& a)
      : m_data(a)
   {
      this->priv_range_insertion_construct(unique_insertion, first, last);
   }

   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
            , const Compare& comp, const allocator_type& a)
      : m_data(comp, a)
   {
      this->priv_range_insertion_construct(unique_insertion, first, last);
   }

   inline __attribute__ ((__always_inline__)) ~flat_tree()
   {}

   inline __attribute__ ((__always_inline__)) flat_tree& operator=(const flat_tree & x)
   { m_data = x.m_data; return *this; }

   inline __attribute__ ((__always_inline__)) flat_tree& operator=(flat_tree && x)
      noexcept(((allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value) && boost::container::dtl::is_nothrow_move_assignable<Compare>::value))


   { m_data = boost::move(x.m_data); return *this; }

   inline __attribute__ ((__always_inline__)) const value_compare &priv_value_comp() const
   { return static_cast<const value_compare &>(this->m_data); }

   inline __attribute__ ((__always_inline__)) value_compare &priv_value_comp()
   { return static_cast<value_compare &>(this->m_data); }

   inline __attribute__ ((__always_inline__)) const key_compare &priv_key_comp() const
   { return this->priv_value_comp().get_comp(); }

   inline __attribute__ ((__always_inline__)) key_compare &priv_key_comp()
   { return this->priv_value_comp().get_comp(); }

   struct insert_commit_data
   {
      const_iterator position;
   };

   public:

   inline __attribute__ ((__always_inline__)) Compare key_comp() const
   { return this->m_data.get_comp(); }

   inline __attribute__ ((__always_inline__)) value_compare value_comp() const
   { return this->m_data; }

   inline __attribute__ ((__always_inline__)) allocator_type get_allocator() const
   { return this->m_data.m_seq.get_allocator(); }

   inline __attribute__ ((__always_inline__)) get_stored_allocator_const_return_t get_stored_allocator() const
   {
      return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
   }

   inline __attribute__ ((__always_inline__)) get_stored_allocator_noconst_return_t get_stored_allocator()
   {
      return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
   }

   inline __attribute__ ((__always_inline__)) iterator begin()
   { return this->m_data.m_seq.begin(); }

   inline __attribute__ ((__always_inline__)) const_iterator begin() const
   { return this->cbegin(); }

   inline __attribute__ ((__always_inline__)) const_iterator cbegin() const
   { return this->m_data.m_seq.begin(); }

   inline __attribute__ ((__always_inline__)) iterator end()
   { return this->m_data.m_seq.end(); }

   inline __attribute__ ((__always_inline__)) const_iterator end() const
   { return this->cend(); }

   inline __attribute__ ((__always_inline__)) const_iterator cend() const
   { return this->m_data.m_seq.end(); }

   inline __attribute__ ((__always_inline__)) reverse_iterator rbegin()
   { return reverse_iterator(this->end()); }

   inline __attribute__ ((__always_inline__)) const_reverse_iterator rbegin() const
   { return this->crbegin(); }

   inline __attribute__ ((__always_inline__)) const_reverse_iterator crbegin() const
   { return const_reverse_iterator(this->cend()); }

   inline __attribute__ ((__always_inline__)) reverse_iterator rend()
   { return reverse_iterator(this->begin()); }

   inline __attribute__ ((__always_inline__)) const_reverse_iterator rend() const
   { return this->crend(); }

   inline __attribute__ ((__always_inline__)) const_reverse_iterator crend() const
   { return const_reverse_iterator(this->cbegin()); }

   inline __attribute__ ((__always_inline__)) bool empty() const
   { return this->m_data.m_seq.empty(); }

   inline __attribute__ ((__always_inline__)) size_type size() const
   { return this->m_data.m_seq.size(); }

   inline __attribute__ ((__always_inline__)) size_type max_size() const
   { return this->m_data.m_seq.max_size(); }

   inline __attribute__ ((__always_inline__)) void swap(flat_tree& other)
      noexcept((allocator_traits_type::is_always_equal::value && boost::container::dtl::is_nothrow_swappable<Compare>::value))

   { this->m_data.swap(other.m_data); }

   public:

   std::pair<iterator,bool> insert_unique(const value_type& val)
   {
      std::pair<iterator,bool> ret;
      insert_commit_data data;
      ret.second = this->priv_insert_unique_prepare(KeyOfValue()(val), data);
      ret.first = ret.second ? this->priv_insert_commit(data, val)
                             : this->begin() + (data.position - this->cbegin());

      return ret;
   }

   std::pair<iterator,bool> insert_unique(value_type && val)
   {
      std::pair<iterator,bool> ret;
      insert_commit_data data;
      ret.second = this->priv_insert_unique_prepare(KeyOfValue()(val), data);
      ret.first = ret.second ? this->priv_insert_commit(data, boost::move(val))
                             : this->begin() + (data.position - this->cbegin());

      return ret;
   }

   iterator insert_equal(const value_type& val)
   {
      iterator i = this->upper_bound(KeyOfValue()(val));
      i = this->m_data.m_seq.insert(i, val);
      return i;
   }

   iterator insert_equal(value_type && mval)
   {
      iterator i = this->upper_bound(KeyOfValue()(mval));
      i = this->m_data.m_seq.insert(i, boost::move(mval));
      return i;
   }

   iterator insert_unique(const_iterator hint, const value_type& val)
   {
      (static_cast<void> (0));
      insert_commit_data data;
      return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
            ? this->priv_insert_commit(data, val)
            : this->begin() + (data.position - this->cbegin());

   }

   iterator insert_unique(const_iterator hint, value_type && val)
   {
      (static_cast<void> (0));
      insert_commit_data data;
      return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
         ? this->priv_insert_commit(data, boost::move(val))
         : this->begin() + (data.position - this->cbegin());

   }

   iterator insert_equal(const_iterator hint, const value_type& val)
   {
      (static_cast<void> (0));
      insert_commit_data data;
      this->priv_insert_equal_prepare(hint, val, data);
      return this->priv_insert_commit(data, val);
   }

   iterator insert_equal(const_iterator hint, value_type && mval)
   {
      (static_cast<void> (0));
      insert_commit_data data;
      this->priv_insert_equal_prepare(hint, mval, data);
      return this->priv_insert_commit(data, boost::move(mval));
   }

   template <class InIt>
   void insert_unique(InIt first, InIt last)
   {
      dtl::bool_<is_contiguous_container<container_type>::value> contiguous_tag;
      container_type &seq = this->m_data.m_seq;
      value_compare &val_cmp = this->priv_value_comp();


      typename container_type::iterator const it = seq.insert(seq.cend(), first, last);


      boost::movelib::pdqsort(it, seq.end(), val_cmp);


      typename container_type::iterator const e = boost::movelib::inplace_set_unique_difference
         (it, seq.end(), seq.begin(), it, val_cmp);
      seq.erase(e, seq.cend());


      (flat_tree_container_inplace_merge)(seq, it, this->priv_value_comp(), contiguous_tag);
   }

   template <class InIt>
   void insert_equal(InIt first, InIt last)
   {
      dtl::bool_<is_contiguous_container<container_type>::value> contiguous_tag;
      container_type &seq = this->m_data.m_seq;
      typename container_type::iterator const it = seq.insert(seq.cend(), first, last);
      (flat_tree_container_inplace_sort_ending)(seq, it, this->priv_value_comp(), contiguous_tag);
      (flat_tree_container_inplace_merge) (seq, it, this->priv_value_comp(), contiguous_tag);
   }



   template <class InIt>
   void insert_equal(ordered_range_t, InIt first, InIt last)
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_merge_unique<container_type, InIt, InIt, value_compare>::value;
      (flat_tree_merge_equal)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());
   }

   template <class InIt>
   void insert_unique(ordered_unique_range_t, InIt first, InIt last)
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_merge_unique<container_type, InIt, InIt, value_compare>::value;
      (flat_tree_merge_unique)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());
   }



   template <class... Args>
   std::pair<iterator, bool> emplace_unique(Args &&... args)
   {
      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
      stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
      value_destructor<stored_allocator_type, value_type> d(a, val);
      return this->insert_unique(::boost::move(val));
   }

   template <class... Args>
   iterator emplace_hint_unique(const_iterator hint, Args &&... args)
   {

      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
      stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
      value_destructor<stored_allocator_type, value_type> d(a, val);
      return this->insert_unique(hint, ::boost::move(val));
   }

   template <class... Args>
   iterator emplace_equal(Args &&... args)
   {
      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
      stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
      value_destructor<stored_allocator_type, value_type> d(a, val);
      return this->insert_equal(::boost::move(val));
   }

   template <class... Args>
   iterator emplace_hint_equal(const_iterator hint, Args &&... args)
   {

      typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
      value_type &val = *static_cast<value_type *>(static_cast<void *>(v.data));
      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
      stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
      value_destructor<stored_allocator_type, value_type> d(a, val);
      return this->insert_equal(hint, ::boost::move(val));
   }

   template <class KeyType, class... Args>
   inline __attribute__ ((__always_inline__)) std::pair<iterator, bool> try_emplace
      (const_iterator hint, KeyType && key, Args &&... args)
   {
      std::pair<iterator,bool> ret;
      insert_commit_data data;
      const key_type & k = key;
      ret.second = hint == const_iterator()
         ? this->priv_insert_unique_prepare(k, data)
         : this->priv_insert_unique_prepare(hint, k, data);

      if(!ret.second){
         ret.first = this->nth(data.position - this->cbegin());
      }
      else{
         typedef typename emplace_functor_type<try_emplace_t, KeyType, Args...>::type func_t;
         typedef emplace_iterator<value_type, func_t, difference_type> it_t;
         func_t func(try_emplace_t(), ::boost::forward<KeyType>(key), ::boost::forward<Args>(args)...);
         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
      }
      return ret;
   }
# 1063 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 3 4
   template<class KeyType, class M>
   std::pair<iterator, bool> insert_or_assign(const_iterator hint, KeyType && key, M && obj)
   {
      const key_type& k = key;
      std::pair<iterator,bool> ret;
      insert_commit_data data;
      ret.second = hint == const_iterator()
         ? this->priv_insert_unique_prepare(k, data)
         : this->priv_insert_unique_prepare(hint, k, data);
      if(!ret.second){
         ret.first = this->nth(data.position - this->cbegin());
         ret.first->second = boost::forward<M>(obj);
      }
      else{
         typedef typename emplace_functor_type<KeyType, M>::type func_t;
         typedef emplace_iterator<value_type, func_t, difference_type> it_t;
         func_t func(boost::forward<KeyType>(key), boost::forward<M>(obj));
         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
      }
      return ret;
   }

   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator position)
   { return this->m_data.m_seq.erase(position); }

   size_type erase(const key_type& k)
   {
      std::pair<iterator,iterator > itp = this->equal_range(k);
      size_type ret = static_cast<size_type>(itp.second-itp.first);
      if (ret){
         this->m_data.m_seq.erase(itp.first, itp.second);
      }
      return ret;
   }

   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator first, const_iterator last)
   { return this->m_data.m_seq.erase(first, last); }

   inline __attribute__ ((__always_inline__)) void clear()
   { this->m_data.m_seq.clear(); }







   inline __attribute__ ((__always_inline__)) void shrink_to_fit()
   { this->m_data.m_seq.shrink_to_fit(); }

   inline __attribute__ ((__always_inline__)) iterator nth(size_type n) noexcept
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_nth<container_type, size_type>::value;
      return flat_tree_nth<iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
   }

   inline __attribute__ ((__always_inline__)) const_iterator nth(size_type n) const noexcept
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_nth<container_type, size_type>::value;
      return flat_tree_nth<const_iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
   }

   inline __attribute__ ((__always_inline__)) size_type index_of(iterator p) noexcept
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_index_of<container_type, iterator>::value;
      return flat_tree_index_of(this->m_data.m_seq, p, dtl::bool_<value>());
   }

   inline __attribute__ ((__always_inline__)) size_type index_of(const_iterator p) const noexcept
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_index_of<container_type, const_iterator>::value;
      return flat_tree_index_of(this->m_data.m_seq, p, dtl::bool_<value>());
   }


   iterator find(const key_type& k)
   {
      iterator i = this->lower_bound(k);
      iterator end_it = this->end();
      if (i != end_it && this->m_data.get_comp()(k, KeyOfValue()(*i))){
         i = end_it;
      }
      return i;
   }

   const_iterator find(const key_type& k) const
   {
      const_iterator i = this->lower_bound(k);

      const_iterator end_it = this->cend();
      if (i != end_it && this->m_data.get_comp()(k, KeyOfValue()(*i))){
         i = end_it;
      }
      return i;
   }


   size_type count(const key_type& k) const
   {
      std::pair<const_iterator, const_iterator> p = this->equal_range(k);
      size_type n = p.second - p.first;
      return n;
   }

   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge_unique(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
   {
      this->insert( boost::make_move_iterator(source.begin())
                  , boost::make_move_iterator(source.end()));
   }

   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge_equal(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
   {
      this->insert( boost::make_move_iterator(source.begin())
                  , boost::make_move_iterator(source.end()));
   }

   inline __attribute__ ((__always_inline__)) void merge_unique(flat_tree& source)
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
      (flat_tree_merge_unique)
         ( this->m_data.m_seq
         , boost::make_move_iterator(source.m_data.m_seq.begin())
         , boost::make_move_iterator(source.m_data.m_seq.end())
         , this->priv_value_comp()
         , dtl::bool_<value>());
   }

   inline __attribute__ ((__always_inline__)) void merge_equal(flat_tree& source)
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_merge<container_type, iterator, iterator, value_compare>::value;
      (flat_tree_merge_equal)
         ( this->m_data.m_seq
         , boost::make_move_iterator(source.m_data.m_seq.begin())
         , boost::make_move_iterator(source.m_data.m_seq.end())
         , this->priv_value_comp()
         , dtl::bool_<value>());
   }

   inline __attribute__ ((__always_inline__)) iterator lower_bound(const key_type& k)
   { return this->priv_lower_bound(this->begin(), this->end(), k); }

   inline __attribute__ ((__always_inline__)) const_iterator lower_bound(const key_type& k) const
   { return this->priv_lower_bound(this->cbegin(), this->cend(), k); }

   inline __attribute__ ((__always_inline__)) iterator upper_bound(const key_type& k)
   { return this->priv_upper_bound(this->begin(), this->end(), k); }

   inline __attribute__ ((__always_inline__)) const_iterator upper_bound(const key_type& k) const
   { return this->priv_upper_bound(this->cbegin(), this->cend(), k); }

   inline __attribute__ ((__always_inline__)) std::pair<iterator,iterator> equal_range(const key_type& k)
   { return this->priv_equal_range(this->begin(), this->end(), k); }

   inline __attribute__ ((__always_inline__)) std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
   { return this->priv_equal_range(this->cbegin(), this->cend(), k); }

   inline __attribute__ ((__always_inline__)) std::pair<iterator, iterator> lower_bound_range(const key_type& k)
   { return this->priv_lower_bound_range(this->begin(), this->end(), k); }

   inline __attribute__ ((__always_inline__)) std::pair<const_iterator, const_iterator> lower_bound_range(const key_type& k) const
   { return this->priv_lower_bound_range(this->cbegin(), this->cend(), k); }

   inline __attribute__ ((__always_inline__)) size_type capacity() const
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_capacity<container_type>::value;
      return (flat_tree_capacity)(this->m_data.m_seq, dtl::bool_<value>());
   }

   inline __attribute__ ((__always_inline__)) void reserve(size_type cnt)
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_reserve<container_type, size_type>::value;
      (flat_tree_reserve)(this->m_data.m_seq, cnt, dtl::bool_<value>());
   }

   inline __attribute__ ((__always_inline__)) container_type extract_sequence()
   {
      return boost::move(m_data.m_seq);
   }

   inline __attribute__ ((__always_inline__)) container_type &get_sequence_ref()
   {
      return m_data.m_seq;
   }

   inline __attribute__ ((__always_inline__)) void adopt_sequence_equal(container_type && seq)
   {
      (flat_tree_adopt_sequence_equal)( m_data.m_seq, boost::move(seq), this->priv_value_comp()
         , dtl::bool_<is_contiguous_container<container_type>::value>());
   }

   inline __attribute__ ((__always_inline__)) void adopt_sequence_unique(container_type && seq)
   {
      (flat_tree_adopt_sequence_unique)(m_data.m_seq, boost::move(seq), this->priv_value_comp()
         , dtl::bool_<is_contiguous_container<container_type>::value>());
   }

   void adopt_sequence_equal(ordered_range_t, container_type && seq)
   {
      (static_cast<void> (0));
      m_data.m_seq = boost::move(seq);
   }

   void adopt_sequence_unique(ordered_unique_range_t, container_type && seq)
   {
      (static_cast<void> (0));
      m_data.m_seq = boost::move(seq);
   }

   inline __attribute__ ((__always_inline__)) friend bool operator==(const flat_tree& x, const flat_tree& y)
   {
      return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());
   }

   inline __attribute__ ((__always_inline__)) friend bool operator<(const flat_tree& x, const flat_tree& y)
   {
      return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
   }

   inline __attribute__ ((__always_inline__)) friend bool operator!=(const flat_tree& x, const flat_tree& y)
      { return !(x == y); }

   inline __attribute__ ((__always_inline__)) friend bool operator>(const flat_tree& x, const flat_tree& y)
      { return y < x; }

   inline __attribute__ ((__always_inline__)) friend bool operator<=(const flat_tree& x, const flat_tree& y)
      { return !(y < x); }

   inline __attribute__ ((__always_inline__)) friend bool operator>=(const flat_tree& x, const flat_tree& y)
      { return !(x < y); }

   inline __attribute__ ((__always_inline__)) friend void swap(flat_tree& x, flat_tree& y)
      { x.swap(y); }

   private:

   template <class InputIterator>
   void priv_range_insertion_construct( bool unique_insertion, InputIterator first, InputIterator last)
   {




      if(unique_insertion){
         this->insert_unique(first, last);
      }
      else{
         this->insert_equal (first, last);
      }
   }

   inline __attribute__ ((__always_inline__)) bool priv_in_range_or_end(const_iterator pos) const
   {
      return (this->begin() <= pos) && (pos <= this->end());
   }


   void priv_insert_equal_prepare
      (const_iterator pos, const value_type& val, insert_commit_data &data)
   {
# 1341 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 3 4
      const value_compare &val_cmp = this->m_data;

      if(pos == this->cend() || !val_cmp(*pos, val)){
         if (pos == this->cbegin() || !val_cmp(val, pos[-1])){
            data.position = pos;
         }
         else{
            data.position =
               this->priv_upper_bound(this->cbegin(), pos, KeyOfValue()(val));
         }
      }
      else{
         data.position =
            this->priv_lower_bound(pos, this->cend(), KeyOfValue()(val));
      }
   }

   bool priv_insert_unique_prepare
      (const_iterator b, const_iterator e, const key_type& k, insert_commit_data &commit_data)
   {
      const key_compare &key_cmp = this->priv_key_comp();
      commit_data.position = this->priv_lower_bound(b, e, k);
      return commit_data.position == e || key_cmp(k, KeyOfValue()(*commit_data.position));
   }

   inline __attribute__ ((__always_inline__)) bool priv_insert_unique_prepare
      (const key_type& k, insert_commit_data &commit_data)
   { return this->priv_insert_unique_prepare(this->cbegin(), this->cend(), k, commit_data); }

   bool priv_insert_unique_prepare
      (const_iterator pos, const key_type& k, insert_commit_data &commit_data)
   {
# 1384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 3 4
      const key_compare &key_cmp = this->priv_key_comp();
      const const_iterator cend_it = this->cend();
      if(pos == cend_it || key_cmp(k, KeyOfValue()(*pos))){
         const const_iterator cbeg = this->cbegin();
         commit_data.position = pos;
         if(pos == cbeg){
            return true;
         }
         const_iterator prev(pos);
         --prev;
         if(key_cmp(KeyOfValue()(*prev), k)){
            return true;
         }
         else if(!key_cmp(k, KeyOfValue()(*prev))){
            commit_data.position = prev;
            return false;
         }
         else{

            return this->priv_insert_unique_prepare(cbeg, prev, k, commit_data);
         }
      }
      else{


         return this->priv_insert_unique_prepare(pos, cend_it, k, commit_data);
      }
   }

   template<class Convertible>
   inline __attribute__ ((__always_inline__)) iterator priv_insert_commit
      (insert_commit_data &commit_data, Convertible && convertible)
   {
      return this->m_data.m_seq.insert
         ( commit_data.position
         , boost::forward<Convertible>(convertible));
   }

   template <class RanIt>
   RanIt priv_lower_bound(RanIt first, const RanIt last,
                          const key_type & key) const
   {
      const Compare &key_cmp = this->m_data.get_comp();
      KeyOfValue key_extract;
      size_type len = static_cast<size_type>(last - first);
      RanIt middle;

      while (len) {
         size_type step = len >> 1;
         middle = first;
         middle += step;

         if (key_cmp(key_extract(*middle), key)) {
            first = ++middle;
            len -= step + 1;
         }
         else{
            len = step;
         }
      }
      return first;
   }

   template <class RanIt>
   RanIt priv_upper_bound
      (RanIt first, const RanIt last,const key_type & key) const
   {
      const Compare &key_cmp = this->m_data.get_comp();
      KeyOfValue key_extract;
      size_type len = static_cast<size_type>(last - first);
      RanIt middle;

      while (len) {
         size_type step = len >> 1;
         middle = first;
         middle += step;

         if (key_cmp(key, key_extract(*middle))) {
            len = step;
         }
         else{
            first = ++middle;
            len -= step + 1;
         }
      }
      return first;
   }

   template <class RanIt>
   std::pair<RanIt, RanIt>
      priv_equal_range(RanIt first, RanIt last, const key_type& key) const
   {
      const Compare &key_cmp = this->m_data.get_comp();
      KeyOfValue key_extract;
      size_type len = static_cast<size_type>(last - first);
      RanIt middle;

      while (len) {
         size_type step = len >> 1;
         middle = first;
         middle += step;

         if (key_cmp(key_extract(*middle), key)){
            first = ++middle;
            len -= step + 1;
         }
         else if (key_cmp(key, key_extract(*middle))){
            len = step;
         }
         else {

            last = first;
            last += len;
            RanIt const first_ret = this->priv_lower_bound(first, middle, key);
            return std::pair<RanIt, RanIt>
               ( first_ret, this->priv_upper_bound(++middle, last, key));
         }
      }
      return std::pair<RanIt, RanIt>(first, first);
   }

   template<class RanIt>
   std::pair<RanIt, RanIt> priv_lower_bound_range(RanIt first, RanIt last, const key_type& k) const
   {
      const Compare &key_cmp = this->m_data.get_comp();
      KeyOfValue key_extract;
      RanIt lb(this->priv_lower_bound(first, last, k)), ub(lb);
      if(lb != last && static_cast<difference_type>(!key_cmp(k, key_extract(*lb)))){
         ++ub;
      }
      return std::pair<RanIt, RanIt>(lb, ub);
   }
};

}

}



template <class T, class KeyOfValue,
class Compare, class AllocatorOrContainer>
struct has_trivial_destructor_after_move<boost::container::dtl::flat_tree<T, KeyOfValue, Compare, AllocatorOrContainer> >
{
   typedef typename boost::container::dtl::select_container_type<T, AllocatorOrContainer>::type container_type;
   typedef typename container_type::allocator_type allocator_t;
   typedef typename ::boost::container::allocator_traits<allocator_t>::pointer pointer;
   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_t>::value &&
                             ::boost::has_trivial_destructor_after_move<pointer>::value;
};

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 1538 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/flat_tree.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/container_or_allocator_rebind.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/container_or_allocator_rebind.hpp" 3 4
         



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/container_rebind.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/container_rebind.hpp" 3 4
         





namespace boost {
namespace container {
namespace dtl {

   template <class Cont, class U>
   struct container_rebind;



   template <template <class, class, class...> class Cont, typename V, typename A, class... An, class U>
   struct container_rebind<Cont<V, A, An...>, U>
   {
      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, An...> type;
   };


   template <template <class, class> class Cont, typename V, typename A, class U>
   struct container_rebind<Cont<V, A>, U>
   {
      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
   };

   template <template <class> class Cont, typename V, class U>
   struct container_rebind<Cont<V>, U>
   {
      typedef Cont<U> type;
   };



   template <template <class, std::size_t, class, class...> class Cont, typename V, std::size_t N, typename A, class... An, class U>
   struct container_rebind<Cont<V, N, A, An...>, U>
   {
      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, An...> type;
   };


   template <template <class, std::size_t, class> class Cont, typename V, std::size_t N, typename A, class U>
   struct container_rebind<Cont<V, N, A>, U>
   {
      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
   };

   template <template <class, std::size_t> class Cont, typename V, std::size_t N, class U>
   struct container_rebind<Cont<V, N>, U>
   {
      typedef Cont<U, N> type;
   };
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/container_rebind.hpp" 3 4
}
}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/container_or_allocator_rebind.hpp" 2 3 4


namespace boost {
namespace container {
namespace dtl {

template<class AllocatorOrContainer, class ToType, bool = is_container<AllocatorOrContainer>::value>
struct container_or_allocator_rebind_impl
   : container_rebind<AllocatorOrContainer, ToType>
{};

template<class AllocatorOrContainer, class ToType>
struct container_or_allocator_rebind_impl<AllocatorOrContainer, ToType, false>
   : allocator_traits<AllocatorOrContainer>::template portable_rebind_alloc<ToType>

{};

template<class AllocatorOrContainer, class ToType>
struct container_or_allocator_rebind
   : container_or_allocator_rebind_impl<AllocatorOrContainer, ToType>
{};

}
}
}
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/minimal_less_equal_header.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/minimal_less_equal_header.hpp" 3 4
         
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 2 3 4







namespace boost {
namespace container {



template <class Key, class T, class Compare, class AllocatorOrContainer>
class flat_multimap;

namespace dtl{

template<class D, class S>
inline __attribute__ ((__always_inline__)) static D &force(S &s)
{ return *reinterpret_cast<D*>(&s); }

template<class D, class S>
inline __attribute__ ((__always_inline__)) static D force_copy(const S &s)
{
   const D *const vp = reinterpret_cast<const D *>(&s);
   D ret_val(*vp);
   return ret_val;
}

}
# 110 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
template <class Key, class T, class Compare, class AllocatorOrContainer>

class flat_map
{

   private:
  

   typedef dtl::flat_tree<
                           std::pair<Key, T>,
                           dtl::select1st<Key>,
                           Compare,
                           AllocatorOrContainer> tree_t;


   typedef dtl::flat_tree<
                           dtl::pair<Key, T>,
                           dtl::select1st<Key>,
                           Compare,
                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type
                           > impl_tree_t;
   impl_tree_t m_flat_tree;

   typedef typename impl_tree_t::value_type impl_value_type;
   typedef typename impl_tree_t::const_iterator impl_const_iterator;
   typedef typename impl_tree_t::iterator impl_iterator;
   typedef typename impl_tree_t::allocator_type impl_allocator_type;

   typedef std::initializer_list<impl_value_type> impl_initializer_list;


   typedef dtl::flat_tree_value_compare
      < Compare
      , dtl::select1st<Key>
      , std::pair<Key, T> > value_compare_t;
   typedef typename tree_t::iterator iterator_t;
   typedef typename tree_t::const_iterator const_iterator_t;
   typedef typename tree_t::reverse_iterator reverse_iterator_t;
   typedef typename tree_t::const_reverse_iterator const_reverse_iterator_t;

   public:
   typedef typename impl_tree_t::stored_allocator_type impl_stored_allocator_type;
   typedef typename impl_tree_t::sequence_type impl_sequence_type;

   inline __attribute__ ((__always_inline__)) impl_tree_t &tree()
   { return m_flat_tree; }

   inline __attribute__ ((__always_inline__)) const impl_tree_t &tree() const
   { return m_flat_tree; }

   private:
   typedef typename tree_t::get_stored_allocator_const_return_t get_stored_allocator_const_return_t;
   typedef typename tree_t::get_stored_allocator_noconst_return_t get_stored_allocator_noconst_return_t;
   typedef typename impl_tree_t::get_stored_allocator_const_return_t impl_get_stored_allocator_const_return_t;
   typedef typename impl_tree_t::get_stored_allocator_noconst_return_t impl_get_stored_allocator_noconst_return_t;



   public:






   typedef Key key_type;
   typedef T mapped_type;
   typedef Compare key_compare;
   typedef std::pair<Key, T> value_type;
   typedef typename tree_t::sequence_type sequence_type;
   typedef typename sequence_type::allocator_type allocator_type;
   typedef ::boost::container::allocator_traits<allocator_type> allocator_traits_type;
   typedef typename sequence_type::pointer pointer;
   typedef typename sequence_type::const_pointer const_pointer;
   typedef typename sequence_type::reference reference;
   typedef typename sequence_type::const_reference const_reference;
   typedef typename sequence_type::size_type size_type;
   typedef typename sequence_type::difference_type difference_type;
   typedef typename tree_t::stored_allocator_type stored_allocator_type;
   typedef typename tree_t::value_compare value_compare;

   typedef typename sequence_type::iterator iterator;
   typedef typename sequence_type::const_iterator const_iterator;
   typedef typename sequence_type::reverse_iterator reverse_iterator;
   typedef typename sequence_type::const_reverse_iterator const_reverse_iterator;
   typedef impl_value_type movable_value_type;


   static_assert((dtl::is_same<std::pair<Key, T>, typename allocator_type::value_type>::value), "(dtl::is_same<std::pair<Key, T>, typename allocator_type::value_type>::value)");
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_map() noexcept((dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value && dtl::is_nothrow_default_constructible<Compare>::value))

      : m_flat_tree()
   {}




   inline __attribute__ ((__always_inline__)) explicit flat_map(const allocator_type& a)
      : m_flat_tree(dtl::force<const impl_allocator_type>(a))
   {}





   inline __attribute__ ((__always_inline__)) explicit flat_map(const Compare& comp)
      : m_flat_tree(comp)
   {}





   inline __attribute__ ((__always_inline__)) flat_map(const Compare& comp, const allocator_type& a)
      : m_flat_tree(comp, dtl::force<const impl_allocator_type>(a))
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_map(InputIterator first, InputIterator last)
      : m_flat_tree(true, first, last)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_map(InputIterator first, InputIterator last, const allocator_type& a)
      : m_flat_tree(true, first, last, dtl::force<const impl_allocator_type>(a))
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_map(InputIterator first, InputIterator last, const Compare& comp)
      : m_flat_tree(true, first, last, comp)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_map(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : m_flat_tree(true, first, last, comp, dtl::force<const impl_allocator_type>(a))
   {}
# 286 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last)
      : m_flat_tree(ordered_range, first, last)
   {}
# 301 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
      : m_flat_tree(ordered_range, first, last, comp)
   {}
# 316 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : m_flat_tree(ordered_range, first, last, comp, dtl::force<const impl_allocator_type>(a))
   {}







   inline __attribute__ ((__always_inline__)) flat_map(std::initializer_list<value_type> il)
     : m_flat_tree( true
                  , dtl::force<impl_initializer_list>(il).begin()
                  , dtl::force<impl_initializer_list>(il).end())
   {}






   inline __attribute__ ((__always_inline__)) flat_map(std::initializer_list<value_type> il, const allocator_type& a)
     : m_flat_tree( true
                  , dtl::force<impl_initializer_list>(il).begin()
                  , dtl::force<impl_initializer_list>(il).end()
                  , dtl::force<const impl_allocator_type>(a))
   {}






   inline __attribute__ ((__always_inline__)) flat_map(std::initializer_list<value_type> il, const Compare& comp)
     : m_flat_tree(true
                  , dtl::force<impl_initializer_list>(il).begin()
                  , dtl::force<impl_initializer_list>(il).end()
                  , comp)
   {}






   inline __attribute__ ((__always_inline__)) flat_map(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
     : m_flat_tree(true
                  , dtl::force<impl_initializer_list>(il).begin()
                  , dtl::force<impl_initializer_list>(il).end()
                  , comp
                  , dtl::force<const impl_allocator_type>(a))
   {}
# 381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_map(ordered_unique_range_t, std::initializer_list<value_type> il)
     : m_flat_tree(ordered_unique_range
                  , dtl::force<impl_initializer_list>(il).begin()
                  , dtl::force<impl_initializer_list>(il).end())
   {}
# 397 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
     : m_flat_tree(ordered_unique_range
                  , dtl::force<impl_initializer_list>(il).begin()
                  , dtl::force<impl_initializer_list>(il).end()
                  , comp)
   {}
# 414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
     : m_flat_tree( ordered_unique_range
                  , dtl::force<impl_initializer_list>(il).begin()
                  , dtl::force<impl_initializer_list>(il).end()
                  , comp
                  , dtl::force<const impl_allocator_type>(a))
   {}





   inline __attribute__ ((__always_inline__)) flat_map(const flat_map& x)
      : m_flat_tree(x.m_flat_tree)
   {}







   inline __attribute__ ((__always_inline__)) flat_map(flat_map && x)
      noexcept((boost::container::dtl::is_nothrow_move_constructible<Compare>::value))
      : m_flat_tree(boost::move(x.m_flat_tree))
   {}




   inline __attribute__ ((__always_inline__)) flat_map(const flat_map& x, const allocator_type &a)
      : m_flat_tree(x.m_flat_tree, dtl::force<const impl_allocator_type>(a))
   {}





   inline __attribute__ ((__always_inline__)) flat_map(flat_map && x, const allocator_type &a)
      : m_flat_tree(boost::move(x.m_flat_tree), dtl::force<const impl_allocator_type>(a))
   {}




   inline __attribute__ ((__always_inline__)) flat_map& operator=(const flat_map & x)
   { m_flat_tree = x.m_flat_tree; return *this; }
# 471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_map& operator=(flat_map && x)
      noexcept(((allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value) && boost::container::dtl::is_nothrow_move_assignable<Compare>::value))


   { m_flat_tree = boost::move(x.m_flat_tree); return *this; }



   flat_map& operator=(std::initializer_list<value_type> il)
   {
      this->clear();
      this->insert(il.begin(), il.end());
      return *this;
   }






   inline __attribute__ ((__always_inline__)) allocator_type get_allocator() const noexcept
      { return dtl::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
# 501 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) get_stored_allocator_noconst_return_t get_stored_allocator() noexcept
   {
      impl_get_stored_allocator_noconst_return_t r = m_flat_tree.get_stored_allocator();
      return dtl::force<stored_allocator_type>(r);
   }
# 514 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) get_stored_allocator_const_return_t get_stored_allocator() const noexcept
   {
      impl_get_stored_allocator_const_return_t r = m_flat_tree.get_stored_allocator();
      return dtl::force<const stored_allocator_type>(r);
   }
# 531 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator begin() noexcept
      { return dtl::force_copy<iterator>(m_flat_tree.begin()); }






   inline __attribute__ ((__always_inline__)) const_iterator begin() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.begin()); }






   inline __attribute__ ((__always_inline__)) iterator end() noexcept
      { return dtl::force_copy<iterator>(m_flat_tree.end()); }






   inline __attribute__ ((__always_inline__)) const_iterator end() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.end()); }







   inline __attribute__ ((__always_inline__)) reverse_iterator rbegin() noexcept
      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator rbegin() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }







   inline __attribute__ ((__always_inline__)) reverse_iterator rend() noexcept
      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rend()); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator rend() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }






   inline __attribute__ ((__always_inline__)) const_iterator cbegin() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.cbegin()); }






   inline __attribute__ ((__always_inline__)) const_iterator cend() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.cend()); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator crbegin() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator crend() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
# 639 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) bool empty() const noexcept
      { return m_flat_tree.empty(); }






   inline __attribute__ ((__always_inline__)) size_type size() const noexcept
      { return m_flat_tree.size(); }






   inline __attribute__ ((__always_inline__)) size_type max_size() const noexcept
      { return m_flat_tree.max_size(); }







   inline __attribute__ ((__always_inline__)) size_type capacity() const noexcept
      { return m_flat_tree.capacity(); }
# 677 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void reserve(size_type cnt)
      { m_flat_tree.reserve(cnt); }







   inline __attribute__ ((__always_inline__)) void shrink_to_fit()
      { m_flat_tree.shrink_to_fit(); }
# 716 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
      inline __attribute__ ((__always_inline__)) mapped_type& operator[](const key_type & x) { return this->priv_subscript(x); } inline __attribute__ ((__always_inline__)) mapped_type& operator[](key_type && x) { return this->priv_subscript(::boost::move(x)); }
# 731 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class M>
   inline __attribute__ ((__always_inline__)) std::pair<iterator, bool> insert_or_assign(const key_type& k, M && obj)
   {
      return dtl::force_copy< std::pair<iterator, bool> >
         (this->m_flat_tree.insert_or_assign
            ( impl_const_iterator(), k, ::boost::forward<M>(obj))
         );
   }
# 752 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class M>
   inline __attribute__ ((__always_inline__)) std::pair<iterator, bool> insert_or_assign(key_type && k, M && obj)
   {
      return dtl::force_copy< std::pair<iterator, bool> >
         (this->m_flat_tree.insert_or_assign
            ( impl_const_iterator(), ::boost::move(k), ::boost::forward<M>(obj))
         );
   }
# 775 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class M>
   inline __attribute__ ((__always_inline__)) iterator insert_or_assign(const_iterator hint, const key_type& k, M && obj)
   {
      return dtl::force_copy< std::pair<iterator, bool> >
         (this->m_flat_tree.insert_or_assign
            ( dtl::force_copy<impl_const_iterator>(hint)
            , k, ::boost::forward<M>(obj))
         );
   }
# 799 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class M>
   inline __attribute__ ((__always_inline__)) iterator insert_or_assign(const_iterator hint, key_type && k, M && obj)
   {
      return dtl::force_copy< std::pair<iterator, bool> >
         (this->m_flat_tree.insert_or_assign
            ( dtl::force_copy<impl_const_iterator>(hint)
            , ::boost::move(k), ::boost::forward<M>(obj))
         );
   }


   inline __attribute__ ((__always_inline__)) iterator nth(size_type n) noexcept
   { return dtl::force_copy<iterator>(m_flat_tree.nth(n)); }


   inline __attribute__ ((__always_inline__)) const_iterator nth(size_type n) const noexcept
   { return dtl::force_copy<iterator>(m_flat_tree.nth(n)); }


   inline __attribute__ ((__always_inline__)) size_type index_of(iterator p) noexcept
   { return m_flat_tree.index_of(dtl::force_copy<impl_iterator>(p)); }


   inline __attribute__ ((__always_inline__)) size_type index_of(const_iterator p) const noexcept
   { return m_flat_tree.index_of(dtl::force_copy<impl_const_iterator>(p)); }






   T& at(const key_type& k)
   {
      iterator i = this->find(k);
      if(i == this->end()){
         throw_out_of_range("flat_map::at key not found");
      }
      return i->second;
   }






   const T& at(const key_type& k) const
   {
      const_iterator i = this->find(k);
      if(i == this->end()){
         throw_out_of_range("flat_map::at key not found");
      }
      return i->second;
   }
# 873 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) std::pair<iterator,bool> emplace(Args &&... args)
   { return dtl::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
# 889 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) iterator emplace_hint(const_iterator hint, Args &&... args)
   {
      return dtl::force_copy<iterator>
         (m_flat_tree.emplace_hint_unique( dtl::force_copy<impl_const_iterator>(hint)
                                         , boost::forward<Args>(args)...));
   }
# 908 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) std::pair<iterator, bool> try_emplace(const key_type& k, Args &&... args)
   {
      return dtl::force_copy< std::pair<iterator, bool> >(
         m_flat_tree.try_emplace(impl_const_iterator(), k, boost::forward<Args>(args)...));
   }
# 926 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) iterator try_emplace(const_iterator hint, const key_type &k, Args &&... args)
   {
      return dtl::force_copy<iterator>(m_flat_tree.try_emplace
         (dtl::force_copy<impl_const_iterator>(hint), k, boost::forward<Args>(args)...).first);
   }
# 944 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) std::pair<iterator, bool> try_emplace(key_type && k, Args &&... args)
   {
      return dtl::force_copy< std::pair<iterator, bool> >
         (m_flat_tree.try_emplace(impl_const_iterator(), boost::move(k), boost::forward<Args>(args)...));
   }
# 962 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) iterator try_emplace(const_iterator hint, key_type && k, Args &&... args)
   {
      return dtl::force_copy<iterator>
         (m_flat_tree.try_emplace(dtl::force_copy
            <impl_const_iterator>(hint), boost::move(k), boost::forward<Args>(args)...).first);
   }
# 1026 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) std::pair<iterator,bool> insert(const value_type& x)
   { return dtl::force_copy<std::pair<iterator,bool> >(
         m_flat_tree.insert_unique(dtl::force<const impl_value_type>(x))); }
# 1041 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) std::pair<iterator,bool> insert(value_type && x)
   { return dtl::force_copy<std::pair<iterator,bool> >(
      m_flat_tree.insert_unique(boost::move(dtl::force<impl_value_type>(x)))); }
# 1056 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) std::pair<iterator,bool> insert(movable_value_type && x)
   {
      return dtl::force_copy<std::pair<iterator,bool> >
      (m_flat_tree.insert_unique(boost::move(x)));
   }
# 1073 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator p, const value_type& x)
   {
      return dtl::force_copy<iterator>(
         m_flat_tree.insert_unique( dtl::force_copy<impl_const_iterator>(p)
                                  , dtl::force<const impl_value_type>(x)));
   }
# 1089 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator p, value_type && x)
   {
      return dtl::force_copy<iterator>
         (m_flat_tree.insert_unique( dtl::force_copy<impl_const_iterator>(p)
                                   , boost::move(dtl::force<impl_value_type>(x))));
   }
# 1105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator p, movable_value_type && x)
   {
      return dtl::force_copy<iterator>(
         m_flat_tree.insert_unique(dtl::force_copy<impl_const_iterator>(p), boost::move(x)));
   }
# 1119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(InputIterator first, InputIterator last)
   { m_flat_tree.insert_unique(first, last); }
# 1137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
      { m_flat_tree.insert_unique(ordered_unique_range, first, last); }
# 1148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void insert(std::initializer_list<value_type> il)
   {
      m_flat_tree.insert_unique( dtl::force<impl_initializer_list>(il).begin()
                               , dtl::force<impl_initializer_list>(il).end());
   }
# 1166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
   {
      m_flat_tree.insert_unique(ordered_unique_range
                               , dtl::force<impl_initializer_list>(il).begin()
                               , dtl::force<impl_initializer_list>(il).end());
   }
# 1188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_map<Key, T, C2, AllocatorOrContainer>& source)
   { m_flat_tree.merge_unique(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_map<Key, T, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_map<Key, T, C2, AllocatorOrContainer>&>(source)); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_multimap<Key, T, C2, AllocatorOrContainer>& source)
   { m_flat_tree.merge_unique(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_multimap<Key, T, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_multimap<Key, T, C2, AllocatorOrContainer>&>(source)); }
# 1217 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator p)
   {
      return dtl::force_copy<iterator>
         (m_flat_tree.erase(dtl::force_copy<impl_const_iterator>(p)));
   }







   inline __attribute__ ((__always_inline__)) size_type erase(const key_type& x)
      { return m_flat_tree.erase(x); }
# 1240 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator first, const_iterator last)
   {
      return dtl::force_copy<iterator>(
         m_flat_tree.erase( dtl::force_copy<impl_const_iterator>(first)
                          , dtl::force_copy<impl_const_iterator>(last)));
   }






   inline __attribute__ ((__always_inline__)) void swap(flat_map& x)
      noexcept((allocator_traits_type::is_always_equal::value && boost::container::dtl::is_nothrow_swappable<Compare>::value))

   { m_flat_tree.swap(x.m_flat_tree); }






   inline __attribute__ ((__always_inline__)) void clear() noexcept
      { m_flat_tree.clear(); }
# 1275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) key_compare key_comp() const
      { return dtl::force_copy<key_compare>(m_flat_tree.key_comp()); }





   inline __attribute__ ((__always_inline__)) value_compare value_comp() const
      { return value_compare(dtl::force_copy<key_compare>(m_flat_tree.key_comp())); }
# 1295 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator find(const key_type& x)
      { return dtl::force_copy<iterator>(m_flat_tree.find(x)); }





   inline __attribute__ ((__always_inline__)) const_iterator find(const key_type& x) const
      { return dtl::force_copy<const_iterator>(m_flat_tree.find(x)); }




   inline __attribute__ ((__always_inline__)) size_type count(const key_type& x) const
      { return static_cast<size_type>(m_flat_tree.find(x) != m_flat_tree.end()); }





   inline __attribute__ ((__always_inline__)) iterator lower_bound(const key_type& x)
      { return dtl::force_copy<iterator>(m_flat_tree.lower_bound(x)); }





   inline __attribute__ ((__always_inline__)) const_iterator lower_bound(const key_type& x) const
      { return dtl::force_copy<const_iterator>(m_flat_tree.lower_bound(x)); }





   inline __attribute__ ((__always_inline__)) iterator upper_bound(const key_type& x)
      { return dtl::force_copy<iterator>(m_flat_tree.upper_bound(x)); }





   inline __attribute__ ((__always_inline__)) const_iterator upper_bound(const key_type& x) const
      { return dtl::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }




   inline __attribute__ ((__always_inline__)) std::pair<iterator,iterator> equal_range(const key_type& x)
      { return dtl::force_copy<std::pair<iterator,iterator> >(m_flat_tree.lower_bound_range(x)); }




   inline __attribute__ ((__always_inline__)) std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
      { return dtl::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.lower_bound_range(x)); }
# 1358 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) sequence_type extract_sequence()
   {
      return boost::move(dtl::force<sequence_type>(m_flat_tree.get_sequence_ref()));
   }







   inline __attribute__ ((__always_inline__)) void adopt_sequence(sequence_type && seq)
   { this->m_flat_tree.adopt_sequence_unique(boost::move(dtl::force<impl_sequence_type>(seq))); }
# 1381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void adopt_sequence(ordered_unique_range_t, sequence_type && seq)
   { this->m_flat_tree.adopt_sequence_unique(ordered_unique_range_t(), boost::move(dtl::force<impl_sequence_type>(seq))); }




   inline __attribute__ ((__always_inline__)) friend bool operator==(const flat_map& x, const flat_map& y)
   { return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin()); }




   inline __attribute__ ((__always_inline__)) friend bool operator!=(const flat_map& x, const flat_map& y)
   { return !(x == y); }




   inline __attribute__ ((__always_inline__)) friend bool operator<(const flat_map& x, const flat_map& y)
   { return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }




   inline __attribute__ ((__always_inline__)) friend bool operator>(const flat_map& x, const flat_map& y)
   { return y < x; }




   inline __attribute__ ((__always_inline__)) friend bool operator<=(const flat_map& x, const flat_map& y)
   { return !(y < x); }




   inline __attribute__ ((__always_inline__)) friend bool operator>=(const flat_map& x, const flat_map& y)
   { return !(x < y); }




   inline __attribute__ ((__always_inline__)) friend void swap(flat_map& x, flat_map& y)
   { x.swap(y); }


   private:
   mapped_type &priv_subscript(const key_type& k)
   {
      iterator i = lower_bound(k);

      if (i == end() || key_comp()(k, (*i).first)){
         dtl::value_init<mapped_type> m;
         i = insert(i, impl_value_type(k, ::boost::move(m.m_t)));
      }
      return (*i).second;
   }
   mapped_type &priv_subscript(key_type && mk)
   {
      key_type &k = mk;
      iterator i = lower_bound(k);

      if (i == end() || key_comp()(k, (*i).first)){
         dtl::value_init<mapped_type> m;
         i = insert(i, impl_value_type(boost::move(k), ::boost::move(m.m_t)));
      }
      return (*i).second;
   }

};



}



template <class Key, class T, class Compare, class AllocatorOrContainer>
struct has_trivial_destructor_after_move<boost::container::flat_map<Key, T, Compare, AllocatorOrContainer> >
{
   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                             ::boost::has_trivial_destructor_after_move<pointer>::value &&
                             ::boost::has_trivial_destructor_after_move<Compare>::value;
};

namespace container {
# 1502 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
template <class Key, class T, class Compare, class AllocatorOrContainer>

class flat_multimap
{

   private:
  
   typedef dtl::flat_tree<
                           std::pair<Key, T>,
                           dtl::select1st<Key>,
                           Compare,
                           AllocatorOrContainer> tree_t;

   typedef dtl::flat_tree<
                           dtl::pair<Key, T>,
                           dtl::select1st<Key>,
                           Compare,
                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type
                           > impl_tree_t;
   impl_tree_t m_flat_tree;

   typedef typename impl_tree_t::value_type impl_value_type;
   typedef typename impl_tree_t::const_iterator impl_const_iterator;
   typedef typename impl_tree_t::iterator impl_iterator;
   typedef typename impl_tree_t::allocator_type impl_allocator_type;

   typedef std::initializer_list<impl_value_type> impl_initializer_list;


   typedef dtl::flat_tree_value_compare
      < Compare
      , dtl::select1st<Key>
      , std::pair<Key, T> > value_compare_t;
   typedef typename tree_t::iterator iterator_t;
   typedef typename tree_t::const_iterator const_iterator_t;
   typedef typename tree_t::reverse_iterator reverse_iterator_t;
   typedef typename tree_t::const_reverse_iterator const_reverse_iterator_t;

   public:
   typedef typename impl_tree_t::stored_allocator_type impl_stored_allocator_type;
   typedef typename impl_tree_t::sequence_type impl_sequence_type;

   inline __attribute__ ((__always_inline__)) impl_tree_t &tree()
   { return m_flat_tree; }

   inline __attribute__ ((__always_inline__)) const impl_tree_t &tree() const
   { return m_flat_tree; }

   private:


   public:






   typedef Key key_type;
   typedef T mapped_type;
   typedef Compare key_compare;
   typedef std::pair<Key, T> value_type;
   typedef typename tree_t::sequence_type sequence_type;
   typedef typename sequence_type::allocator_type allocator_type;
   typedef ::boost::container::allocator_traits<allocator_type> allocator_traits_type;
   typedef typename sequence_type::pointer pointer;
   typedef typename sequence_type::const_pointer const_pointer;
   typedef typename sequence_type::reference reference;
   typedef typename sequence_type::const_reference const_reference;
   typedef typename sequence_type::size_type size_type;
   typedef typename sequence_type::difference_type difference_type;
   typedef typename tree_t::stored_allocator_type stored_allocator_type;
   typedef typename tree_t::value_compare value_compare;

   typedef typename sequence_type::iterator iterator;
   typedef typename sequence_type::const_iterator const_iterator;
   typedef typename sequence_type::reverse_iterator reverse_iterator;
   typedef typename sequence_type::const_reverse_iterator const_reverse_iterator;
   typedef impl_value_type movable_value_type;


   static_assert((dtl::is_same<std::pair<Key, T>, typename AllocatorOrContainer::value_type>::value), "(dtl::is_same<std::pair<Key, T>, typename AllocatorOrContainer::value_type>::value)");
# 1594 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_multimap()
      noexcept((dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value && dtl::is_nothrow_default_constructible<Compare>::value))

      : m_flat_tree()
   {}




   inline __attribute__ ((__always_inline__)) explicit flat_multimap(const allocator_type& a)
      : m_flat_tree(dtl::force<const impl_allocator_type>(a))
   {}





   inline __attribute__ ((__always_inline__)) explicit flat_multimap(const Compare& comp)
      : m_flat_tree(comp)
   {}





   inline __attribute__ ((__always_inline__))
   flat_multimap(const Compare& comp, const allocator_type& a)
      : m_flat_tree(comp, dtl::force<const impl_allocator_type>(a))
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_multimap(InputIterator first, InputIterator last)
      : m_flat_tree(false, first, last)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_multimap(InputIterator first, InputIterator last, const allocator_type& a)
      : m_flat_tree(false, first, last, dtl::force<const impl_allocator_type>(a))
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_multimap(InputIterator first, InputIterator last, const Compare& comp)
      : m_flat_tree(false, first, last, comp)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_multimap(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : m_flat_tree(false, first, last, comp, dtl::force<const impl_allocator_type>(a))
   {}
# 1677 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_multimap(ordered_range_t, InputIterator first, InputIterator last)
      : m_flat_tree(ordered_range, first, last)
   {}
# 1692 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
      : m_flat_tree(ordered_range, first, last, comp)
   {}
# 1707 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : m_flat_tree(ordered_range, first, last, comp, a)
   {}







   inline __attribute__ ((__always_inline__))
   flat_multimap(std::initializer_list<value_type> il)
      : m_flat_tree( false
                   , dtl::force<impl_initializer_list>(il).begin()
                   , dtl::force<impl_initializer_list>(il).end())
   {}






   inline __attribute__ ((__always_inline__))
   flat_multimap(std::initializer_list<value_type> il, const allocator_type& a)
      : m_flat_tree(false
                   , dtl::force<impl_initializer_list>(il).begin()
                   , dtl::force<impl_initializer_list>(il).end()
                   , dtl::force<const impl_allocator_type>(a))
   {}






   inline __attribute__ ((__always_inline__))
   flat_multimap(std::initializer_list<value_type> il, const Compare& comp)
      : m_flat_tree(false
                   , dtl::force<impl_initializer_list>(il).begin()
                   , dtl::force<impl_initializer_list>(il).end(), comp)
   {}






   inline __attribute__ ((__always_inline__))
   flat_multimap(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
      : m_flat_tree( false
                   , dtl::force<impl_initializer_list>(il).begin()
                   , dtl::force<impl_initializer_list>(il).end()
                   , comp, dtl::force<const impl_allocator_type>(a))
   {}
# 1773 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   flat_multimap(ordered_range_t, std::initializer_list<value_type> il)
      : m_flat_tree( ordered_range
                   , dtl::force<impl_initializer_list>(il).begin()
                   , dtl::force<impl_initializer_list>(il).end())
   {}
# 1789 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
      : m_flat_tree( ordered_range
                   , dtl::force<impl_initializer_list>(il).begin()
                   , dtl::force<impl_initializer_list>(il).end(), comp)
   {}
# 1805 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
      : m_flat_tree( ordered_range
                   , dtl::force<impl_initializer_list>(il).begin()
                   , dtl::force<impl_initializer_list>(il).end()
                   , comp, dtl::force<const impl_allocator_type>(a))
   {}





   inline __attribute__ ((__always_inline__))
   flat_multimap(const flat_multimap& x)
      : m_flat_tree(x.m_flat_tree)
   {}






   inline __attribute__ ((__always_inline__))
   flat_multimap(flat_multimap && x)
      noexcept((boost::container::dtl::is_nothrow_move_constructible<Compare>::value))
      : m_flat_tree(boost::move(x.m_flat_tree))
   {}




   inline __attribute__ ((__always_inline__))
   flat_multimap(const flat_multimap& x, const allocator_type &a)
      : m_flat_tree(x.m_flat_tree, dtl::force<const impl_allocator_type>(a))
   {}





   inline __attribute__ ((__always_inline__))
   flat_multimap(flat_multimap && x, const allocator_type &a)
      : m_flat_tree(boost::move(x.m_flat_tree), dtl::force<const impl_allocator_type>(a))
   {}




   inline __attribute__ ((__always_inline__))
   flat_multimap& operator=(const flat_multimap & x)
      { m_flat_tree = x.m_flat_tree; return *this; }




   inline __attribute__ ((__always_inline__))
   flat_multimap& operator=(flat_multimap && x)
      noexcept(((allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value) && boost::container::dtl::is_nothrow_move_assignable<Compare>::value))


      { m_flat_tree = boost::move(x.m_flat_tree); return *this; }





   inline __attribute__ ((__always_inline__))
   flat_multimap& operator=(std::initializer_list<value_type> il)
   {
      this->clear();
      this->insert(il.begin(), il.end());
      return *this;
   }






   inline __attribute__ ((__always_inline__))
   allocator_type get_allocator() const noexcept
      { return dtl::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
# 1895 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   stored_allocator_type &get_stored_allocator() noexcept
      { return dtl::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
# 1906 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   const stored_allocator_type &get_stored_allocator() const noexcept
      { return dtl::force<const stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
# 1921 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   iterator begin() noexcept
      { return dtl::force_copy<iterator>(m_flat_tree.begin()); }






   inline __attribute__ ((__always_inline__))
   const_iterator begin() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.begin()); }






   inline __attribute__ ((__always_inline__))
   iterator end() noexcept
      { return dtl::force_copy<iterator>(m_flat_tree.end()); }






   inline __attribute__ ((__always_inline__))
   const_iterator end() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.end()); }







   inline __attribute__ ((__always_inline__))
   reverse_iterator rbegin() noexcept
      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }







   inline __attribute__ ((__always_inline__))
   const_reverse_iterator rbegin() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }







   inline __attribute__ ((__always_inline__))
   reverse_iterator rend() noexcept
      { return dtl::force_copy<reverse_iterator>(m_flat_tree.rend()); }







   inline __attribute__ ((__always_inline__))
   const_reverse_iterator rend() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }






   inline __attribute__ ((__always_inline__))
   const_iterator cbegin() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.cbegin()); }






   inline __attribute__ ((__always_inline__))
   const_iterator cend() const noexcept
      { return dtl::force_copy<const_iterator>(m_flat_tree.cend()); }







   inline __attribute__ ((__always_inline__))
   const_reverse_iterator crbegin() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }







   inline __attribute__ ((__always_inline__))
   const_reverse_iterator crend() const noexcept
      { return dtl::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
# 2041 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   bool empty() const noexcept
      { return m_flat_tree.empty(); }






   inline __attribute__ ((__always_inline__))
   size_type size() const noexcept
      { return m_flat_tree.size(); }






   inline __attribute__ ((__always_inline__))
   size_type max_size() const noexcept
      { return m_flat_tree.max_size(); }







   inline __attribute__ ((__always_inline__))
   size_type capacity() const noexcept
      { return m_flat_tree.capacity(); }
# 2083 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   void reserve(size_type cnt)
      { m_flat_tree.reserve(cnt); }







   inline __attribute__ ((__always_inline__))
   void shrink_to_fit()
      { m_flat_tree.shrink_to_fit(); }


   inline __attribute__ ((__always_inline__))
   iterator nth(size_type n) noexcept
   { return dtl::force_copy<iterator>(m_flat_tree.nth(n)); }


   inline __attribute__ ((__always_inline__))
   const_iterator nth(size_type n) const noexcept
   { return dtl::force_copy<iterator>(m_flat_tree.nth(n)); }


   inline __attribute__ ((__always_inline__))
   size_type index_of(iterator p) noexcept
   { return m_flat_tree.index_of(dtl::force_copy<impl_iterator>(p)); }


   inline __attribute__ ((__always_inline__))
   size_type index_of(const_iterator p) const noexcept
   { return m_flat_tree.index_of(dtl::force_copy<impl_const_iterator>(p)); }
# 2127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__))
   iterator emplace(Args &&... args)
   { return dtl::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
# 2144 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__))
   iterator emplace_hint(const_iterator hint, Args &&... args)
   {
      return dtl::force_copy<iterator>(m_flat_tree.emplace_hint_equal
         (dtl::force_copy<impl_const_iterator>(hint), boost::forward<Args>(args)...));
   }
# 2178 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const value_type& x)
   {
      return dtl::force_copy<iterator>(
         m_flat_tree.insert_equal(dtl::force<const impl_value_type>(x)));
   }
# 2191 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(value_type && x)
   { return dtl::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
# 2201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(impl_value_type && x)
      { return dtl::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
# 2215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator p, const value_type& x)
   {
      return dtl::force_copy<iterator>
         (m_flat_tree.insert_equal( dtl::force_copy<impl_const_iterator>(p)
                                  , dtl::force<const impl_value_type>(x)));
   }
# 2233 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator p, value_type && x)
   {
      return dtl::force_copy<iterator>
         (m_flat_tree.insert_equal(dtl::force_copy<impl_const_iterator>(p)
                                  , boost::move(x)));
   }
# 2251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator p, impl_value_type && x)
   {
      return dtl::force_copy<iterator>(
         m_flat_tree.insert_equal(dtl::force_copy<impl_const_iterator>(p), boost::move(x)));
   }
# 2264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(InputIterator first, InputIterator last)
      { m_flat_tree.insert_equal(first, last); }
# 2281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(ordered_range_t, InputIterator first, InputIterator last)
      { m_flat_tree.insert_equal(ordered_range, first, last); }







   inline __attribute__ ((__always_inline__)) void insert(std::initializer_list<value_type> il)
   {
      m_flat_tree.insert_equal( dtl::force<impl_initializer_list>(il).begin()
                              , dtl::force<impl_initializer_list>(il).end());
   }
# 2308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void insert(ordered_range_t, std::initializer_list<value_type> il)
   {
      m_flat_tree.insert_equal( ordered_range
                              , dtl::force<impl_initializer_list>(il).begin()
                              , dtl::force<impl_initializer_list>(il).end());
   }
# 2329 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_multimap<Key, T, C2, AllocatorOrContainer>& source)
   { m_flat_tree.merge_equal(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_multimap<Key, T, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_multimap<Key, T, C2, AllocatorOrContainer>&>(source)); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_map<Key, T, C2, AllocatorOrContainer>& source)
   { m_flat_tree.merge_equal(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_map<Key, T, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_map<Key, T, C2, AllocatorOrContainer>&>(source)); }
# 2358 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator p)
   {
      return dtl::force_copy<iterator>(
         m_flat_tree.erase(dtl::force_copy<impl_const_iterator>(p)));
   }







   inline __attribute__ ((__always_inline__)) size_type erase(const key_type& x)
      { return m_flat_tree.erase(x); }
# 2381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator first, const_iterator last)
   {
      return dtl::force_copy<iterator>
         (m_flat_tree.erase( dtl::force_copy<impl_const_iterator>(first)
                           , dtl::force_copy<impl_const_iterator>(last)));
   }






   inline __attribute__ ((__always_inline__)) void swap(flat_multimap& x)
      noexcept((allocator_traits_type::is_always_equal::value && boost::container::dtl::is_nothrow_swappable<Compare>::value))

   { m_flat_tree.swap(x.m_flat_tree); }






   inline __attribute__ ((__always_inline__)) void clear() noexcept
      { m_flat_tree.clear(); }
# 2416 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) key_compare key_comp() const
      { return dtl::force_copy<key_compare>(m_flat_tree.key_comp()); }





   inline __attribute__ ((__always_inline__)) value_compare value_comp() const
      { return value_compare(dtl::force_copy<key_compare>(m_flat_tree.key_comp())); }
# 2436 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator find(const key_type& x)
      { return dtl::force_copy<iterator>(m_flat_tree.find(x)); }





   inline __attribute__ ((__always_inline__)) const_iterator find(const key_type& x) const
      { return dtl::force_copy<const_iterator>(m_flat_tree.find(x)); }




   inline __attribute__ ((__always_inline__)) size_type count(const key_type& x) const
      { return m_flat_tree.count(x); }





   inline __attribute__ ((__always_inline__)) iterator lower_bound(const key_type& x)
      { return dtl::force_copy<iterator>(m_flat_tree.lower_bound(x)); }





   inline __attribute__ ((__always_inline__)) const_iterator lower_bound(const key_type& x) const
      { return dtl::force_copy<const_iterator>(m_flat_tree.lower_bound(x)); }





   inline __attribute__ ((__always_inline__)) iterator upper_bound(const key_type& x)
      {return dtl::force_copy<iterator>(m_flat_tree.upper_bound(x)); }





   inline __attribute__ ((__always_inline__)) const_iterator upper_bound(const key_type& x) const
      { return dtl::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }




   inline __attribute__ ((__always_inline__)) std::pair<iterator,iterator> equal_range(const key_type& x)
      { return dtl::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x)); }




   inline __attribute__ ((__always_inline__)) std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
      { return dtl::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x)); }
# 2499 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) sequence_type extract_sequence()
   {
      return boost::move(dtl::force<sequence_type>(m_flat_tree.get_sequence_ref()));
   }







   inline __attribute__ ((__always_inline__)) void adopt_sequence(sequence_type && seq)
   { this->m_flat_tree.adopt_sequence_equal(boost::move(dtl::force<impl_sequence_type>(seq))); }
# 2521 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void adopt_sequence(ordered_range_t, sequence_type && seq)
   { this->m_flat_tree.adopt_sequence_equal(ordered_range_t(), boost::move(dtl::force<impl_sequence_type>(seq))); }




   inline __attribute__ ((__always_inline__)) friend bool operator==(const flat_multimap& x, const flat_multimap& y)
   { return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin()); }




   inline __attribute__ ((__always_inline__)) friend bool operator!=(const flat_multimap& x, const flat_multimap& y)
   { return !(x == y); }




   inline __attribute__ ((__always_inline__)) friend bool operator<(const flat_multimap& x, const flat_multimap& y)
   { return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }




   inline __attribute__ ((__always_inline__)) friend bool operator>(const flat_multimap& x, const flat_multimap& y)
   { return y < x; }




   inline __attribute__ ((__always_inline__)) friend bool operator<=(const flat_multimap& x, const flat_multimap& y)
   { return !(y < x); }




   inline __attribute__ ((__always_inline__)) friend bool operator>=(const flat_multimap& x, const flat_multimap& y)
   { return !(x < y); }




   inline __attribute__ ((__always_inline__)) friend void swap(flat_multimap& x, flat_multimap& y)
   { x.swap(y); }
};

}}



namespace boost {



template <class Key, class T, class Compare, class AllocatorOrContainer>
struct has_trivial_destructor_after_move< boost::container::flat_multimap<Key, T, Compare, AllocatorOrContainer> >
{
   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                             ::boost::has_trivial_destructor_after_move<pointer>::value &&
                             ::boost::has_trivial_destructor_after_move<Compare>::value;
};

}



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 2589 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_map.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_begin.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
namespace boost {
namespace container {


template <class Key, class Compare, class AllocatorOrContainer>
class flat_multiset;
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
template <class Key, class Compare, class AllocatorOrContainer>

class flat_set

   : public dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer>

{

   private:
  
   typedef dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer> tree_t;

   public:
   tree_t &tree()
   { return *this; }

   const tree_t &tree() const
   { return *this; }



   public:





   typedef Key key_type;
   typedef Compare key_compare;
   typedef Key value_type;
   typedef typename tree_t::sequence_type sequence_type;
   typedef typename sequence_type::allocator_type allocator_type;
   typedef ::boost::container::allocator_traits<allocator_type> allocator_traits_type;
   typedef typename sequence_type::pointer pointer;
   typedef typename sequence_type::const_pointer const_pointer;
   typedef typename sequence_type::reference reference;
   typedef typename sequence_type::const_reference const_reference;
   typedef typename sequence_type::size_type size_type;
   typedef typename sequence_type::difference_type difference_type;
   typedef typename tree_t::stored_allocator_type stored_allocator_type;
   typedef typename tree_t::value_compare value_compare;

   typedef typename sequence_type::iterator iterator;
   typedef typename sequence_type::const_iterator const_iterator;
   typedef typename sequence_type::reverse_iterator reverse_iterator;
   typedef typename sequence_type::const_reverse_iterator const_reverse_iterator;

   public:
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__))
   flat_set() noexcept((dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value && dtl::is_nothrow_default_constructible<Compare>::value))

      : tree_t()
   {}





   inline __attribute__ ((__always_inline__))
   explicit flat_set(const Compare& comp)
      : tree_t(comp)
   {}




   inline __attribute__ ((__always_inline__))
   explicit flat_set(const allocator_type& a)
      : tree_t(a)
   {}





   inline __attribute__ ((__always_inline__))
   flat_set(const Compare& comp, const allocator_type& a)
      : tree_t(comp, a)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_set(InputIterator first, InputIterator last)
      : tree_t(true, first, last)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_set(InputIterator first, InputIterator last, const allocator_type& a)
      : tree_t(true, first, last, a)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_set(InputIterator first, InputIterator last, const Compare& comp)
      : tree_t(true, first, last, comp)
   {}






   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_set(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : tree_t(true, first, last, comp, a)
   {}
# 222 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last)
      : tree_t(ordered_unique_range, first, last)
   {}
# 238 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
      : tree_t(ordered_unique_range, first, last, comp)
   {}
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__))
   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : tree_t(ordered_unique_range, first, last, comp, a)
   {}







   inline __attribute__ ((__always_inline__)) flat_set(std::initializer_list<value_type> il)
      : tree_t(true, il.begin(), il.end())
   {}






   inline __attribute__ ((__always_inline__)) flat_set(std::initializer_list<value_type> il, const allocator_type& a)
      : tree_t(true, il.begin(), il.end(), a)
   {}






   inline __attribute__ ((__always_inline__)) flat_set(std::initializer_list<value_type> il, const Compare& comp)
      : tree_t(true, il.begin(), il.end(), comp)
   {}






   inline __attribute__ ((__always_inline__)) flat_set(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
      : tree_t(true, il.begin(), il.end(), comp, a)
   {}
# 307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_set(ordered_unique_range_t, std::initializer_list<value_type> il)
      : tree_t(ordered_unique_range, il.begin(), il.end())
   {}
# 321 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_set(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
      : tree_t(ordered_unique_range, il.begin(), il.end(), comp)
   {}
# 335 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_set(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
      : tree_t(ordered_unique_range, il.begin(), il.end(), comp, a)
   {}





   inline __attribute__ ((__always_inline__)) flat_set(const flat_set& x)
      : tree_t(static_cast<const tree_t&>(x))
   {}






   inline __attribute__ ((__always_inline__)) flat_set(flat_set && x)
      noexcept((boost::container::dtl::is_nothrow_move_constructible<Compare>::value))
      : tree_t(::boost::move((tree_t&)(x)))
   {}




   inline __attribute__ ((__always_inline__)) flat_set(const flat_set& x, const allocator_type &a)
      : tree_t(static_cast<const tree_t&>(x), a)
   {}





   inline __attribute__ ((__always_inline__)) flat_set(flat_set && x, const allocator_type &a)
      : tree_t(::boost::move((tree_t&)(x)), a)
   {}




   inline __attribute__ ((__always_inline__)) flat_set& operator=(const flat_set & x)
   { return static_cast<flat_set&>(this->tree_t::operator=(static_cast<const tree_t&>(x))); }







   inline __attribute__ ((__always_inline__)) flat_set& operator=(flat_set && x)
      noexcept(((allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value) && boost::container::dtl::is_nothrow_move_assignable<Compare>::value))


   { return static_cast<flat_set&>(this->tree_t::operator=(::boost::move((tree_t&)(x)))); }





   flat_set& operator=(std::initializer_list<value_type> il)
   {
       this->clear();
       this->insert(il.begin(), il.end());
       return *this;
   }
# 588 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) std::pair<iterator,bool> emplace(Args &&... args)
   { return this->tree_t::emplace_unique(boost::forward<Args>(args)...); }
# 604 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) iterator emplace_hint(const_iterator p, Args &&... args)
   { return this->tree_t::emplace_hint_unique(p, boost::forward<Args>(args)...); }
# 651 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   private:
   typedef std::pair<iterator, bool> insert_return_pair;
   public:
   inline __attribute__ ((__always_inline__)) insert_return_pair insert(const value_type & x) { return this->priv_insert(x); } inline __attribute__ ((__always_inline__)) insert_return_pair insert(value_type && x) { return this->priv_insert(::boost::move(x)); }
# 682 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator arg1, const value_type & x) { return this->priv_insert(arg1, static_cast<const value_type&>(x)); } inline __attribute__ ((__always_inline__)) iterator insert(const_iterator arg1, value_type && x) { return this->priv_insert(arg1, ::boost::move(x)); }
# 693 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(InputIterator first, InputIterator last)
      { this->tree_t::insert_unique(first, last); }
# 707 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
      { this->tree_t::insert_unique(ordered_unique_range, first, last); }
# 718 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void insert(std::initializer_list<value_type> il)
   { this->tree_t::insert_unique(il.begin(), il.end()); }
# 730 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
   { this->tree_t::insert_unique(ordered_unique_range, il.begin(), il.end()); }



   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_set<Key, C2, AllocatorOrContainer>& source)
   { this->tree_t::merge_unique(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_set<Key, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_set<Key, C2, AllocatorOrContainer>&>(source)); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_multiset<Key, C2, AllocatorOrContainer>& source)
   { this->tree_t::merge_unique(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_multiset<Key, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_multiset<Key, C2, AllocatorOrContainer>&>(source)); }
# 881 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) size_type count(const key_type& x) const
   { return static_cast<size_type>(this->tree_t::find(x) != this->tree_t::cend()); }
# 914 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
   { return this->tree_t::lower_bound_range(x); }




   inline __attribute__ ((__always_inline__)) std::pair<iterator,iterator> equal_range(const key_type& x)
   { return this->tree_t::lower_bound_range(x); }
# 977 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void adopt_sequence(sequence_type && seq)
   { this->tree_t::adopt_sequence_unique(boost::move(seq)); }
# 989 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void adopt_sequence(ordered_unique_range_t, sequence_type && seq)
   { this->tree_t::adopt_sequence_unique(ordered_unique_range_t(), boost::move(seq)); }


   private:
   template<class KeyType>
   inline __attribute__ ((__always_inline__)) std::pair<iterator, bool> priv_insert(KeyType && x)
   { return this->tree_t::insert_unique(::boost::forward<KeyType>(x)); }

   template<class KeyType>
   inline __attribute__ ((__always_inline__)) iterator priv_insert(const_iterator p, KeyType && x)
   { return this->tree_t::insert_unique(p, ::boost::forward<KeyType>(x)); }

};



}



template <class Key, class Compare, class AllocatorOrContainer>
struct has_trivial_destructor_after_move<boost::container::flat_set<Key, Compare, AllocatorOrContainer> >
{
   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                             ::boost::has_trivial_destructor_after_move<pointer>::value &&
                             ::boost::has_trivial_destructor_after_move<Compare>::value;
};

namespace container {
# 1047 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
template <class Key, class Compare, class AllocatorOrContainer>

class flat_multiset

   : public dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer>

{

   private:
  
   typedef dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer> tree_t;

   public:
   tree_t &tree()
   { return *this; }

   const tree_t &tree() const
   { return *this; }


   public:





   typedef Key key_type;
   typedef Compare key_compare;
   typedef Key value_type;
   typedef typename tree_t::sequence_type sequence_type;
   typedef typename sequence_type::allocator_type allocator_type;
   typedef ::boost::container::allocator_traits<allocator_type> allocator_traits_type;
   typedef typename sequence_type::pointer pointer;
   typedef typename sequence_type::const_pointer const_pointer;
   typedef typename sequence_type::reference reference;
   typedef typename sequence_type::const_reference const_reference;
   typedef typename sequence_type::size_type size_type;
   typedef typename sequence_type::difference_type difference_type;
   typedef typename tree_t::stored_allocator_type stored_allocator_type;
   typedef typename tree_t::value_compare value_compare;

   typedef typename sequence_type::iterator iterator;
   typedef typename sequence_type::const_iterator const_iterator;
   typedef typename sequence_type::reverse_iterator reverse_iterator;
   typedef typename sequence_type::const_reverse_iterator const_reverse_iterator;


   inline __attribute__ ((__always_inline__)) flat_multiset() noexcept((dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value && dtl::is_nothrow_default_constructible<Compare>::value))

      : tree_t()
   {}


   inline __attribute__ ((__always_inline__)) explicit flat_multiset(const Compare& comp)
      : tree_t(comp)
   {}


   inline __attribute__ ((__always_inline__)) explicit flat_multiset(const allocator_type& a)
      : tree_t(a)
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset(const Compare& comp, const allocator_type& a)
      : tree_t(comp, a)
   {}


   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_multiset(InputIterator first, InputIterator last)
      : tree_t(false, first, last)
   {}


   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_multiset(InputIterator first, InputIterator last, const allocator_type& a)
      : tree_t(false, first, last, a)
   {}


   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_multiset(InputIterator first, InputIterator last, const Compare& comp)
      : tree_t(false, first, last, comp)
   {}


   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_multiset(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : tree_t(false, first, last, comp, a)
   {}
# 1147 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_multiset(ordered_range_t, InputIterator first, InputIterator last)
      : tree_t(ordered_range, first, last)
   {}
# 1161 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_multiset(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
      : tree_t(ordered_range, first, last, comp)
   {}
# 1175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) flat_multiset(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
      : tree_t(ordered_range, first, last, comp, a)
   {}



   inline __attribute__ ((__always_inline__)) flat_multiset(std::initializer_list<value_type> il)
      : tree_t(false, il.begin(), il.end())
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset(std::initializer_list<value_type> il, const allocator_type& a)
      : tree_t(false, il.begin(), il.end(), a)
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset(std::initializer_list<value_type> il, const Compare& comp)
      : tree_t(false, il.begin(), il.end(), comp)
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
      : tree_t(false, il.begin(), il.end(), comp, a)
   {}
# 1210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_multiset(ordered_range_t, std::initializer_list<value_type> il)
      : tree_t(ordered_range, il.begin(), il.end())
   {}
# 1223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
      : tree_t(ordered_range, il.begin(), il.end(), comp)
   {}
# 1236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) flat_multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
      : tree_t(ordered_range, il.begin(), il.end(), comp, a)
   {}



   inline __attribute__ ((__always_inline__)) flat_multiset(const flat_multiset& x)
      : tree_t(static_cast<const tree_t&>(x))
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset(flat_multiset && x)
      noexcept((boost::container::dtl::is_nothrow_move_constructible<Compare>::value))
      : tree_t(boost::move(static_cast<tree_t&>(x)))
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset(const flat_multiset& x, const allocator_type &a)
      : tree_t(static_cast<const tree_t&>(x), a)
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset(flat_multiset && x, const allocator_type &a)
      : tree_t(::boost::move((tree_t&)(x)), a)
   {}


   inline __attribute__ ((__always_inline__)) flat_multiset& operator=(const flat_multiset & x)
   { return static_cast<flat_multiset&>(this->tree_t::operator=(static_cast<const tree_t&>(x))); }


   inline __attribute__ ((__always_inline__)) flat_multiset& operator=(flat_multiset && x)
      noexcept(((allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value) && boost::container::dtl::is_nothrow_move_assignable<Compare>::value))


   { return static_cast<flat_multiset&>(this->tree_t::operator=(::boost::move((tree_t&)(x)))); }



   flat_multiset& operator=(std::initializer_list<value_type> il)
   {
       this->clear();
       this->insert(il.begin(), il.end());
       return *this;
   }
# 1366 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) iterator emplace(Args &&... args)
   { return this->tree_t::emplace_equal(boost::forward<Args>(args)...); }
# 1381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class... Args>
   inline __attribute__ ((__always_inline__)) iterator emplace_hint(const_iterator p, Args &&... args)
   { return this->tree_t::emplace_hint_equal(p, boost::forward<Args>(args)...); }
# 1420 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const value_type & x) { return this->priv_insert(x); } inline __attribute__ ((__always_inline__)) iterator insert(value_type && x) { return this->priv_insert(::boost::move(x)); }
# 1448 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator arg1, const value_type & x) { return this->priv_insert(arg1, static_cast<const value_type&>(x)); } inline __attribute__ ((__always_inline__)) iterator insert(const_iterator arg1, value_type && x) { return this->priv_insert(arg1, ::boost::move(x)); }
# 1458 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(InputIterator first, InputIterator last)
      { this->tree_t::insert_equal(first, last); }
# 1471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   template <class InputIterator>
   inline __attribute__ ((__always_inline__)) void insert(ordered_range_t, InputIterator first, InputIterator last)
      { this->tree_t::insert_equal(ordered_range, first, last); }







   inline __attribute__ ((__always_inline__)) void insert(std::initializer_list<value_type> il)
   { this->tree_t::insert_equal(il.begin(), il.end()); }
# 1492 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void insert(ordered_range_t, std::initializer_list<value_type> il)
   { this->tree_t::insert_equal(ordered_range, il.begin(), il.end()); }



   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_multiset<Key, C2, AllocatorOrContainer>& source)
   { this->tree_t::merge_equal(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_multiset<Key, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_multiset<Key, C2, AllocatorOrContainer>&>(source)); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge(flat_set<Key, C2, AllocatorOrContainer>& source)
   { this->tree_t::merge_equal(source.tree()); }


   template<class C2>
   inline __attribute__ ((__always_inline__)) void merge( flat_set<Key, C2, AllocatorOrContainer> && source)
   { return this->merge(static_cast<flat_set<Key, C2, AllocatorOrContainer>&>(source)); }
# 1632 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void adopt_sequence(sequence_type && seq)
   { this->tree_t::adopt_sequence_equal(boost::move(seq)); }
# 1643 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void adopt_sequence(ordered_range_t, sequence_type && seq)
   { this->tree_t::adopt_sequence_equal(ordered_range_t(), boost::move(seq)); }


   private:
   template <class KeyType>
   inline __attribute__ ((__always_inline__)) iterator priv_insert(KeyType && x)
   { return this->tree_t::insert_equal(::boost::forward<KeyType>(x)); }

   template <class KeyType>
   inline __attribute__ ((__always_inline__)) iterator priv_insert(const_iterator p, KeyType && x)
   { return this->tree_t::insert_equal(p, ::boost::forward<KeyType>(x)); }

};



}



template <class Key, class Compare, class AllocatorOrContainer>
struct has_trivial_destructor_after_move<boost::container::flat_multiset<Key, Compare, AllocatorOrContainer> >
{
   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                             ::boost::has_trivial_destructor_after_move<pointer>::value &&
                             ::boost::has_trivial_destructor_after_move<Compare>::value;
};

namespace container {



}}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/detail/config_end.hpp" 1 3 4
# 1680 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/container/flat_set.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/intrusive_fwd.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/intrusive_fwd.hpp" 3 4
         
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/intrusive_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/link_mode.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/intrusive_fwd.hpp" 2 3 4


namespace boost {
namespace intrusive {



      using ::boost::uintptr_t;
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;







template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class slist;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



class slist_base_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



class slist_member_hook;



template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   >



class list;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



class list_base_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



class list_member_hook;



template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class rbtree;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class set;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class multiset;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   >



class set_base_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   >



class set_member_hook;



template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class splaytree;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class splay_set;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class splay_multiset;



template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class avltree;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class avl_set;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class avl_multiset;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   >



class avl_set_base_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   >



class avl_set_member_hook;




template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class treap;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class treap_set;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class treap_multiset;



template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class sgtree;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class sg_set;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class sg_multiset;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class bstree;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class bs_set;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   >



class bs_multiset;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



class bs_set_base_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



class bs_set_member_hook;




template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   , class O7 = void
   , class O8 = void
   , class O9 = void
   , class O10 = void
   >



class hashtable;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   , class O7 = void
   , class O8 = void
   , class O9 = void
   , class O10 = void
   >



class unordered_set;


template
   < class T
   , class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   , class O5 = void
   , class O6 = void
   , class O7 = void
   , class O8 = void
   , class O9 = void
   , class O10 = void
   >



class unordered_multiset;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   >



class unordered_set_base_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   , class O4 = void
   >



class unordered_set_member_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



class any_base_hook;


template
   < class O1 = void
   , class O2 = void
   , class O3 = void
   >



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 *>;

}
}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/assert.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/assert.hpp" 3 4
       



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/assert.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/assert.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/assert.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/algo_type.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

}
}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/uncast.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/uncast.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/uncast.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 2 3 4

namespace boost {
namespace intrusive {

template<class NodeTraits>
class bstree_algorithms_base
{
   public:
   typedef typename NodeTraits::node node;
   typedef NodeTraits node_traits;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 3 4
   static node_ptr next_node(const node_ptr & node)
   {
      node_ptr const n_right(NodeTraits::get_right(node));
      if(n_right){
         return minimum(n_right);
      }
      else {
         node_ptr n(node);
         node_ptr p(NodeTraits::get_parent(n));
         while(n == NodeTraits::get_right(p)){
            n = p;
            p = NodeTraits::get_parent(p);
         }
         return NodeTraits::get_right(n) != p ? p : n;
      }
   }
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 3 4
   static node_ptr prev_node(const node_ptr & node)
   {
      if(is_header(node)){

         return maximum(NodeTraits::get_parent(node));
      }
      else if(NodeTraits::get_left(node)){
         return maximum(NodeTraits::get_left(node));
      }
      else {
         node_ptr p(node);
         node_ptr x = NodeTraits::get_parent(p);
         while(p == NodeTraits::get_left(x)){
            p = x;
            x = NodeTraits::get_parent(x);
         }
         return x;
      }
   }
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 3 4
   static node_ptr minimum(node_ptr node)
   {
      for(node_ptr p_left = NodeTraits::get_left(node)
         ;p_left
         ;p_left = NodeTraits::get_left(node)){
         node = p_left;
      }
      return node;
   }
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 3 4
   static node_ptr maximum(node_ptr node)
   {
      for(node_ptr p_right = NodeTraits::get_right(node)
         ;p_right
         ;p_right = NodeTraits::get_right(node)){
         node = p_right;
      }
      return node;
   }
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 3 4
   static bool is_header(const const_node_ptr & p)
   {
      node_ptr p_left (NodeTraits::get_left(p));
      node_ptr p_right(NodeTraits::get_right(p));
      if(!NodeTraits::get_parent(p) ||
         (p_left && p_right &&
            (p_left == p_right ||
               (NodeTraits::get_parent(p_left) != p ||
                NodeTraits::get_parent(p_right) != p ))


          )){
         return true;
      }
      return false;
   }
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/bstree_algorithms_base.hpp" 3 4
   static node_ptr get_header(const const_node_ptr & node)
   {
      node_ptr n(detail::uncast(node));
      node_ptr p(NodeTraits::get_parent(node));

      if(p){

         node_ptr pp(NodeTraits::get_parent(p));


         if(n != pp){
            do{
               n = p;
               p = pp;
               pp = NodeTraits::get_parent(pp);
            }while(n != pp);
            n = p;
         }

         else if(!bstree_algorithms_base::is_header(n)){
            n = p;
         }
      }
      return n;
   }
};

}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/math.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/math.hpp" 3 4
         



# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/math.hpp" 2 3 4


namespace boost {
namespace intrusive {
namespace detail {
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/math.hpp" 3 4
   template<class Uint>
   struct builtin_clz_dispatch;


   template<>
   struct builtin_clz_dispatch< ::boost::ulong_long_type >
   {
      static ::boost::ulong_long_type call(::boost::ulong_long_type n)
      { return __builtin_clzll(n); }
   };


   template<>
   struct builtin_clz_dispatch<unsigned long>
   {
      static unsigned long call(unsigned long n)
      { return __builtin_clzl(n); }
   };

   template<>
   struct builtin_clz_dispatch<unsigned int>
   {
      static unsigned int call(unsigned int n)
      { return __builtin_clz(n); }
   };

   inline std::size_t floor_log2(std::size_t n)
   {
      return sizeof(std::size_t)*8 - std::size_t(1) - builtin_clz_dispatch<std::size_t>::call(n);
   }
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/math.hpp" 3 4
inline float fast_log2 (float val)
{
   union caster_t
   {
      unsigned x;
      float val;
   } caster;

   caster.val = val;
   unsigned x = caster.x;
   const int log_2 = int((x >> 23) & 255) - 128;
   x &= ~(unsigned(255u) << 23u);
   x += unsigned(127) << 23u;
   caster.x = x;
   val = caster.val;



   val = ((-1.f/3.f) * val + 2.f) * val - (2.f/3.f);
   return val + static_cast<float>(log_2);
}

inline bool is_pow2(std::size_t x)
{ return (x & (x-1)) == 0; }

template<std::size_t N>
struct static_is_pow2
{
   static const bool value = (N & (N-1)) == 0;
};

inline std::size_t ceil_log2 (std::size_t x)
{
   return static_cast<std::size_t>(!(is_pow2)(x)) + floor_log2(x);
}

inline std::size_t ceil_pow2 (std::size_t x)
{
   return std::size_t(1u) << (ceil_log2)(x);
}

inline std::size_t previous_or_equal_pow2(std::size_t x)
{
   return std::size_t(1u) << floor_log2(x);
}

template<class SizeType, std::size_t N>
struct numbits_eq
{
   static const bool value = sizeof(SizeType)*8 == N;
};

template<class SizeType, class Enabler = void >
struct sqrt2_pow_max;

template <class SizeType>
struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 32> >::type>
{
   static const SizeType value = 0xb504f334;
   static const std::size_t pow = 31;
};



template <class SizeType>
struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 64> >::type>
{
   static const SizeType value = 0xb504f333f9de6484ull;
   static const std::size_t pow = 63;
};





inline std::size_t sqrt2_pow_2xplus1 (std::size_t x)
{
   const std::size_t value = (std::size_t)sqrt2_pow_max<std::size_t>::value;
   const std::size_t pow = (std::size_t)sqrt2_pow_max<std::size_t>::pow;
   return (value >> (pow - x)) + 1;
}

}
}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 2 3 4





         


namespace boost {
namespace intrusive {




template <class NodePtr>
struct insert_commit_data_t
{
   inline insert_commit_data_t()
      : link_left(false), node()
   {}
   bool link_left;
   NodePtr node;
};

template <class NodePtr>
struct data_for_rebalance_t
{
   NodePtr x;
   NodePtr x_parent;
   NodePtr y;
};

namespace detail {

template<class ValueTraits, class NodePtrCompare, class ExtraChecker>
struct bstree_node_checker
   : public ExtraChecker
{
   typedef ExtraChecker base_checker_t;
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::const_node_ptr const_node_ptr;

   struct return_type
      : public base_checker_t::return_type
   {
      inline return_type()
         : min_key_node_ptr(const_node_ptr()), max_key_node_ptr(const_node_ptr()), node_count(0)
      {}

      const_node_ptr min_key_node_ptr;
      const_node_ptr max_key_node_ptr;
      size_t node_count;
   };

   inline bstree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker)
      : base_checker_t(extra_checker), comp_(comp)
   {}

   void operator () (const const_node_ptr& p,
                     const return_type& check_return_left, const return_type& check_return_right,
                     return_type& check_return)
   {
      if (check_return_left.max_key_node_ptr)
         (static_cast<void> (0));
      if (check_return_right.min_key_node_ptr)
         (static_cast<void> (0));
      check_return.min_key_node_ptr = node_traits::get_left(p)? check_return_left.min_key_node_ptr : p;
      check_return.max_key_node_ptr = node_traits::get_right(p)? check_return_right.max_key_node_ptr : p;
      check_return.node_count = check_return_left.node_count + check_return_right.node_count + 1;
      base_checker_t::operator()(p, check_return_left, check_return_right, check_return);
   }

   const NodePtrCompare comp_;
};

}
# 172 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
template<class NodeTraits>
class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
{
   public:
   typedef typename NodeTraits::node node;
   typedef NodeTraits node_traits;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef insert_commit_data_t<node_ptr> insert_commit_data;
   typedef data_for_rebalance_t<node_ptr> data_for_rebalance;


   typedef bstree_algorithms<NodeTraits> this_type;
   typedef bstree_algorithms_base<NodeTraits> base_type;
   private:
   template<class Disposer>
   struct dispose_subtree_disposer
   {
      inline dispose_subtree_disposer(Disposer &disp, const node_ptr & subtree)
         : disposer_(&disp), subtree_(subtree)
      {}

      inline void release()
      { disposer_ = 0; }

      inline ~dispose_subtree_disposer()
      {
         if(disposer_){
            dispose_subtree(subtree_, *disposer_);
         }
      }
      Disposer *disposer_;
      const node_ptr subtree_;
   };



   public:







   inline static node_ptr begin_node(const const_node_ptr & header)
   { return node_traits::get_left(header); }
# 227 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static node_ptr end_node(const const_node_ptr & header)
   { return detail::uncast(header); }
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static node_ptr root_node(const const_node_ptr & header)
   {
      node_ptr p = node_traits::get_parent(header);
      return p ? p : detail::uncast(header);
   }
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static bool unique(const const_node_ptr & node)
   { return !NodeTraits::get_parent(node); }
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
   {
      if(node1 == node2)
         return;

      node_ptr header1(base_type::get_header(node1)), header2(base_type::get_header(node2));
      swap_nodes(node1, header1, node2, header2);
   }
# 304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
   {
      if(node1 == node2)
         return;



      if(header1 != header2){

         if(node1 == NodeTraits::get_left(header1)){
            NodeTraits::set_left(header1, node2);
         }

         if(node1 == NodeTraits::get_right(header1)){
            NodeTraits::set_right(header1, node2);
         }

         if(node1 == NodeTraits::get_parent(header1)){
            NodeTraits::set_parent(header1, node2);
         }


         if(node2 == NodeTraits::get_left(header2)){
            NodeTraits::set_left(header2, node1);
         }

         if(node2 == NodeTraits::get_right(header2)){
            NodeTraits::set_right(header2, node1);
         }

         if(node2 == NodeTraits::get_parent(header2)){
            NodeTraits::set_parent(header2, node1);
         }
      }
      else{


         if(node1 == NodeTraits::get_left(header1)){
            NodeTraits::set_left(header1, node2);
         }
         else if(node2 == NodeTraits::get_left(header2)){
            NodeTraits::set_left(header2, node1);
         }

         if(node1 == NodeTraits::get_right(header1)){
            NodeTraits::set_right(header1, node2);
         }
         else if(node2 == NodeTraits::get_right(header2)){
            NodeTraits::set_right(header2, node1);
         }

         if(node1 == NodeTraits::get_parent(header1)){
            NodeTraits::set_parent(header1, node2);
         }
         else if(node2 == NodeTraits::get_parent(header2)){
            NodeTraits::set_parent(header2, node1);
         }



         if(node1 == NodeTraits::get_parent(node2)){
            NodeTraits::set_parent(node2, node2);

            if(node2 == NodeTraits::get_right(node1)){
               NodeTraits::set_right(node1, node1);
            }
            else{
               NodeTraits::set_left(node1, node1);
            }
         }
         else if(node2 == NodeTraits::get_parent(node1)){
            NodeTraits::set_parent(node1, node1);

            if(node1 == NodeTraits::get_right(node2)){
               NodeTraits::set_right(node2, node2);
            }
            else{
               NodeTraits::set_left(node2, node2);
            }
         }
      }


      node_ptr temp;

      temp = NodeTraits::get_left(node1);
      NodeTraits::set_left(node1, NodeTraits::get_left(node2));
      NodeTraits::set_left(node2, temp);

      temp = NodeTraits::get_right(node1);
      NodeTraits::set_right(node1, NodeTraits::get_right(node2));
      NodeTraits::set_right(node2, temp);

      temp = NodeTraits::get_parent(node1);
      NodeTraits::set_parent(node1, NodeTraits::get_parent(node2));
      NodeTraits::set_parent(node2, temp);


      if((temp = NodeTraits::get_left(node1))){
         NodeTraits::set_parent(temp, node1);
      }
      if((temp = NodeTraits::get_right(node1))){
         NodeTraits::set_parent(temp, node1);
      }
      if((temp = NodeTraits::get_parent(node1)) &&

         temp != header2){
         if(NodeTraits::get_left(temp) == node2){
            NodeTraits::set_left(temp, node1);
         }
         if(NodeTraits::get_right(temp) == node2){
            NodeTraits::set_right(temp, node1);
         }
      }

      if((temp = NodeTraits::get_left(node2))){
         NodeTraits::set_parent(temp, node2);
      }
      if((temp = NodeTraits::get_right(node2))){
         NodeTraits::set_parent(temp, node2);
      }
      if((temp = NodeTraits::get_parent(node2)) &&

         temp != header1){
         if(NodeTraits::get_left(temp) == node1){
            NodeTraits::set_left(temp, node2);
         }
         if(NodeTraits::get_right(temp) == node1){
            NodeTraits::set_right(temp, node2);
         }
      }
   }
# 451 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
   {
      if(node_to_be_replaced == new_node)
         return;
      replace_node(node_to_be_replaced, base_type::get_header(node_to_be_replaced), new_node);
   }
# 472 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
   {
      if(node_to_be_replaced == new_node)
         return;


      if(node_to_be_replaced == NodeTraits::get_left(header)){
         NodeTraits::set_left(header, new_node);
      }

      if(node_to_be_replaced == NodeTraits::get_right(header)){
         NodeTraits::set_right(header, new_node);
      }

      if(node_to_be_replaced == NodeTraits::get_parent(header)){
         NodeTraits::set_parent(header, new_node);
      }


      node_ptr temp;
      NodeTraits::set_left(new_node, NodeTraits::get_left(node_to_be_replaced));
      NodeTraits::set_right(new_node, NodeTraits::get_right(node_to_be_replaced));
      NodeTraits::set_parent(new_node, NodeTraits::get_parent(node_to_be_replaced));


      if((temp = NodeTraits::get_left(new_node))){
         NodeTraits::set_parent(temp, new_node);
      }
      if((temp = NodeTraits::get_right(new_node))){
         NodeTraits::set_parent(temp, new_node);
      }
      if((temp = NodeTraits::get_parent(new_node)) &&

         temp != header){
         if(NodeTraits::get_left(temp) == node_to_be_replaced){
            NodeTraits::set_left(temp, new_node);
         }
         if(NodeTraits::get_right(temp) == node_to_be_replaced){
            NodeTraits::set_right(temp, new_node);
         }
      }
   }
# 562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static void init(const node_ptr & node)
   {
      NodeTraits::set_parent(node, node_ptr());
      NodeTraits::set_left(node, node_ptr());
      NodeTraits::set_right(node, node_ptr());
   };






   inline static bool inited(const const_node_ptr & node)
   {
      return !NodeTraits::get_parent(node) &&
             !NodeTraits::get_left(node) &&
             !NodeTraits::get_right(node) ;
   };
# 591 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static void init_header(const node_ptr & header)
   {
      NodeTraits::set_parent(header, node_ptr());
      NodeTraits::set_left(header, header);
      NodeTraits::set_right(header, header);
   }
# 609 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class Disposer>
   static void clear_and_dispose(const node_ptr & header, Disposer disposer)
   {
      node_ptr source_root = NodeTraits::get_parent(header);
      if(!source_root)
         return;
      dispose_subtree(source_root, disposer);
      init_header(header);
   }
# 632 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
   {
      node_ptr leftmost = NodeTraits::get_left(header);
      if (leftmost == header)
         return node_ptr();
      node_ptr leftmost_parent(NodeTraits::get_parent(leftmost));
      node_ptr leftmost_right (NodeTraits::get_right(leftmost));
      bool is_root = leftmost_parent == header;

      if (leftmost_right){
         NodeTraits::set_parent(leftmost_right, leftmost_parent);
         NodeTraits::set_left(header, base_type::minimum(leftmost_right));

         if (is_root)
            NodeTraits::set_parent(header, leftmost_right);
         else
            NodeTraits::set_left(NodeTraits::get_parent(header), leftmost_right);
      }
      else if (is_root){
         NodeTraits::set_parent(header, node_ptr());
         NodeTraits::set_left(header, header);
         NodeTraits::set_right(header, header);
      }
      else{
         NodeTraits::set_left(leftmost_parent, node_ptr());
         NodeTraits::set_left(header, leftmost_parent);
      }
      return leftmost;
   }
# 669 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static std::size_t size(const const_node_ptr & header)
   {
      node_ptr beg(begin_node(header));
      node_ptr end(end_node(header));
      std::size_t i = 0;
      for(;beg != end; beg = base_type::next_node(beg)) ++i;
      return i;
   }
# 687 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void swap_tree(const node_ptr & header1, const node_ptr & header2)
   {
      if(header1 == header2)
         return;

      node_ptr tmp;


      tmp = NodeTraits::get_parent(header1);
      NodeTraits::set_parent(header1, NodeTraits::get_parent(header2));
      NodeTraits::set_parent(header2, tmp);

      tmp = NodeTraits::get_left(header1);
      NodeTraits::set_left(header1, NodeTraits::get_left(header2));
      NodeTraits::set_left(header2, tmp);

      tmp = NodeTraits::get_right(header1);
      NodeTraits::set_right(header1, NodeTraits::get_right(header2));
      NodeTraits::set_right(header2, tmp);


      node_ptr h1_parent(NodeTraits::get_parent(header1));
      if(h1_parent){
         NodeTraits::set_parent(h1_parent, header1);
      }
      else{
         NodeTraits::set_left(header1, header1);
         NodeTraits::set_right(header1, header1);
      }

      node_ptr h2_parent(NodeTraits::get_parent(header2));
      if(h2_parent){
         NodeTraits::set_parent(h2_parent, header2);
      }
      else{
         NodeTraits::set_left(header2, header2);
         NodeTraits::set_right(header2, header2);
      }
   }
# 749 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr find
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      node_ptr end = detail::uncast(header);
      node_ptr y = lower_bound(header, key, comp);
      return (y == end || comp(key, y)) ? end : y;
   }
# 779 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template< class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, node_ptr> bounded_range
      ( const const_node_ptr & header
      , const KeyType &lower_key
      , const KeyType &upper_key
      , KeyNodePtrCompare comp
      , bool left_closed
      , bool right_closed)
   {
      node_ptr y = detail::uncast(header);
      node_ptr x = NodeTraits::get_parent(header);

      while(x){


         if(comp(x, lower_key)){

            (static_cast<void> (0));
            x = NodeTraits::get_right(x);
         }


         else if(comp(upper_key, x)){
            y = x;
            x = NodeTraits::get_left(x);
         }
         else{




            (static_cast<void> (0));
            return std::pair<node_ptr,node_ptr>(
               left_closed



                  ? lower_bound_loop(NodeTraits::get_left(x), x, lower_key, comp)


                  : upper_bound_loop(x, y, lower_key, comp)
            ,
               right_closed



                  ? upper_bound_loop(NodeTraits::get_right(x), y, upper_key, comp)


                  : lower_bound_loop(x, y, upper_key, comp)
            );
         }
      }
      return std::pair<node_ptr,node_ptr> (y, y);
   }
# 846 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   static std::size_t count
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      std::pair<node_ptr, node_ptr> ret = equal_range(header, key, comp);
      std::size_t n = 0;
      while(ret.first != ret.second){
         ++n;
         ret.first = base_type::next_node(ret.first);
      }
      return n;
   }
# 872 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   inline static std::pair<node_ptr, node_ptr> equal_range
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      return bounded_range(header, key, key, comp, true, true);
   }
# 892 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, node_ptr> lower_bound_range
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      node_ptr const lb(lower_bound(header, key, comp));
      std::pair<node_ptr, node_ptr> ret_ii(lb, lb);
      if(lb != header && !comp(key, lb)){
         ret_ii.second = base_type::next_node(ret_ii.second);
      }
      return ret_ii;
   }
# 916 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   inline static node_ptr lower_bound
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      return lower_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
   }
# 934 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   inline static node_ptr upper_bound
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      return upper_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
   }
# 958 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static void insert_unique_commit
      (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
   { return insert_commit(header, new_value, commit_data); }
# 996 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, bool> insert_unique_check
      (const const_node_ptr & header, const KeyType &key
      ,KeyNodePtrCompare comp, insert_commit_data &commit_data

         , std::size_t *pdepth = 0

      )
   {
      std::size_t depth = 0;
      node_ptr h(detail::uncast(header));
      node_ptr y(h);
      node_ptr x(NodeTraits::get_parent(y));
      node_ptr prev = node_ptr();



      bool left_child = true;
      while(x){
         ++depth;
         y = x;
         x = (left_child = comp(key, x)) ?
               NodeTraits::get_left(x) : (prev = y, NodeTraits::get_right(x));
      }

      if(pdepth) *pdepth = depth;




      const bool not_present = !prev || comp(prev, key);
      if(not_present){
         commit_data.link_left = left_child;
         commit_data.node = y;
      }
      return std::pair<node_ptr, bool>(prev, not_present);
   }
# 1073 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, bool> insert_unique_check
      (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
      ,KeyNodePtrCompare comp, insert_commit_data &commit_data

         , std::size_t *pdepth = 0

      )
   {

      if(hint == header || comp(key, hint)){
         node_ptr prev(hint);

         if(hint == begin_node(header) || comp((prev = base_type::prev_node(hint)), key)){
            commit_data.link_left = unique(header) || !NodeTraits::get_left(hint);
            commit_data.node = commit_data.link_left ? hint : prev;
            if(pdepth){
               *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
            }
            return std::pair<node_ptr, bool>(node_ptr(), true);
         }
      }

      return insert_unique_check(header, key, comp, commit_data, pdepth);
   }
# 1113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class NodePtrCompare>
   static node_ptr insert_equal
      (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp

         , std::size_t *pdepth = 0

      )
   {
      insert_commit_data commit_data;
      insert_equal_check(h, hint, new_node, comp, commit_data, pdepth);
      insert_commit(h, new_node, commit_data);
      return new_node;
   }
# 1139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class NodePtrCompare>
   static node_ptr insert_equal_upper_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp

         , std::size_t *pdepth = 0

      )
   {
      insert_commit_data commit_data;
      insert_equal_upper_bound_check(h, new_node, comp, commit_data, pdepth);
      insert_commit(h, new_node, commit_data);
      return new_node;
   }
# 1165 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class NodePtrCompare>
   static node_ptr insert_equal_lower_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp

         , std::size_t *pdepth = 0

      )
   {
      insert_commit_data commit_data;
      insert_equal_lower_bound_check(h, new_node, comp, commit_data, pdepth);
      insert_commit(h, new_node, commit_data);
      return new_node;
   }
# 1193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static node_ptr insert_before
      (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node

         , std::size_t *pdepth = 0

      )
   {
      insert_commit_data commit_data;
      insert_before_check(header, pos, commit_data, pdepth);
      insert_commit(header, new_node, commit_data);
      return new_node;
   }
# 1219 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void push_back
      (const node_ptr & header, const node_ptr & new_node

         , std::size_t *pdepth = 0

      )
   {
      insert_commit_data commit_data;
      push_back_check(header, commit_data, pdepth);
      insert_commit(header, new_node, commit_data);
   }
# 1244 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void push_front
      (const node_ptr & header, const node_ptr & new_node

         , std::size_t *pdepth = 0

      )
   {
      insert_commit_data commit_data;
      push_front_check(header, commit_data, pdepth);
      insert_commit(header, new_node, commit_data);
   }
# 1265 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static std::size_t depth(const_node_ptr node)
   {
      std::size_t depth = 0;
      node_ptr p_parent;
      while(node != NodeTraits::get_parent(p_parent = NodeTraits::get_parent(node))){
         ++depth;
         node = p_parent;
      }
      return depth;
   }
# 1293 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template <class Cloner, class Disposer>
   static void clone
      (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
   {
      if(!unique(target_header)){
         clear_and_dispose(target_header, disposer);
      }

      node_ptr leftmost, rightmost;
      node_ptr new_root = clone_subtree
         (source_header, target_header, cloner, disposer, leftmost, rightmost);


      NodeTraits::set_parent(target_header, new_root);
      NodeTraits::set_left (target_header, leftmost);
      NodeTraits::set_right (target_header, rightmost);
   }
# 1319 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static void erase(const node_ptr & header, const node_ptr & z)
   {
      data_for_rebalance ignored;
      erase(header, z, ignored);
   }
# 1337 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class NodePtrCompare>
   inline static bool transfer_unique
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
   {
      data_for_rebalance ignored;
      return transfer_unique(header1, comp, header2, z, ignored);
   }
# 1354 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class NodePtrCompare>
   inline static void transfer_equal
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
   {
      data_for_rebalance ignored;
      transfer_equal(header1, comp, header2, z, ignored);
   }
# 1369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void unlink(const node_ptr & node)
   {
      node_ptr x = NodeTraits::get_parent(node);
      if(x){
         while(!base_type::is_header(x))
            x = NodeTraits::get_parent(x);
         erase(x, node);
      }
   }
# 1386 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static void rebalance(const node_ptr & header)
   {
      node_ptr root = NodeTraits::get_parent(header);
      if(root){
         rebalance_subtree(root);
      }
   }
# 1403 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static node_ptr rebalance_subtree(const node_ptr & old_root)
   {
# 1414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
      node_ptr super_root = NodeTraits::get_parent(old_root);
      (static_cast<void> (0));


      node_ptr super_root_right_backup = NodeTraits::get_right(super_root);
      bool super_root_is_header = NodeTraits::get_parent(super_root) == old_root;
      bool old_root_is_right = is_right_child(old_root);
      NodeTraits::set_right(super_root, old_root);

      std::size_t size;
      subtree_to_vine(super_root, size);
      vine_to_subtree(super_root, size);
      node_ptr new_root = NodeTraits::get_right(super_root);


      if(super_root_is_header){
         NodeTraits::set_right(super_root, super_root_right_backup);
         NodeTraits::set_parent(super_root, new_root);
      }
      else if(old_root_is_right){
         NodeTraits::set_right(super_root, new_root);
      }
      else{
         NodeTraits::set_right(super_root, super_root_right_backup);
         NodeTraits::set_left(super_root, new_root);
      }
      return new_root;
   }
# 1451 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   template<class Checker>
   static void check(const const_node_ptr& header, Checker checker, typename Checker::return_type& checker_return)
   {
      const_node_ptr root_node_ptr = NodeTraits::get_parent(header);
      if (!root_node_ptr){

         (static_cast<void> (0));
         (static_cast<void> (0));
      }
      else{

         (static_cast<void> (0));

         check_subtree(root_node_ptr, checker, checker_return);

         const_node_ptr p = root_node_ptr;
         while (NodeTraits::get_left(p)) { p = NodeTraits::get_left(p); }
         (static_cast<void> (0));
         p = root_node_ptr;
         while (NodeTraits::get_right(p)) { p = NodeTraits::get_right(p); }
         (static_cast<void> (0));
      }
   }

   protected:

   template<class NodePtrCompare>
   static bool transfer_unique
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z, data_for_rebalance &info)
   {
      insert_commit_data commit_data;
      bool const transferable = insert_unique_check(header1, z, comp, commit_data).second;
      if(transferable){
         erase(header2, z, info);
         insert_commit(header1, z, commit_data);
      }
      return transferable;
   }

   template<class NodePtrCompare>
   static void transfer_equal
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z, data_for_rebalance &info)
   {
      insert_commit_data commit_data;
      insert_equal_upper_bound_check(header1, z, comp, commit_data);
      erase(header2, z, info);
      insert_commit(header1, z, commit_data);
   }

   static void erase(const node_ptr & header, const node_ptr & z, data_for_rebalance &info)
   {
      node_ptr y(z);
      node_ptr x;
      const node_ptr z_left(NodeTraits::get_left(z));
      const node_ptr z_right(NodeTraits::get_right(z));

      if(!z_left){
         x = z_right;
      }
      else if(!z_right){
         x = z_left;
         (static_cast<void> (0));
      }
      else{

         y = base_type::minimum(z_right);
         x = NodeTraits::get_right(y);
      }

      node_ptr x_parent;
      const node_ptr z_parent(NodeTraits::get_parent(z));
      const bool z_is_leftchild(NodeTraits::get_left(z_parent) == z);

      if(y != z){



         NodeTraits::set_parent(z_left, y);
         NodeTraits::set_left(y, z_left);
         if(y != z_right){

            NodeTraits::set_right(y, z_right);
            NodeTraits::set_parent(z_right, y);

            x_parent = NodeTraits::get_parent(y);
            (static_cast<void> (0));
            if(x)
               NodeTraits::set_parent(x, x_parent);

            NodeTraits::set_left(x_parent, x);
         }
         else{
            x_parent = y;
         }
         NodeTraits::set_parent(y, z_parent);
         this_type::set_child(header, y, z_parent, z_is_leftchild);
      }
      else {

         x_parent = z_parent;
         if(x)
            NodeTraits::set_parent(x, z_parent);
         this_type::set_child(header, x, z_parent, z_is_leftchild);


         if(NodeTraits::get_left(header) == z){

            (static_cast<void> (0));
            NodeTraits::set_left(header, !z_right ?
               z_parent :
               base_type::minimum(z_right));
         }
         if(NodeTraits::get_right(header) == z){

            (static_cast<void> (0));
            NodeTraits::set_right(header, !z_left ?
               z_parent :
               base_type::maximum(z_left));
         }
      }



      info.x = x;
      info.y = y;


      (static_cast<void> (0));
      info.x_parent = x_parent;
   }
# 1589 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static std::size_t subtree_size(const const_node_ptr & subtree)
   {
      std::size_t count = 0;
      if (subtree){
         node_ptr n = detail::uncast(subtree);
         node_ptr m = NodeTraits::get_left(n);
         while(m){
            n = m;
            m = NodeTraits::get_left(n);
         }

         while(1){
            ++count;
            node_ptr n_right(NodeTraits::get_right(n));
            if(n_right){
               n = n_right;
               m = NodeTraits::get_left(n);
               while(m){
                  n = m;
                  m = NodeTraits::get_left(n);
               }
            }
            else {
               do{
                  if (n == subtree){
                     return count;
                  }
                  m = n;
                  n = NodeTraits::get_parent(n);
               }while(NodeTraits::get_left(n) != m);
            }
         }
      }
      return count;
   }
# 1632 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static bool is_left_child(const node_ptr & p)
   { return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; }
# 1642 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   inline static bool is_right_child(const node_ptr & p)
   { return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; }

   static void insert_before_check
      (const node_ptr &header, const node_ptr & pos
      , insert_commit_data &commit_data

         , std::size_t *pdepth = 0

      )
   {
      node_ptr prev(pos);
      if(pos != NodeTraits::get_left(header))
         prev = base_type::prev_node(pos);
      bool link_left = unique(header) || !NodeTraits::get_left(pos);
      commit_data.link_left = link_left;
      commit_data.node = link_left ? pos : prev;
      if(pdepth){
         *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
      }
   }

   static void push_back_check
      (const node_ptr & header, insert_commit_data &commit_data

         , std::size_t *pdepth = 0

      )
   {
      node_ptr prev(NodeTraits::get_right(header));
      if(pdepth){
         *pdepth = prev == header ? 0 : depth(prev) + 1;
      }
      commit_data.link_left = false;
      commit_data.node = prev;
   }

   static void push_front_check
      (const node_ptr & header, insert_commit_data &commit_data

         , std::size_t *pdepth = 0

      )
   {
      node_ptr pos(NodeTraits::get_left(header));
      if(pdepth){
         *pdepth = pos == header ? 0 : depth(pos) + 1;
      }
      commit_data.link_left = true;
      commit_data.node = pos;
   }

   template<class NodePtrCompare>
   static void insert_equal_check
      (const node_ptr &header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
      , insert_commit_data &commit_data

      , std::size_t *pdepth = 0

      )
   {
      if(hint == header || !comp(hint, new_node)){
         node_ptr prev(hint);
         if(hint == NodeTraits::get_left(header) ||
            !comp(new_node, (prev = base_type::prev_node(hint)))){
            bool link_left = unique(header) || !NodeTraits::get_left(hint);
            commit_data.link_left = link_left;
            commit_data.node = link_left ? hint : prev;
            if(pdepth){
               *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
            }
         }
         else{
            insert_equal_upper_bound_check(header, new_node, comp, commit_data, pdepth);
         }
      }
      else{
         insert_equal_lower_bound_check(header, new_node, comp, commit_data, pdepth);
      }
   }

   template<class NodePtrCompare>
   static void insert_equal_upper_bound_check
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
   {
      std::size_t depth = 0;
      node_ptr y(h);
      node_ptr x(NodeTraits::get_parent(y));

      while(x){
         ++depth;
         y = x;
         x = comp(new_node, x) ?
               NodeTraits::get_left(x) : NodeTraits::get_right(x);
      }
      if(pdepth) *pdepth = depth;
      commit_data.link_left = (y == h) || comp(new_node, y);
      commit_data.node = y;
   }

   template<class NodePtrCompare>
   static void insert_equal_lower_bound_check
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
   {
      std::size_t depth = 0;
      node_ptr y(h);
      node_ptr x(NodeTraits::get_parent(y));

      while(x){
         ++depth;
         y = x;
         x = !comp(x, new_node) ?
               NodeTraits::get_left(x) : NodeTraits::get_right(x);
      }
      if(pdepth) *pdepth = depth;
      commit_data.link_left = (y == h) || !comp(y, new_node);
      commit_data.node = y;
   }

   static void insert_commit
      (const node_ptr & header, const node_ptr & new_node, const insert_commit_data &commit_data)
   {

      (static_cast<void> (0));
      node_ptr parent_node(commit_data.node);
      if(parent_node == header){
         NodeTraits::set_parent(header, new_node);
         NodeTraits::set_right(header, new_node);
         NodeTraits::set_left(header, new_node);
      }
      else if(commit_data.link_left){
         NodeTraits::set_left(parent_node, new_node);
         if(parent_node == NodeTraits::get_left(header))
             NodeTraits::set_left(header, new_node);
      }
      else{
         NodeTraits::set_right(parent_node, new_node);
         if(parent_node == NodeTraits::get_right(header))
             NodeTraits::set_right(header, new_node);
      }
      NodeTraits::set_parent(new_node, parent_node);
      NodeTraits::set_right(new_node, node_ptr());
      NodeTraits::set_left(new_node, node_ptr());
   }


   static void set_child(const node_ptr & header, const node_ptr & new_child, const node_ptr & new_parent, const bool link_left)
   {
      if(new_parent == header)
         NodeTraits::set_parent(header, new_child);
      else if(link_left)
         NodeTraits::set_left(new_parent, new_child);
      else
         NodeTraits::set_right(new_parent, new_child);
   }


   static void rotate_left_no_parent_fix(const node_ptr & p, const node_ptr &p_right)
   {
      node_ptr p_right_left(NodeTraits::get_left(p_right));
      NodeTraits::set_right(p, p_right_left);
      if(p_right_left){
         NodeTraits::set_parent(p_right_left, p);
      }
      NodeTraits::set_left(p_right, p);
      NodeTraits::set_parent(p, p_right);
   }


   static void rotate_left(const node_ptr & p, const node_ptr & p_right, const node_ptr & p_parent, const node_ptr & header)
   {
      const bool p_was_left(NodeTraits::get_left(p_parent) == p);
      rotate_left_no_parent_fix(p, p_right);
      NodeTraits::set_parent(p_right, p_parent);
      set_child(header, p_right, p_parent, p_was_left);
   }


   static void rotate_right_no_parent_fix(const node_ptr & p, const node_ptr &p_left)
   {
      node_ptr p_left_right(NodeTraits::get_right(p_left));
      NodeTraits::set_left(p, p_left_right);
      if(p_left_right){
         NodeTraits::set_parent(p_left_right, p);
      }
      NodeTraits::set_right(p_left, p);
      NodeTraits::set_parent(p, p_left);
   }


   static void rotate_right(const node_ptr & p, const node_ptr & p_left, const node_ptr & p_parent, const node_ptr & header)
   {
      const bool p_was_left(NodeTraits::get_left(p_parent) == p);
      rotate_right_no_parent_fix(p, p_left);
      NodeTraits::set_parent(p_left, p_parent);
      set_child(header, p_left, p_parent, p_was_left);
   }

   private:

   static void subtree_to_vine(node_ptr vine_tail, std::size_t &size)
   {






      std::size_t len = 0;
      node_ptr remainder = NodeTraits::get_right(vine_tail);
      while(remainder){
         node_ptr tempptr = NodeTraits::get_left(remainder);
         if(!tempptr){
            vine_tail = remainder;
            remainder = NodeTraits::get_right(remainder);
            ++len;
         }
         else{
            NodeTraits::set_left(remainder, NodeTraits::get_right(tempptr));
            NodeTraits::set_right(tempptr, remainder);
            remainder = tempptr;
            NodeTraits::set_right(vine_tail, tempptr);
         }
      }
      size = len;
   }

   static void compress_subtree(node_ptr scanner, std::size_t count)
   {
      while(count--){
         node_ptr child = NodeTraits::get_right(scanner);
         node_ptr child_right = NodeTraits::get_right(child);
         NodeTraits::set_right(scanner, child_right);

         scanner = child_right;
         node_ptr scanner_left = NodeTraits::get_left(scanner);
         NodeTraits::set_right(child, scanner_left);
         if(scanner_left)
            NodeTraits::set_parent(scanner_left, child);
         NodeTraits::set_left(scanner, child);
         NodeTraits::set_parent(child, scanner);
      }
   }

   static void vine_to_subtree(const node_ptr & super_root, std::size_t count)
   {
      const std::size_t one_szt = 1u;
      std::size_t leaf_nodes = count + one_szt - std::size_t(one_szt << detail::floor_log2(count + one_szt));
      compress_subtree(super_root, leaf_nodes);
      std::size_t vine_nodes = count - leaf_nodes;
      while(vine_nodes > 1){
         vine_nodes /= 2;
         compress_subtree(super_root, vine_nodes);
      }



      for ( node_ptr q = super_root, p = NodeTraits::get_right(super_root)
          ; p
          ; q = p, p = NodeTraits::get_right(p)){
         NodeTraits::set_parent(p, q);
      }
   }
# 1913 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 3 4
   static node_ptr get_root(const node_ptr & node)
   {
      (static_cast<void> (0));
      node_ptr x = NodeTraits::get_parent(node);
      if(x){
         while(!base_type::is_header(x)){
            x = NodeTraits::get_parent(x);
         }
         return x;
      }
      else{
         return node;
      }
   }

   template <class Cloner, class Disposer>
   static node_ptr clone_subtree
      (const const_node_ptr &source_parent, const node_ptr &target_parent
      , Cloner cloner, Disposer disposer
      , node_ptr &leftmost_out, node_ptr &rightmost_out
      )
   {
      node_ptr target_sub_root = target_parent;
      node_ptr source_root = NodeTraits::get_parent(source_parent);
      if(!source_root){
         leftmost_out = rightmost_out = source_root;
      }
      else{

         node_ptr current = source_root;
         node_ptr insertion_point = target_sub_root = cloner(current);


         node_ptr leftmost = target_sub_root;
         node_ptr rightmost = target_sub_root;


         NodeTraits::set_left(target_sub_root, node_ptr());
         NodeTraits::set_right(target_sub_root, node_ptr());
         NodeTraits::set_parent(target_sub_root, target_parent);

         dispose_subtree_disposer<Disposer> rollback(disposer, target_sub_root);
         while(true) {

            if( NodeTraits::get_left(current) &&
               !NodeTraits::get_left(insertion_point)) {
               current = NodeTraits::get_left(current);
               node_ptr temp = insertion_point;

               insertion_point = cloner(current);
               NodeTraits::set_left (insertion_point, node_ptr());
               NodeTraits::set_right (insertion_point, node_ptr());

               NodeTraits::set_parent(insertion_point, temp);
               NodeTraits::set_left (temp, insertion_point);

               if(rightmost == target_sub_root)
                  leftmost = insertion_point;
            }

            else if( NodeTraits::get_right(current) &&
                     !NodeTraits::get_right(insertion_point)){
               current = NodeTraits::get_right(current);
               node_ptr temp = insertion_point;

               insertion_point = cloner(current);
               NodeTraits::set_left (insertion_point, node_ptr());
               NodeTraits::set_right (insertion_point, node_ptr());

               NodeTraits::set_parent(insertion_point, temp);
               NodeTraits::set_right (temp, insertion_point);

               rightmost = insertion_point;
            }

            else if(current == source_root){
               break;
            }
            else{

               current = NodeTraits::get_parent(current);
               insertion_point = NodeTraits::get_parent(insertion_point);
            }
         }
         rollback.release();
         leftmost_out = leftmost;
         rightmost_out = rightmost;
      }
      return target_sub_root;
   }

   template<class Disposer>
   static void dispose_subtree(node_ptr x, Disposer disposer)
   {
      while (x){
         node_ptr save(NodeTraits::get_left(x));
         if (save) {

            NodeTraits::set_left(x, NodeTraits::get_right(save));
            NodeTraits::set_right(save, x);
         }
         else {
            save = NodeTraits::get_right(x);
            init(x);
            disposer(x);
         }
         x = save;
      }
   }

   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr lower_bound_loop
      (node_ptr x, node_ptr y, const KeyType &key, KeyNodePtrCompare comp)
   {
      while(x){
         if(comp(x, key)){
            x = NodeTraits::get_right(x);
         }
         else{
            y = x;
            x = NodeTraits::get_left(x);
         }
      }
      return y;
   }

   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr upper_bound_loop
      (node_ptr x, node_ptr y, const KeyType &key, KeyNodePtrCompare comp)
   {
      while(x){
         if(comp(key, x)){
            y = x;
            x = NodeTraits::get_left(x);
         }
         else{
            x = NodeTraits::get_right(x);
         }
      }
      return y;
   }

   template<class Checker>
   static void check_subtree(const const_node_ptr& node, Checker checker, typename Checker::return_type& check_return)
   {
      const_node_ptr left = NodeTraits::get_left(node);
      const_node_ptr right = NodeTraits::get_right(node);
      typename Checker::return_type check_return_left;
      typename Checker::return_type check_return_right;
      if (left)
      {
         (static_cast<void> (0));
         check_subtree(left, checker, check_return_left);
      }
      if (right)
      {
         (static_cast<void> (0));
         check_subtree(right, checker, check_return_right);
      }
      checker(node, check_return_left, check_return_right, check_return);
   }
};



template<class NodeTraits>
struct get_algo<BsTreeAlgorithms, NodeTraits>
{
   typedef bstree_algorithms<NodeTraits> type;
};

template <class ValueTraits, class NodePtrCompare, class ExtraChecker>
struct get_node_checker<BsTreeAlgorithms, ValueTraits, NodePtrCompare, ExtraChecker>
{
   typedef detail::bstree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker> type;
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 2096 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree_algorithms.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/ebo_functor_holder.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/ebo_functor_holder.hpp" 3 4
         





namespace boost {
namespace intrusive {
namespace detail {
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, bool = is_unary_or_binary_function<T>::value>
class ebo_functor_holder
{
  

   public:
   typedef T functor_type;

   inline ebo_functor_holder()
      : t_()
   {}

   inline explicit ebo_functor_holder(const T &t)
      : t_(t)
   {}

   inline explicit ebo_functor_holder(T && t)
      : t_(::boost::move(t))
   {}

   template<class Arg1, class Arg2>
   inline ebo_functor_holder(Arg1 && arg1, Arg2 && arg2)
      : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
   {}

   inline ebo_functor_holder(const ebo_functor_holder &x)
      : t_(x.t_)
   {}

   inline ebo_functor_holder(ebo_functor_holder && x)
      : t_(x.t_)
   {}

   inline ebo_functor_holder& operator=(const ebo_functor_holder & x)
   {
      this->get() = x.get();
      return *this;
   }

   inline ebo_functor_holder& operator=(ebo_functor_holder && x)
   {
      this->get() = ::boost::move(x.get());
      return *this;
   }

   inline ebo_functor_holder& operator=(const T &x)
   {
      this->get() = x;
      return *this;
   }

   inline ebo_functor_holder& operator=(T && x)
   {
      this->get() = ::boost::move(x);
      return *this;
   }

   inline T& get(){return t_;}
   inline const T& get()const{return t_;}

   private:
   T t_;
};

template<typename T>
class ebo_functor_holder<T, false>
   : public T
{
  

   public:
   typedef T functor_type;

   inline ebo_functor_holder()
      : T()
   {}

   inline explicit ebo_functor_holder(const T &t)
      : T(t)
   {}

   inline explicit ebo_functor_holder(T && t)
      : T(::boost::move(t))
   {}

   template<class Arg1, class Arg2>
   inline ebo_functor_holder(Arg1 && arg1, Arg2 && arg2)
      : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
   {}

   inline ebo_functor_holder(const ebo_functor_holder &x)
      : T(static_cast<const T&>(x))
   {}

   inline ebo_functor_holder(ebo_functor_holder && x)
      : T(::boost::move((T&)(x)))
   {}

   inline ebo_functor_holder& operator=(const ebo_functor_holder & x)
   {
      const ebo_functor_holder&r = x;
      this->get() = r;
      return *this;
   }

   inline ebo_functor_holder& operator=(ebo_functor_holder && x)
   {
      this->get() = ::boost::move(x.get());
      return *this;
   }

   inline ebo_functor_holder& operator=(const T &x)
   {
      this->get() = x;
      return *this;
   }

   inline ebo_functor_holder& operator=(T && x)
   {
      this->get() = ::boost::move(x);
      return *this;
   }

   inline T& get(){return *this;}
   inline const T& get()const{return *this;}
};

}
}
}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2 3 4


         


namespace boost {
namespace intrusive {



template<class NodeTraits, class F>
struct rbtree_node_cloner

   : public detail::ebo_functor_holder<F>
{
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef detail::ebo_functor_holder<F> base_t;

   explicit rbtree_node_cloner(F f)
      : base_t(f)
   {}

   node_ptr operator()(const node_ptr & p)
   {
      node_ptr n = base_t::get()(p);
      NodeTraits::set_color(n, NodeTraits::get_color(p));
      return n;
   }
};

namespace detail {

template<class ValueTraits, class NodePtrCompare, class ExtraChecker>
struct rbtree_node_checker
   : public bstree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker>
{
   typedef bstree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker> base_checker_t;
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef typename node_traits::node_ptr node_ptr;

   struct return_type
         : public base_checker_t::return_type
   {
      return_type() : black_count_(0) {}
      std::size_t black_count_;
   };

   rbtree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker)
      : base_checker_t(comp, extra_checker)
   {}

   void operator () (const const_node_ptr& p,
                     const return_type& check_return_left, const return_type& check_return_right,
                     return_type& check_return)
   {

      if (node_traits::get_color(p) == node_traits::red()){

         const node_ptr p_left(node_traits::get_left(p)); (void)p_left;
         const node_ptr p_right(node_traits::get_right(p)); (void)p_right;
         (static_cast<void> (0));
         (static_cast<void> (0));

         (static_cast<void> (0));
      }

      const std::size_t l_black_count = check_return_left.black_count_;
      (static_cast<void> (0));
      check_return.black_count_ = l_black_count +
         static_cast<std::size_t>(node_traits::get_color(p) == node_traits::black());
      base_checker_t::operator()(p, check_return_left, check_return_right, check_return);
   }
};

}
# 165 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 3 4
template<class NodeTraits>
class rbtree_algorithms

   : public bstree_algorithms<NodeTraits>

{
   public:
   typedef NodeTraits node_traits;
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef typename NodeTraits::color color;


   private:

   typedef bstree_algorithms<NodeTraits> bstree_algo;



   public:



   typedef typename bstree_algo::insert_commit_data insert_commit_data;
# 208 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 3 4
   static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
   {
      if(node1 == node2)
         return;

      node_ptr header1(bstree_algo::get_header(node1)), header2(bstree_algo::get_header(node2));
      swap_nodes(node1, header1, node2, header2);
   }


   static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
   {
      if(node1 == node2) return;

      bstree_algo::swap_nodes(node1, header1, node2, header2);

      color c = NodeTraits::get_color(node1);
      NodeTraits::set_color(node1, NodeTraits::get_color(node2));
      NodeTraits::set_color(node2, c);
   }


   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
   {
      if(node_to_be_replaced == new_node)
         return;
      replace_node(node_to_be_replaced, bstree_algo::get_header(node_to_be_replaced), new_node);
   }


   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
   {
      bstree_algo::replace_node(node_to_be_replaced, header, new_node);
      NodeTraits::set_color(new_node, NodeTraits::get_color(node_to_be_replaced));
   }


   static void unlink(const node_ptr& node)
   {
      node_ptr x = NodeTraits::get_parent(node);
      if(x){
         while(!is_header(x))
            x = NodeTraits::get_parent(x);
         erase(x, node);
      }
   }
# 276 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 3 4
   static void init_header(const node_ptr & header)
   {
      bstree_algo::init_header(header);
      NodeTraits::set_color(header, NodeTraits::red());
   }


   static node_ptr erase(const node_ptr & header, const node_ptr & z)
   {
      typename bstree_algo::data_for_rebalance info;
      bstree_algo::erase(header, z, info);
      rebalance_after_erasure(header, z, info);
      return z;
   }


   template<class NodePtrCompare>
   static bool transfer_unique
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
   {
      typename bstree_algo::data_for_rebalance info;
      bool const transferred = bstree_algo::transfer_unique(header1, comp, header2, z, info);
      if(transferred){
         rebalance_after_erasure(header2, z, info);
         rebalance_after_insertion(header1, z);
      }
      return transferred;
   }


   template<class NodePtrCompare>
   static void transfer_equal
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
   {
      typename bstree_algo::data_for_rebalance info;
      bstree_algo::transfer_equal(header1, comp, header2, z, info);
      rebalance_after_erasure(header2, z, info);
      rebalance_after_insertion(header1, z);
   }


   template <class Cloner, class Disposer>
   static void clone
      (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
   {
      rbtree_node_cloner<NodeTraits, Cloner> new_cloner(cloner);
      bstree_algo::clone(source_header, target_header, new_cloner, disposer);
   }
# 363 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 3 4
   template<class NodePtrCompare>
   static node_ptr insert_equal_upper_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
   {
      bstree_algo::insert_equal_upper_bound(h, new_node, comp);
      rebalance_after_insertion(h, new_node);
      return new_node;
   }


   template<class NodePtrCompare>
   static node_ptr insert_equal_lower_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
   {
      bstree_algo::insert_equal_lower_bound(h, new_node, comp);
      rebalance_after_insertion(h, new_node);
      return new_node;
   }


   template<class NodePtrCompare>
   static node_ptr insert_equal
      (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp)
   {
      bstree_algo::insert_equal(header, hint, new_node, comp);
      rebalance_after_insertion(header, new_node);
      return new_node;
   }


   static node_ptr insert_before
      (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node)
   {
      bstree_algo::insert_before(header, pos, new_node);
      rebalance_after_insertion(header, new_node);
      return new_node;
   }


   static void push_back(const node_ptr & header, const node_ptr & new_node)
   {
      bstree_algo::push_back(header, new_node);
      rebalance_after_insertion(header, new_node);
   }


   static void push_front(const node_ptr & header, const node_ptr & new_node)
   {
      bstree_algo::push_front(header, new_node);
      rebalance_after_insertion(header, new_node);
   }
# 430 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 3 4
   static void insert_unique_commit
      (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
   {
      bstree_algo::insert_unique_commit(header, new_value, commit_data);
      rebalance_after_insertion(header, new_value);
   }


   static bool is_header(const const_node_ptr & p)
   {
      return NodeTraits::get_color(p) == NodeTraits::red() &&
            bstree_algo::is_header(p);
   }


   private:

   static void rebalance_after_erasure
      ( const node_ptr & header, const node_ptr &z, const typename bstree_algo::data_for_rebalance &info)
   {
      color new_z_color;
      if(info.y != z){
         new_z_color = NodeTraits::get_color(info.y);
         NodeTraits::set_color(info.y, NodeTraits::get_color(z));
      }
      else{
         new_z_color = NodeTraits::get_color(z);
      }

      if(new_z_color != NodeTraits::red()){
         rebalance_after_erasure_restore_invariants(header, info.x, info.x_parent);
      }
   }

   static void rebalance_after_erasure_restore_invariants(const node_ptr & header, node_ptr x, node_ptr x_parent)
   {
      while(1){
         if(x_parent == header || (x && NodeTraits::get_color(x) != NodeTraits::black())){
            break;
         }


         const node_ptr x_parent_left(NodeTraits::get_left(x_parent));
         if(x == x_parent_left){
            node_ptr w = NodeTraits::get_right(x_parent);
            (static_cast<void> (0));
            if(NodeTraits::get_color(w) == NodeTraits::red()){
               NodeTraits::set_color(w, NodeTraits::black());
               NodeTraits::set_color(x_parent, NodeTraits::red());
               bstree_algo::rotate_left(x_parent, w, NodeTraits::get_parent(x_parent), header);
               w = NodeTraits::get_right(x_parent);
               (static_cast<void> (0));
            }
            node_ptr const w_left (NodeTraits::get_left(w));
            node_ptr const w_right(NodeTraits::get_right(w));
            if((!w_left || NodeTraits::get_color(w_left) == NodeTraits::black()) &&
               (!w_right || NodeTraits::get_color(w_right) == NodeTraits::black())){
               NodeTraits::set_color(w, NodeTraits::red());
               x = x_parent;
               x_parent = NodeTraits::get_parent(x_parent);
            }
            else {
               if(!w_right || NodeTraits::get_color(w_right) == NodeTraits::black()){
                  NodeTraits::set_color(w_left, NodeTraits::black());
                  NodeTraits::set_color(w, NodeTraits::red());
                  bstree_algo::rotate_right(w, w_left, NodeTraits::get_parent(w), header);
                  w = NodeTraits::get_right(x_parent);
                  (static_cast<void> (0));
               }
               NodeTraits::set_color(w, NodeTraits::get_color(x_parent));
               NodeTraits::set_color(x_parent, NodeTraits::black());
               const node_ptr new_wright(NodeTraits::get_right(w));
               if(new_wright)
                  NodeTraits::set_color(new_wright, NodeTraits::black());
               bstree_algo::rotate_left(x_parent, NodeTraits::get_right(x_parent), NodeTraits::get_parent(x_parent), header);
               break;
            }
         }
         else {

            node_ptr w = x_parent_left;
            if(NodeTraits::get_color(w) == NodeTraits::red()){
               NodeTraits::set_color(w, NodeTraits::black());
               NodeTraits::set_color(x_parent, NodeTraits::red());
               bstree_algo::rotate_right(x_parent, w, NodeTraits::get_parent(x_parent), header);
               w = NodeTraits::get_left(x_parent);
               (static_cast<void> (0));
            }
            node_ptr const w_left (NodeTraits::get_left(w));
            node_ptr const w_right(NodeTraits::get_right(w));
            if((!w_right || NodeTraits::get_color(w_right) == NodeTraits::black()) &&
               (!w_left || NodeTraits::get_color(w_left) == NodeTraits::black())){
               NodeTraits::set_color(w, NodeTraits::red());
               x = x_parent;
               x_parent = NodeTraits::get_parent(x_parent);
            }
            else {
               if(!w_left || NodeTraits::get_color(w_left) == NodeTraits::black()){
                  NodeTraits::set_color(w_right, NodeTraits::black());
                  NodeTraits::set_color(w, NodeTraits::red());
                  bstree_algo::rotate_left(w, w_right, NodeTraits::get_parent(w), header);
                  w = NodeTraits::get_left(x_parent);
                  (static_cast<void> (0));
               }
               NodeTraits::set_color(w, NodeTraits::get_color(x_parent));
               NodeTraits::set_color(x_parent, NodeTraits::black());
               const node_ptr new_wleft(NodeTraits::get_left(w));
               if(new_wleft)
                  NodeTraits::set_color(new_wleft, NodeTraits::black());
               bstree_algo::rotate_right(x_parent, NodeTraits::get_left(x_parent), NodeTraits::get_parent(x_parent), header);
               break;
            }
         }
      }
      if(x)
         NodeTraits::set_color(x, NodeTraits::black());
   }

   static void rebalance_after_insertion(const node_ptr & header, node_ptr p)
   {
      NodeTraits::set_color(p, NodeTraits::red());
      while(1){
         node_ptr p_parent(NodeTraits::get_parent(p));
         const node_ptr p_grandparent(NodeTraits::get_parent(p_parent));
         if(p_parent == header || NodeTraits::get_color(p_parent) == NodeTraits::black() || p_grandparent == header){
            break;
         }

         NodeTraits::set_color(p_grandparent, NodeTraits::red());
         node_ptr const p_grandparent_left (NodeTraits::get_left (p_grandparent));
         bool const p_parent_is_left_child = p_parent == p_grandparent_left;
         node_ptr const x(p_parent_is_left_child ? NodeTraits::get_right(p_grandparent) : p_grandparent_left);

         if(x && NodeTraits::get_color(x) == NodeTraits::red()){
            NodeTraits::set_color(x, NodeTraits::black());
            NodeTraits::set_color(p_parent, NodeTraits::black());
            p = p_grandparent;
         }
         else{
            const bool p_is_left_child(NodeTraits::get_left(p_parent) == p);
            if(p_parent_is_left_child){
               if(!p_is_left_child){
                  bstree_algo::rotate_left_no_parent_fix(p_parent, p);




                  p_parent = p;
               }
               bstree_algo::rotate_right(p_grandparent, p_parent, NodeTraits::get_parent(p_grandparent), header);
            }
            else{
               if(p_is_left_child){
                  bstree_algo::rotate_right_no_parent_fix(p_parent, p);




                  p_parent = p;
               }
               bstree_algo::rotate_left(p_grandparent, p_parent, NodeTraits::get_parent(p_grandparent), header);
            }
            NodeTraits::set_color(p_parent, NodeTraits::black());
            break;
         }
      }
      NodeTraits::set_color(NodeTraits::get_parent(header), NodeTraits::black());
   }

};



template<class NodeTraits>
struct get_algo<RbTreeAlgorithms, NodeTraits>
{
   typedef rbtree_algorithms<NodeTraits> type;
};

template <class ValueTraits, class NodePtrCompare, class ExtraChecker>
struct get_node_checker<RbTreeAlgorithms, ValueTraits, NodePtrCompare, ExtraChecker>
{
    typedef detail::rbtree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker> type;
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 621 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_plus_bits.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_plus_bits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_plus_bits.hpp" 2 3 4





         
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_plus_bits.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"



namespace boost {
namespace intrusive {





template<class VoidPointer, std::size_t Alignment>
struct max_pointer_plus_bits
{
   static const std::size_t value = 0;
};




template<std::size_t Alignment>
struct max_pointer_plus_bits<void*, Alignment>
{
   static const std::size_t value = detail::ls_zeros<Alignment>::value;
};
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_plus_bits.hpp" 3 4
template<class Pointer, std::size_t NumBits>
struct pointer_plus_bits



;



template<class T, std::size_t NumBits>
struct pointer_plus_bits<T*, NumBits>
{
   static const uintptr_t Mask = uintptr_t((uintptr_t(1u) << NumBits) - 1);
   typedef T* pointer;

   inline static pointer get_pointer(pointer n)
   { return pointer(uintptr_t(n) & uintptr_t(~Mask)); }

   inline static void set_pointer(pointer &n, pointer p)
   {
      (static_cast<void> (0));
      n = pointer(uintptr_t(p) | (uintptr_t(n) & Mask));
   }

   inline static std::size_t get_bits(pointer n)
   { return std::size_t(uintptr_t(n) & Mask); }

   inline static void set_bits(pointer &n, std::size_t c)
   {
      (static_cast<void> (0));
      n = pointer(uintptr_t((get_pointer)(n)) | uintptr_t(c));
   }
};

}
}


#pragma GCC diagnostic pop


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/pointer_plus_bits.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_node.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_node.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_node.hpp" 2 3 4



namespace boost {
namespace intrusive {

template<class VoidPointer>
struct tree_node
{
   typedef typename pointer_rebind<VoidPointer, tree_node>::type node_ptr;

   node_ptr parent_, left_, right_;
};

template<class VoidPointer>
struct tree_node_traits
{
   typedef tree_node<VoidPointer> node;

   typedef typename node::node_ptr node_ptr;
   typedef typename pointer_rebind<VoidPointer, const node>::type const_node_ptr;

   inline static node_ptr get_parent(const const_node_ptr & n)
   { return n->parent_; }

   inline static node_ptr get_parent(const node_ptr & n)
   { return n->parent_; }

   inline static void set_parent(const node_ptr & n, const node_ptr & p)
   { n->parent_ = p; }

   inline static node_ptr get_left(const const_node_ptr & n)
   { return n->left_; }

   inline static node_ptr get_left(const node_ptr & n)
   { return n->left_; }

   inline static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   inline static node_ptr get_right(const const_node_ptr & n)
   { return n->right_; }

   inline static node_ptr get_right(const node_ptr & n)
   { return n->right_; }

   inline static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_node.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2 3 4

namespace boost {
namespace intrusive {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 3 4
template<class VoidPointer>
struct compact_rbtree_node
{
   typedef compact_rbtree_node<VoidPointer> node;
   typedef typename pointer_rebind<VoidPointer, node >::type node_ptr;
   typedef typename pointer_rebind<VoidPointer, const node >::type const_node_ptr;
   enum color { red_t, black_t };
   node_ptr parent_, left_, right_;
};


template<class VoidPointer>
struct rbtree_node
{
   typedef rbtree_node<VoidPointer> node;
   typedef typename pointer_rebind<VoidPointer, node >::type node_ptr;
   typedef typename pointer_rebind<VoidPointer, const node >::type const_node_ptr;

   enum color { red_t, black_t };
   node_ptr parent_, left_, right_;
   color color_;
};



template<class VoidPointer>
struct default_rbtree_node_traits_impl
{
   typedef rbtree_node<VoidPointer> node;
   typedef typename node::node_ptr node_ptr;
   typedef typename node::const_node_ptr const_node_ptr;

   typedef typename node::color color;

   inline static node_ptr get_parent(const const_node_ptr & n)
   { return n->parent_; }

   inline static node_ptr get_parent(const node_ptr & n)
   { return n->parent_; }

   inline static void set_parent(const node_ptr & n, const node_ptr & p)
   { n->parent_ = p; }

   inline static node_ptr get_left(const const_node_ptr & n)
   { return n->left_; }

   inline static node_ptr get_left(const node_ptr & n)
   { return n->left_; }

   inline static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   inline static node_ptr get_right(const const_node_ptr & n)
   { return n->right_; }

   inline static node_ptr get_right(const node_ptr & n)
   { return n->right_; }

   inline static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }

   inline static color get_color(const const_node_ptr & n)
   { return n->color_; }

   inline static color get_color(const node_ptr & n)
   { return n->color_; }

   inline static void set_color(const node_ptr & n, color c)
   { n->color_ = c; }

   inline static color black()
   { return node::black_t; }

   inline static color red()
   { return node::red_t; }
};



template<class VoidPointer>
struct compact_rbtree_node_traits_impl
{
   typedef compact_rbtree_node<VoidPointer> node;
   typedef typename node::node_ptr node_ptr;
   typedef typename node::const_node_ptr const_node_ptr;

   typedef pointer_plus_bits<node_ptr, 1> ptr_bit;

   typedef typename node::color color;

   inline static node_ptr get_parent(const const_node_ptr & n)
   { return ptr_bit::get_pointer(n->parent_); }

   inline static node_ptr get_parent(const node_ptr & n)
   { return ptr_bit::get_pointer(n->parent_); }

   inline static void set_parent(const node_ptr & n, const node_ptr & p)
   { ptr_bit::set_pointer(n->parent_, p); }

   inline static node_ptr get_left(const const_node_ptr & n)
   { return n->left_; }

   inline static node_ptr get_left(const node_ptr & n)
   { return n->left_; }

   inline static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   inline static node_ptr get_right(const const_node_ptr & n)
   { return n->right_; }

   inline static node_ptr get_right(const node_ptr & n)
   { return n->right_; }

   inline static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }

   inline static color get_color(const const_node_ptr & n)
   { return (color)ptr_bit::get_bits(n->parent_); }

   inline static color get_color(const node_ptr & n)
   { return (color)ptr_bit::get_bits(n->parent_); }

   inline static void set_color(const node_ptr & n, color c)
   { ptr_bit::set_bits(n->parent_, c != 0); }

   inline static color black()
   { return node::black_t; }

   inline static color red()
   { return node::red_t; }
};


template<class VoidPointer, bool Compact>
struct rbtree_node_traits_dispatch
   : public default_rbtree_node_traits_impl<VoidPointer>
{};

template<class VoidPointer>
struct rbtree_node_traits_dispatch<VoidPointer, true>
   : public compact_rbtree_node_traits_impl<VoidPointer>
{};


template<class VoidPointer, bool OptimizeSize = false>
struct rbtree_node_traits
   : public rbtree_node_traits_dispatch
         < VoidPointer
         , OptimizeSize &&
           (max_pointer_plus_bits
            < VoidPointer
            , detail::alignment_of<compact_rbtree_node<VoidPointer> >::value
            >::value >= 1)
         >
{};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/options.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/options.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 { 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; }; };
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; }; };
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/options.hpp" 3 4
template< bool Enabled> struct floating_point { 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; }; };
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/options.hpp" 3 4
template< typename Parent
        , typename MemberHook
        , MemberHook Parent::* PtrToMember>
struct member_hook
{
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 { template<class Base> struct pack : Base { static const link_mode_type link_mode = LinkType; }; };



template< bool Enabled> struct optimize_size { template<class Base> struct pack : Base { static const bool optimize_size = Enabled; }; };



template< bool Enabled> struct linear { template<class Base> struct pack : Base { static const bool linear = Enabled; }; };




template< bool Enabled> struct cache_last { 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 { template<class Base> struct pack : Base { static const bool store_hash = Enabled; }; };







template< bool Enabled> struct optimize_multikey { template<class Base> struct pack : Base { static const bool optimize_multikey = Enabled; }; };






template< bool Enabled> struct power_2_buckets { template<class Base> struct pack : Base { static const bool power_2_buckets = Enabled; }; };





template< bool Enabled> struct cache_begin { template<class Base> struct pack : Base { static const bool cache_begin = Enabled; }; };







template< bool Enabled> struct compare_hash { template<class Base> struct pack : Base { static const bool compare_hash = Enabled; }; };







template< bool Enabled> struct incremental { template<class Base> struct pack : Base { static const bool incremental = 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 255 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/options.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/generic_hook.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/generic_hook.hpp" 3 4
         






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/node_holder.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>
void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
{


   (void)hook; (static_cast<void> (0));
}

template<class Hook>
void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
{ hook.unlink(); }

template<class Hook>
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;

   node_ptr this_ptr()
   { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }

   const_node_ptr this_ptr() const
   { return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }

   public:


   generic_hook()
   {
      if(hooktags::safemode_or_autounlink){
         node_algorithms::init(this->this_ptr());
      }
   }

   generic_hook(const generic_hook& )
   {
      if(hooktags::safemode_or_autounlink){
         node_algorithms::init(this->this_ptr());
      }
   }

   generic_hook& operator=(const generic_hook& )
   { return *this; }

   ~generic_hook()
   {
      destructor_impl
         (*this, detail::link_dispatch<hooktags::link_mode>());
   }

   void swap_nodes(generic_hook &other)
   {
      node_algorithms::swap_nodes
         (this->this_ptr(), other.this_ptr());
   }

   bool is_linked() const
   {

      static_assert(( hooktags::safemode_or_autounlink ), "( hooktags::safemode_or_autounlink )");
      return !node_algorithms::unique(this->this_ptr());
   }

   void unlink()
   {
      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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 2 3 4


         


namespace boost {
namespace intrusive {






template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct make_set_base_hook
{

   typedef typename pack_options
      < hook_defaults,

      O1, O2, O3, O4



      >::type packed_options;

   typedef generic_hook
   < RbTreeAlgorithms
   , rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
   , typename packed_options::tag
   , packed_options::link_mode
   , RbTreeBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 3 4
template<class O1, class O2, class O3, class O4>

class set_base_hook
   : public make_set_base_hook<

      O1, O2, O3, O4



      >::type
{
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 3 4
};






template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct make_set_member_hook
{

   typedef typename pack_options
      < hook_defaults,

      O1, O2, O3, O4



      >::type packed_options;

   typedef generic_hook
   < RbTreeAlgorithms
   , rbtree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
   , member_tag
   , packed_options::link_mode
   , NoBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 212 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 3 4
template<class O1, class O2, class O3, class O4>

class set_member_hook
   : public make_set_member_hook<

      O1, O2, O3, O4



      >::type
{
# 289 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 3 4
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 295 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set_hook.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 3 4
         


namespace boost {
namespace intrusive {






template<class O1 = void, class O2 = void, class O3 = void>

struct make_bs_set_base_hook
{

   typedef typename pack_options

      < hook_defaults, O1, O2, O3>



   ::type packed_options;

   typedef generic_hook
   < BsTreeAlgorithms
   , tree_node_traits<typename packed_options::void_pointer>
   , typename packed_options::tag
   , packed_options::link_mode
   , BsTreeBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 3 4
template<class O1, class O2, class O3>

class bs_set_base_hook
   : public make_bs_set_base_hook

      <O1, O2, O3>



   ::type

{
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 3 4
};






template<class O1 = void, class O2 = void, class O3 = void>

struct make_bs_set_member_hook
{

   typedef typename pack_options

      < hook_defaults, O1, O2, O3>




   ::type packed_options;

   typedef generic_hook
   < BsTreeAlgorithms
   , tree_node_traits<typename packed_options::void_pointer>
   , member_tag
   , packed_options::link_mode
   , NoBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 3 4
template<class O1, class O2, class O3>

class bs_set_member_hook
   : public make_bs_set_member_hook

      <O1, O2, O3>



      ::type
{
# 281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 3 4
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 287 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bs_set_hook.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_iterator.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_iterator.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/iiterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/iiterator.hpp" 3 4
         






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 3 4
         
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/function_detector.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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))
      ;
};

}}}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 iiterator_members()
      : nodeptr_()
   {}

   inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
      : nodeptr_(n_ptr), ptr_(data)
   {}

   inline StoredPointer get_ptr() const
   { return ptr_; }

   NodePtr nodeptr_;
   StoredPointer ptr_;
};

template<class NodePtr, class StoredPointer>
struct iiterator_members<NodePtr, StoredPointer, false>
{
   inline iiterator_members()
      : nodeptr_()
   {}

   inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
      : nodeptr_(n_ptr)
   {}

   inline StoredPointer get_ptr() const
   { return StoredPointer(); }

   NodePtr nodeptr_;
};

}
}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_iterator.hpp" 2 3 4


namespace boost {
namespace intrusive {
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_iterator.hpp" 3 4
template<class ValueTraits, bool IsConst>
class tree_iterator
{
   private:
   typedef iiterator< ValueTraits, IsConst
                    , std::bidirectional_iterator_tag> types_t;
   typedef typename types_t::value_traits 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;
   typedef bstree_algorithms_base<node_traits> node_algorithms;

   static const bool stateful_value_traits = types_t::stateful_value_traits;

   void unspecified_bool_type_func() const {}
   typedef void (tree_iterator::*unspecified_bool_type)() const;

   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 tree_iterator()
   {}

   inline explicit tree_iterator(const node_ptr & nodeptr, const const_value_traits_ptr &traits_ptr)
      : members_(nodeptr, traits_ptr)
   {}

   inline tree_iterator(tree_iterator<value_traits, false> const& other)
      : members_(other.pointed_node(), other.get_value_traits())
   {}

   inline const node_ptr &pointed_node() const
   { return members_.nodeptr_; }

   inline tree_iterator &operator=(const node_ptr &nodeptr)
   { members_.nodeptr_ = nodeptr; return static_cast<tree_iterator&>(*this); }

   public:
   tree_iterator& operator++()
   {
      members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
      return static_cast<tree_iterator&> (*this);
   }

   tree_iterator operator++(int)
   {
      tree_iterator result (*this);
      members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
      return result;
   }

   tree_iterator& operator--()
   {
      members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
      return static_cast<tree_iterator&> (*this);
   }

   tree_iterator operator--(int)
   {
      tree_iterator result (*this);
      members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
      return result;
   }

   inline tree_iterator& go_left()
   {
      members_.nodeptr_ = node_traits::get_left(members_.nodeptr_);
      return static_cast<tree_iterator&> (*this);
   }

   inline tree_iterator& go_right()
   {
      members_.nodeptr_ = node_traits::get_right(members_.nodeptr_);
      return static_cast<tree_iterator&> (*this);
   }

   inline tree_iterator& go_parent()
   {
      members_.nodeptr_ = node_traits::get_parent(members_.nodeptr_);
      return static_cast<tree_iterator&> (*this);
   }

   inline operator unspecified_bool_type() const
   { return members_.nodeptr_ ? &tree_iterator::unspecified_bool_type_func : 0; }

   inline bool operator! () const
   { return !members_.nodeptr_; }

   inline friend bool operator== (const tree_iterator& l, const tree_iterator& r)
   { return l.pointed_node() == r.pointed_node(); }

   inline friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
   { return !(l == r); }

   inline reference operator*() const
   { return *operator->(); }

   inline pointer operator->() const
   { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }

   inline const_value_traits_ptr get_value_traits() const
   { return members_.get_ptr(); }

   tree_iterator end_iterator_from_it() const
   {
      return tree_iterator(node_algorithms::get_header(this->pointed_node()), this->get_value_traits());
   }

   tree_iterator<value_traits, false> unconst() const
   { return tree_iterator<value_traits, false>(this->pointed_node(), this->get_value_traits()); }

   private:
   inline pointer operator_arrow(detail::false_) const
   { return ValueTraits::to_value_ptr(members_.nodeptr_); }

   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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_iterator.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/empty_node_checker.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/empty_node_checker.hpp" 3 4
         


namespace boost {
namespace intrusive {
namespace detail {

template<class ValueTraits>
struct empty_node_checker
{
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::const_node_ptr const_node_ptr;

   struct return_type {};

   void operator () (const const_node_ptr&, const return_type&, const return_type&, return_type&) {}
};

}
}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/default_header_holder.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 const_node_ptr get_node() const
   { return pointer_traits< const_node_ptr >::pointer_to(*static_cast< const node* >(this)); }

   inline node_ptr get_node()
   { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); }


   inline static default_header_holder* get_holder(const 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;
};

}
}
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/exception_disposer.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 void release()
   { cont_ = 0; }

   ~exception_disposer()
   {
      if(cont_){
         cont_->clear_and_dispose(disp_);
      }
   }
};

template<class Container, class Disposer, class SizeType>
class exception_array_disposer
{
   Container *cont_;
   Disposer &disp_;
   SizeType &constructed_;

   exception_array_disposer(const exception_array_disposer&);
   exception_array_disposer &operator=(const exception_array_disposer&);

   public:

   exception_array_disposer
      (Container &cont, Disposer &disp, SizeType &constructed)
      : cont_(&cont), disp_(disp), constructed_(constructed)
   {}

   inline void release()
   { cont_ = 0; }

   ~exception_array_disposer()
   {
      SizeType n = constructed_;
      if(cont_){
         while(n--){
            cont_[n].clear_and_dispose(disp_);
         }
      }
   }
};

}
}
}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/node_cloner_disposer.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/node_cloner_disposer.hpp" 3 4
         
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)
   {}


   node_ptr operator()(const node_ptr & p)
   {
      reference_type v = *traits_->to_value_ptr(p);
      node_ptr n = traits_->to_node_ptr(*base_t::get()(v));

      (static_cast<void> (0));
      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;

   node_disposer(F f, const ValueTraits *cont)
      : base_t(f), traits_(cont)
   {}

   void operator()(const node_ptr & p)
   {
      if(safemode_or_autounlink)
         node_algorithms::init(p);
      base_t::get()(traits_->to_value_ptr(p));
   }
   const ValueTraits * const traits_;
};

}
}
}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/key_nodeptr_comp.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/key_nodeptr_comp.hpp" 3 4
         




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/tree_value_compare.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
        , 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 tree_value_compare()
      : base_t()
   {}

   inline explicit tree_value_compare(const key_compare &kcomp)
      : base_t(kcomp)
   {}

   inline tree_value_compare (const tree_value_compare &x)
      : base_t(x.base_t::get())
   {}

   inline tree_value_compare &operator=(const tree_value_compare &x)
   { this->base_t::get() = x.base_t::get(); return *this; }

   inline tree_value_compare &operator=(const key_compare &x)
   { this->base_t::get() = x; return *this; }

   inline const key_compare &key_comp() const
   { return static_cast<const key_compare &>(*this); }

   inline bool operator()(const key_type &key1, const key_type &key2) const
   { return this->key_comp()(key1, key2); }

   inline bool operator()(const value_type &value1, const value_type &value2) const
   { return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2)); }

   inline bool operator()(const key_type &key1, const value_type &value2) const
   { return this->key_comp()(key1, KeyOfValue()(value2)); }

   inline bool operator()(const value_type &value1, const key_type &key2) const
   { return this->key_comp()(KeyOfValue()(value1), key2); }

   template<class U>
   inline bool 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 bool 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 bool 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 bool 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>
struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, 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 tree_value_compare()
      : base_t()
   {}

   inline explicit tree_value_compare(const key_compare &kcomp)
      : base_t(kcomp)
   {}

   inline tree_value_compare (const tree_value_compare &x)
      : base_t(x.base_t::get())
   {}

   inline tree_value_compare &operator=(const tree_value_compare &x)
   { this->base_t::get() = x.base_t::get(); return *this; }

   inline tree_value_compare &operator=(const key_compare &x)
   { this->base_t::get() = x; return *this; }

   inline const key_compare &key_comp() const
   { return static_cast<const key_compare &>(*this); }

   inline bool operator()(const key_type &key1, const key_type &key2) const
   { return this->key_comp()(key1, key2); }

   template<class U>
   inline bool 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 bool 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
   };

   base_t base() const
   { return static_cast<const base_t&>(*this); }

   inline key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
      : base_t(kcomp), traits_(traits)
   {}


   template<class T1>
   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 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 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 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 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_;
};

}
}
}
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/simple_disposers.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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:
   void operator()(const node_ptr & p)
   { NodeAlgorithms::init(p); }
};

}
}
}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/size_holder.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 SizeType get_size() const
   { return size_; }

   inline void set_size(SizeType size)
   { size_ = size; }

   inline void decrement()
   { --size_; }

   inline void increment()
   { ++size_; }

   inline void increase(SizeType n)
   { size_ += n; }

   inline void decrease(SizeType n)
   { size_ -= n; }

   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 size_type get_size() const
   { return 0; }

   inline void set_size(size_type)
   {}

   inline void decrement()
   {}

   inline void increment()
   {}

   inline void increase(SizeType)
   {}

   inline void decrease(SizeType)
   {}

   inline void swap(size_holder){}
};

}
}
}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/get_value_traits.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/get_value_traits.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/get_value_traits.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/hook_traits.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/hook_traits.hpp" 3 4
         




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/parent_from_member.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/parent_from_member.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/parent_from_member.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/parent_from_member.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {

template<class Parent, class Member>
inline std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
{
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/parent_from_member.hpp" 3 4
}

template<class Parent, class Member>
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 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 120 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/parent_from_member.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 static pointer to_value_ptr(const node_ptr & n)
   {
      return pointer_traits<pointer>::pointer_to
         (static_cast<reference>(static_cast<node_holder_reference>(*n)));
   }

   inline static const_pointer to_value_ptr(const const_node_ptr & n)
   {
      return pointer_traits<const_pointer>::pointer_to
         (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
   }

   inline static node_ptr to_node_ptr(reference value)
   {
      return pointer_traits<node_ptr>::pointer_to
         (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
   }

   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_node_holder_reference>(value)));
   }
};

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 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 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 static pointer to_value_ptr(const 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 static const_pointer to_value_ptr(const 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(const node_ptr & n)
   { return Functor::to_value_ptr(to_hook_ptr(n)); }

   static const_pointer to_value_ptr(const const_node_ptr & n)
   { return Functor::to_value_ptr(to_hook_ptr(n)); }

   private:
   static hook_ptr to_hook_ptr(const node_ptr & n)
   { return hook_ptr(&*static_cast<hook_type*>(&*n)); }

   static const_hook_ptr to_hook_ptr(const const_node_ptr & n)
   { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); }
};


}
}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 _[2 + 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 _[2 + 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 221 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/get_value_traits.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/parent_from_member.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/parent_from_member.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/parent_from_member.hpp" 2 3 4






         


namespace boost {
namespace intrusive {





template<class Parent, class Member>
inline Parent *get_parent_from_member(Member *member, const Member Parent::* ptr_to_member)
{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); }





template<class Parent, class Member>
inline const Parent *get_parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); }

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/parent_from_member.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
         


namespace boost {
namespace intrusive {



struct default_bstree_hook_applier
{ template <class T> struct apply{ typedef typename T::default_bstree_hook type; }; };

template<>
struct is_default_hook_tag<default_bstree_hook_applier>
{ static const bool value = true; };

struct bstree_defaults
{
   typedef default_bstree_hook_applier proto_value_traits;
   static const bool constant_time_size = true;
   typedef std::size_t size_type;
   typedef void compare;
   typedef void key_of_value;
   static const bool floating_point = true;
   typedef void priority;
   typedef void header_holder_type;
};

template<class ValueTraits, algo_types AlgoType, typename HeaderHolder>
struct bstbase3
{
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::node node_type;
   typedef typename get_algo<AlgoType, node_traits>::type node_algorithms;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef tree_iterator<value_traits, false> iterator;
   typedef tree_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::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<const_pointer>::difference_type difference_type;
   typedef typename detail::get_header_holder_type
      < value_traits,HeaderHolder >::type header_holder_type;

   static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;
   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;

   struct holder_t : public ValueTraits
   {
      inline explicit holder_t(const ValueTraits &vtraits)
         : ValueTraits(vtraits)
      {}
      header_holder_type root;
   } holder;

   static bstbase3 &get_tree_base_from_end_iterator(const const_iterator &end_iterator)
   {
      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);
      holder_t *holder = get_parent_from_member<holder_t, header_holder_type>(h, &holder_t::root);
      bstbase3 *base = get_parent_from_member<bstbase3, holder_t> (holder, &bstbase3::holder);
      return *base;
   }

   inline bstbase3(const ValueTraits &vtraits)
      : holder(vtraits)
   {
      node_algorithms::init_header(this->header_ptr());
   }

   inline node_ptr header_ptr()
   { return holder.root.get_node(); }

   inline const_node_ptr header_ptr() const
   { return holder.root.get_node(); }

   inline const value_traits &get_value_traits() const
   { return this->holder; }

   inline value_traits &get_value_traits()
   { return this->holder; }

   typedef typename boost::intrusive::value_traits_pointers
      <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;

   inline const_value_traits_ptr priv_value_traits_ptr() const
   { return pointer_traits<const_value_traits_ptr>::pointer_to(this->get_value_traits()); }

   iterator begin()
   { return iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr()); }

   inline const_iterator begin() const
   { return cbegin(); }

   const_iterator cbegin() const
   { return const_iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr()); }

   iterator end()
   { return iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr()); }

   inline const_iterator end() const
   { return cend(); }

   inline const_iterator cend() const
   { return const_iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr()); }

   inline iterator root()
   { return iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr()); }

   inline const_iterator root() const
   { return croot(); }

   inline const_iterator croot() const
   { return const_iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr()); }

   inline reverse_iterator rbegin()
   { return reverse_iterator(end()); }

   inline const_reverse_iterator rbegin() const
   { return const_reverse_iterator(end()); }

   inline const_reverse_iterator crbegin() const
   { return const_reverse_iterator(end()); }

   inline reverse_iterator rend()
   { return reverse_iterator(begin()); }

   inline const_reverse_iterator rend() const
   { return const_reverse_iterator(begin()); }

   inline const_reverse_iterator crend() const
   { return const_reverse_iterator(begin()); }

   void replace_node(iterator replace_this, reference with_this)
   {
      node_algorithms::replace_node( get_value_traits().to_node_ptr(*replace_this)
                                   , this->header_ptr()
                                   , get_value_traits().to_node_ptr(with_this));
      if(safemode_or_autounlink)
         node_algorithms::init(replace_this.pointed_node());
   }

   inline void rebalance()
   { node_algorithms::rebalance(this->header_ptr()); }

   iterator rebalance_subtree(iterator root)
   { return iterator(node_algorithms::rebalance_subtree(root.pointed_node()), this->priv_value_traits_ptr()); }

   static iterator s_iterator_to(reference value)
   {
      static_assert((!stateful_value_traits), "(!stateful_value_traits)");
      return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr());
   }

   static const_iterator s_iterator_to(const_reference value)
   {
      static_assert((!stateful_value_traits), "(!stateful_value_traits)");
      return const_iterator (value_traits::to_node_ptr(*pointer_traits<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), const_value_traits_ptr());
   }

   iterator iterator_to(reference value)
   { return iterator (this->get_value_traits().to_node_ptr(value), this->priv_value_traits_ptr()); }

   const_iterator iterator_to(const_reference value) const
   { return const_iterator (this->get_value_traits().to_node_ptr(*pointer_traits<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), this->priv_value_traits_ptr()); }

   inline static void init_node(reference value)
   { node_algorithms::init(value_traits::to_node_ptr(value)); }

};

template<class Less, class T>
struct get_compare
{
   typedef Less type;
};

template<class T>
struct get_compare<void, T>
{
   typedef ::std::less<T> type;
};

template<class KeyOfValue, class T>
struct get_key_of_value
{
   typedef KeyOfValue type;
};

template<class T>
struct get_key_of_value<void, T>
{
   typedef ::boost::intrusive::detail::identity<T> type;
};

template<class ValuePtr, class VoidOrKeyOfValue, class VoidOrKeyComp>
struct bst_key_types
{
   typedef typename
      boost::movelib::pointer_element<ValuePtr>::type value_type;
   typedef typename get_key_of_value
      < VoidOrKeyOfValue, value_type>::type key_of_value;
   typedef typename key_of_value::type key_type;
   typedef typename get_compare< VoidOrKeyComp
                      , key_type
                      >::type key_compare;
   typedef tree_value_compare
      <ValuePtr, key_compare, key_of_value> value_compare;
};

template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, algo_types AlgoType, typename HeaderHolder>
struct bstbase2


   : public detail::ebo_functor_holder
            < typename bst_key_types
               < typename ValueTraits::pointer
               , VoidOrKeyOfValue
               , VoidOrKeyComp

               >::value_compare
            >
   , public bstbase3<ValueTraits, AlgoType, HeaderHolder>
{
   typedef bstbase3<ValueTraits, AlgoType, HeaderHolder> treeheader_t;
   typedef bst_key_types< typename ValueTraits::pointer
                        , VoidOrKeyOfValue
                        , VoidOrKeyComp> key_types;
   typedef typename treeheader_t::value_traits value_traits;
   typedef typename treeheader_t::node_algorithms node_algorithms;
   typedef typename ValueTraits::value_type value_type;
   typedef typename key_types::key_type key_type;
   typedef typename key_types::key_of_value key_of_value;
   typedef typename key_types::key_compare key_compare;
   typedef typename key_types::value_compare value_compare;
   typedef typename treeheader_t::iterator iterator;
   typedef typename treeheader_t::const_iterator const_iterator;
   typedef typename treeheader_t::node_ptr node_ptr;
   typedef typename treeheader_t::const_node_ptr const_node_ptr;

   bstbase2(const key_compare &comp, const ValueTraits &vtraits)
      : detail::ebo_functor_holder<value_compare>(value_compare(comp)), treeheader_t(vtraits)
   {}

   const value_compare &comp() const
   { return this->get(); }

   value_compare &comp()
   { return this->get(); }

   typedef typename value_traits::pointer pointer;
   typedef typename value_traits::const_pointer const_pointer;
   typedef typename pointer_traits<pointer>::reference reference;
   typedef typename pointer_traits<const_pointer>::reference const_reference;
   typedef typename pointer_traits<const_pointer>::difference_type difference_type;
   typedef typename node_algorithms::insert_commit_data insert_commit_data;

   inline value_compare value_comp() const
   { return this->comp(); }

   inline key_compare key_comp() const
   { return this->comp().key_comp(); }


   inline iterator lower_bound(const key_type &key)
   { return this->lower_bound(key, this->key_comp()); }

   inline const_iterator lower_bound(const key_type &key) const
   { return this->lower_bound(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   iterator lower_bound(const KeyType &key, KeyTypeKeyCompare comp)
   {
      return iterator(node_algorithms::lower_bound
         (this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
   }

   template<class KeyType, class KeyTypeKeyCompare>
   const_iterator lower_bound(const KeyType &key, KeyTypeKeyCompare comp) const
   {
      return const_iterator(node_algorithms::lower_bound
         (this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
   }


   inline iterator upper_bound(const key_type &key)
   { return this->upper_bound(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   iterator upper_bound(const KeyType &key, KeyTypeKeyCompare comp)
   {
      return iterator(node_algorithms::upper_bound
         (this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
   }

   inline const_iterator upper_bound(const key_type &key) const
   { return this->upper_bound(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   const_iterator upper_bound(const KeyType &key, KeyTypeKeyCompare comp) const
   {
      return const_iterator(node_algorithms::upper_bound
         (this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
   }

   template<class KeyTypeKeyCompare>
   struct key_node_comp_ret
   { typedef detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value> type; };

   template<class KeyTypeKeyCompare>
   inline typename key_node_comp_ret<KeyTypeKeyCompare>::type key_node_comp(KeyTypeKeyCompare comp) const
   {
      return detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value>(comp, &this->get_value_traits());
   }


   inline iterator find(const key_type &key)
   { return this->find(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   iterator find(const KeyType &key, KeyTypeKeyCompare comp)
   {
      return iterator
         (node_algorithms::find(this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
   }

   inline const_iterator find(const key_type &key) const
   { return this->find(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   const_iterator find(const KeyType &key, KeyTypeKeyCompare comp) const
   {
      return const_iterator
         (node_algorithms::find(this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
   }


   inline std::pair<iterator,iterator> equal_range(const key_type &key)
   { return this->equal_range(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator,iterator> equal_range(const KeyType &key, KeyTypeKeyCompare comp)
   {
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::equal_range(this->header_ptr(), key, this->key_node_comp(comp)));
      return std::pair<iterator, iterator>( iterator(ret.first, this->priv_value_traits_ptr())
                                          , iterator(ret.second, this->priv_value_traits_ptr()));
   }

   inline std::pair<const_iterator, const_iterator>
      equal_range(const key_type &key) const
   { return this->equal_range(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<const_iterator, const_iterator>
      equal_range(const KeyType &key, KeyTypeKeyCompare comp) const
   {
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::equal_range(this->header_ptr(), key, this->key_node_comp(comp)));
      return std::pair<const_iterator, const_iterator>( const_iterator(ret.first, this->priv_value_traits_ptr())
                                                      , const_iterator(ret.second, this->priv_value_traits_ptr()));
   }


   inline std::pair<iterator,iterator> lower_bound_range(const key_type &key)
   { return this->lower_bound_range(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator,iterator> lower_bound_range(const KeyType &key, KeyTypeKeyCompare comp)
   {
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::lower_bound_range(this->header_ptr(), key, this->key_node_comp(comp)));
      return std::pair<iterator, iterator>( iterator(ret.first, this->priv_value_traits_ptr())
                                          , iterator(ret.second, this->priv_value_traits_ptr()));
   }

   inline std::pair<const_iterator, const_iterator>
      lower_bound_range(const key_type &key) const
   { return this->lower_bound_range(key, this->key_comp()); }

   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<const_iterator, const_iterator>
      lower_bound_range(const KeyType &key, KeyTypeKeyCompare comp) const
   {
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::lower_bound_range(this->header_ptr(), key, this->key_node_comp(comp)));
      return std::pair<const_iterator, const_iterator>( const_iterator(ret.first, this->priv_value_traits_ptr())
                                                      , const_iterator(ret.second, this->priv_value_traits_ptr()));
   }


   inline std::pair<iterator,iterator> bounded_range
      (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed)
   { return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); }

   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator,iterator> bounded_range
      (const KeyType &lower_key, const KeyType &upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed)
   {
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::bounded_range
            (this->header_ptr(), lower_key, upper_key, this->key_node_comp(comp), left_closed, right_closed));
      return std::pair<iterator, iterator>( iterator(ret.first, this->priv_value_traits_ptr())
                                          , iterator(ret.second, this->priv_value_traits_ptr()));
   }

   inline std::pair<const_iterator,const_iterator> bounded_range
      (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const
   { return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed); }

   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<const_iterator,const_iterator> bounded_range
      (const KeyType &lower_key, const KeyType &upper_key, KeyTypeKeyCompare comp, bool left_closed, bool right_closed) const
   {
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::bounded_range
            (this->header_ptr(), lower_key, upper_key, this->key_node_comp(comp), left_closed, right_closed));
      return std::pair<const_iterator, const_iterator>( const_iterator(ret.first, this->priv_value_traits_ptr())
                                                      , const_iterator(ret.second, this->priv_value_traits_ptr()));
   }


   inline std::pair<iterator, bool> insert_unique_check
      (const key_type &key, insert_commit_data &commit_data)
   { return this->insert_unique_check(key, this->key_comp(), commit_data); }

   inline std::pair<iterator, bool> insert_unique_check
      (const_iterator hint, const key_type &key, insert_commit_data &commit_data)
   { return this->insert_unique_check(hint, key, this->key_comp(), commit_data); }

   template<class KeyType, class KeyTypeKeyCompare>
   typename detail::disable_if_convertible <KeyType , const_iterator , std::pair<iterator , bool> >::type



      insert_unique_check
      (const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
   {
      std::pair<node_ptr, bool> ret =
         (node_algorithms::insert_unique_check
            (this->header_ptr(), key, this->key_node_comp(comp), commit_data));
      return std::pair<iterator, bool>(iterator(ret.first, this->priv_value_traits_ptr()), ret.second);
   }

   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator, bool> insert_unique_check
      (const_iterator hint, const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
   {
      std::pair<node_ptr, bool> ret =
         (node_algorithms::insert_unique_check
            (this->header_ptr(), hint.pointed_node(), key, this->key_node_comp(comp), commit_data));
      return std::pair<iterator, bool>(iterator(ret.first, this->priv_value_traits_ptr()), ret.second);
   }
};




template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, bool ConstantTimeSize, class SizeType, algo_types AlgoType, typename HeaderHolder>
struct bstbase_hack
   : public detail::size_holder<ConstantTimeSize, SizeType>
   , public bstbase2 < ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder>
{
   typedef bstbase2< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder> base_type;
   typedef typename base_type::key_compare key_compare;
   typedef typename base_type::value_compare value_compare;
   typedef SizeType size_type;
   typedef typename base_type::node_traits node_traits;
   typedef typename get_algo
      <AlgoType, node_traits>::type algo_type;

   inline bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
      : base_type(comp, vtraits)
   {
      this->sz_traits().set_size(size_type(0));
   }

   typedef detail::size_holder<ConstantTimeSize, SizeType> size_traits;

   inline size_traits &sz_traits()
   { return static_cast<size_traits &>(*this); }

   inline const size_traits &sz_traits() const
   { return static_cast<const size_traits &>(*this); }
};


template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, algo_types AlgoType, typename HeaderHolder>
struct bstbase_hack<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, false, SizeType, AlgoType, HeaderHolder>
   : public bstbase2 < ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder>
{
   typedef bstbase2< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder> base_type;
   typedef typename base_type::value_compare value_compare;
   typedef typename base_type::key_compare key_compare;
   inline bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
      : base_type(comp, vtraits)
   {}

   typedef detail::size_holder<false, SizeType> size_traits;

   inline size_traits sz_traits() const
   { return size_traits(); }
};


template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, bool ConstantTimeSize, class SizeType, algo_types AlgoType, typename HeaderHolder>
struct bstbase
   : public bstbase_hack< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, ConstantTimeSize, SizeType, AlgoType, HeaderHolder>
{
   typedef bstbase_hack< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, ConstantTimeSize, SizeType, AlgoType, HeaderHolder> base_type;
   typedef ValueTraits value_traits;
   typedef typename base_type::value_compare value_compare;
   typedef typename base_type::key_compare key_compare;
   typedef typename base_type::const_reference const_reference;
   typedef typename base_type::reference reference;
   typedef typename base_type::iterator iterator;
   typedef typename base_type::const_iterator const_iterator;
   typedef typename base_type::node_traits node_traits;
   typedef typename get_algo
      <AlgoType, node_traits>::type node_algorithms;
   typedef SizeType size_type;

   inline bstbase(const key_compare & comp, const ValueTraits &vtraits)
      : base_type(comp, vtraits)
   {}



   ~bstbase()
   {
      if(is_safe_autounlink<value_traits::link_mode>::value){
         node_algorithms::clear_and_dispose
            ( this->header_ptr()
            , detail::node_disposer<detail::null_disposer, value_traits, AlgoType>
               (detail::null_disposer(), &this->get_value_traits()));
         node_algorithms::init(this->header_ptr());
      }
   }
};
# 621 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, algo_types AlgoType, typename HeaderHolder>

class bstree_impl
   : public bstbase<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, ConstantTimeSize, SizeType, AlgoType, HeaderHolder>
{
   public:

   typedef bstbase<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, ConstantTimeSize, SizeType, AlgoType, HeaderHolder> data_type;
   typedef tree_iterator<ValueTraits, false> iterator_type;
   typedef tree_iterator<ValueTraits, true> const_iterator_type;


   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 data_type::key_type key_type;
   typedef typename data_type::key_of_value key_of_value;
   typedef typename pointer_traits<pointer>::reference reference;
   typedef typename pointer_traits<const_pointer>::reference const_reference;
   typedef typename pointer_traits<const_pointer>::difference_type difference_type;
   typedef SizeType size_type;
   typedef typename data_type::value_compare value_compare;
   typedef typename data_type::key_compare key_compare;
   typedef iterator_type iterator;
   typedef const_iterator_type 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 typename get_algo<AlgoType, node_traits>::type algo_type;

   typedef algo_type node_algorithms;

   static const bool constant_time_size = ConstantTimeSize;
   static const bool stateful_value_traits = detail::is_stateful_value_traits<value_traits>::value;

   private:


   public: bstree_impl(bstree_impl const &) = delete; bstree_impl& operator=(bstree_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))");


   protected:




   public:

   typedef typename node_algorithms::insert_commit_data insert_commit_data;
# 688 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   bstree_impl()
      : data_type(key_compare(), value_traits())
   {}
# 699 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   explicit bstree_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : data_type(cmp, v_traits)
   {}
# 715 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Iterator>
   bstree_impl( bool unique, Iterator b, Iterator e
              , const key_compare &cmp = key_compare()
              , const value_traits &v_traits = value_traits())
      : data_type(cmp, v_traits)
   {

      if(unique)
         this->insert_unique(b, e);
      else
         this->insert_equal(b, e);
   }
# 737 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   bstree_impl(bstree_impl && x)
      : data_type(::boost::move(x.comp()), ::boost::move(x.get_value_traits()))
   {
      this->swap(x);
   }



   inline bstree_impl& operator=(bstree_impl && x)
   { this->swap(x); return *this; }
# 880 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   static bstree_impl &container_from_end_iterator(iterator end_iterator)
   {
      return static_cast<bstree_impl&>
               (data_type::get_tree_base_from_end_iterator(end_iterator));
   }
# 894 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   static const bstree_impl &container_from_end_iterator(const_iterator end_iterator)
   {
      return static_cast<bstree_impl&>
               (data_type::get_tree_base_from_end_iterator(end_iterator));
   }
# 908 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   static bstree_impl &container_from_iterator(iterator it)
   { return container_from_end_iterator(it.end_iterator_from_it()); }
# 919 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   static const bstree_impl &container_from_iterator(const_iterator it)
   { return container_from_end_iterator(it.end_iterator_from_it()); }
# 945 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   bool empty() const
   {
      if(ConstantTimeSize){
         return !this->data_type::sz_traits().get_size();
      }
      else{
         return algo_type::unique(this->header_ptr());
      }
   }







   size_type size() const
   {
      if(constant_time_size)
         return this->sz_traits().get_size();
      else{
         return (size_type)node_algorithms::size(this->header_ptr());
      }
   }






   void swap(bstree_impl& other)
   {

      ::boost::adl_move_swap(this->comp(), other.comp());

      node_algorithms::swap_tree(this->header_ptr(), node_ptr(other.header_ptr()));
      this->sz_traits().swap(other.sz_traits());
   }
# 998 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template <class Cloner, class Disposer>
   void clone_from(const bstree_impl &src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      if(!src.empty()){
         detail::exception_disposer<bstree_impl, Disposer>
            rollback(*this, disposer);
         node_algorithms::clone
            (src.header_ptr()
            ,this->header_ptr()
            ,detail::node_cloner <Cloner, value_traits, AlgoType>(cloner, &this->get_value_traits())
            ,detail::node_disposer<Disposer, value_traits, AlgoType>(disposer, &this->get_value_traits()));
         this->sz_traits().set_size(src.sz_traits().get_size());
         this->comp() = src.comp();
         rollback.release();
      }
   }
# 1033 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template <class Cloner, class Disposer>
   void clone_from(bstree_impl && src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      if(!src.empty()){
         detail::exception_disposer<bstree_impl, Disposer>
            rollback(*this, disposer);
         node_algorithms::clone
            (src.header_ptr()
            ,this->header_ptr()
            ,detail::node_cloner <Cloner, value_traits, AlgoType, false>(cloner, &this->get_value_traits())
            ,detail::node_disposer<Disposer, value_traits, AlgoType>(disposer, &this->get_value_traits()));
         this->sz_traits().set_size(src.sz_traits().get_size());
         this->comp() = src.comp();
         rollback.release();
      }
   }
# 1062 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   iterator insert_equal(reference value)
   {
      node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         (static_cast<void> (0));
      iterator ret(node_algorithms::insert_equal_upper_bound
         (this->header_ptr(), to_insert, this->key_node_comp(this->key_comp())), this->priv_value_traits_ptr());
      this->sz_traits().increment();
      return ret;
   }
# 1087 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   iterator insert_equal(const_iterator hint, reference value)
   {
      node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         (static_cast<void> (0));
      iterator ret(node_algorithms::insert_equal
         (this->header_ptr(), hint.pointed_node(), to_insert, this->key_node_comp(this->key_comp())), this->priv_value_traits_ptr());
      this->sz_traits().increment();
      return ret;
   }
# 1112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Iterator>
   void insert_equal(Iterator b, Iterator e)
   {
      iterator iend(this->end());
      for (; b != e; ++b)
         this->insert_equal(iend, *b);
   }
# 1132 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   std::pair<iterator, bool> insert_unique(reference value)
   {
      insert_commit_data commit_data;
      std::pair<node_ptr, bool> ret =
         (node_algorithms::insert_unique_check
            (this->header_ptr(), key_of_value()(value), this->key_node_comp(this->key_comp()), commit_data));
      return std::pair<iterator, bool>
         ( ret.second ? this->insert_unique_commit(value, commit_data)
                      : iterator(ret.first, this->priv_value_traits_ptr())
         , ret.second);
   }
# 1158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   iterator insert_unique(const_iterator hint, reference value)
   {
      insert_commit_data commit_data;
      std::pair<node_ptr, bool> ret =
         (node_algorithms::insert_unique_check
            (this->header_ptr(), hint.pointed_node(), key_of_value()(value), this->key_node_comp(this->key_comp()), commit_data));
      return ret.second ? this->insert_unique_commit(value, commit_data)
                        : iterator(ret.first, this->priv_value_traits_ptr());
   }
# 1181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Iterator>
   void insert_unique(Iterator b, Iterator e)
   {
      if(this->empty()){
         iterator iend(this->end());
         for (; b != e; ++b)
            this->insert_unique(iend, *b);
      }
      else{
         for (; b != e; ++b)
            this->insert_unique(*b);
      }
   }
# 1317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
   {
      node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         (static_cast<void> (0));



      iterator p(commit_data.node, this->priv_value_traits_ptr());
      if(!commit_data.link_left){
         ++p;
      }


      (static_cast<void> (0));
      (static_cast<void> (0));


      node_algorithms::insert_unique_commit
               (this->header_ptr(), to_insert, commit_data);
      this->sz_traits().increment();
      return iterator(to_insert, this->priv_value_traits_ptr());
   }
# 1355 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   iterator insert_before(const_iterator pos, reference value)
   {
      node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         (static_cast<void> (0));
      this->sz_traits().increment();
      return iterator(node_algorithms::insert_before
         (this->header_ptr(), pos.pointed_node(), to_insert), this->priv_value_traits_ptr());
   }
# 1379 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   void push_back(reference value)
   {
      node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         (static_cast<void> (0));
      this->sz_traits().increment();
      node_algorithms::push_back(this->header_ptr(), to_insert);
   }
# 1402 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   void push_front(reference value)
   {
      node_ptr to_insert(this->get_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         (static_cast<void> (0));
      this->sz_traits().increment();
      node_algorithms::push_front(this->header_ptr(), to_insert);
   }
# 1419 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   iterator erase(const_iterator i)
   {
      const_iterator ret(i);
      ++ret;
      node_ptr to_erase(i.pointed_node());
      if(safemode_or_autounlink)
         (static_cast<void> (0));
      node_algorithms::erase(this->header_ptr(), to_erase);
      this->sz_traits().decrement();
      if(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      return ret.unconst();
   }
# 1442 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   iterator erase(const_iterator b, const_iterator e)
   { size_type n; return this->private_erase(b, e, n); }
# 1455 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   size_type erase(const key_type &key)
   { return this->erase(key, this->key_comp()); }
# 1473 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class KeyType, class KeyTypeKeyCompare>
   typename detail::disable_if_convertible<KeyTypeKeyCompare , const_iterator , size_type>::type

      erase(const KeyType& key, KeyTypeKeyCompare comp)
   {
      std::pair<iterator,iterator> p = this->equal_range(key, comp);
      size_type n;
      this->private_erase(p.first, p.second, n);
      return n;
   }
# 1495 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer)
   {
      node_ptr to_erase(i.pointed_node());
      iterator ret(this->erase(i));
      disposer(this->get_value_traits().to_value_ptr(to_erase));
      return ret;
   }
# 1517 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Disposer>
   size_type erase_and_dispose(const key_type &key, Disposer disposer)
   {
      std::pair<iterator,iterator> p = this->equal_range(key);
      size_type n;
      this->private_erase(p.first, p.second, n, disposer);
      return n;
   }
# 1538 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Disposer>
   iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
   { size_type n; return this->private_erase(b, e, n, disposer); }
# 1560 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class KeyType, class KeyTypeKeyCompare, class Disposer>
   typename detail::disable_if_convertible<KeyTypeKeyCompare , const_iterator , size_type>::type

      erase_and_dispose(const KeyType& key, KeyTypeKeyCompare comp, Disposer disposer)
   {
      std::pair<iterator,iterator> p = this->equal_range(key, comp);
      size_type n;
      this->private_erase(p.first, p.second, n, disposer);
      return n;
   }
# 1580 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   void clear()
   {
      if(safemode_or_autounlink){
         this->clear_and_dispose(detail::null_disposer());
      }
      else{
         node_algorithms::init_header(this->header_ptr());
         this->sz_traits().set_size(0);
      }
   }
# 1600 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Disposer>
   void clear_and_dispose(Disposer disposer)
   {
      node_algorithms::clear_and_dispose(this->header_ptr()
         , detail::node_disposer<Disposer, value_traits, AlgoType>(disposer, &this->get_value_traits()));
      node_algorithms::init_header(this->header_ptr());
      this->sz_traits().set_size(0);
   }







   size_type count(const key_type &key) const
   { return size_type(this->count(key, this->key_comp())); }
# 1628 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class KeyType, class KeyTypeKeyCompare>
   size_type count(const KeyType &key, KeyTypeKeyCompare comp) const
   {
      std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp);
      size_type n = 0;
      for(; ret.first != ret.second; ++ret.first){ ++n; }
      return n;
   }





   size_type count(const key_type &key)
   { return size_type(this->count(key, this->key_comp())); }

   template<class KeyType, class KeyTypeKeyCompare>
   size_type count(const KeyType &key, KeyTypeKeyCompare comp)
   {
      std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp);
      size_type n = 0;
      for(; ret.first != ret.second; ++ret.first){ ++n; }
      return n;
   }
# 1907 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   pointer unlink_leftmost_without_rebalance()
   {
      node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
                           (this->header_ptr()));
      if(!to_be_disposed)
         return 0;
      this->sz_traits().decrement();
      if(safemode_or_autounlink)
         node_algorithms::init(to_be_disposed);
      return this->get_value_traits().to_value_ptr(to_be_disposed);
   }
# 1969 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   static void remove_node(reference value)
   {
      static_assert((!constant_time_size), "(!constant_time_size)");
      node_ptr to_remove(value_traits::to_node_ptr(value));
      node_algorithms::unlink(to_remove);
      if(safemode_or_autounlink)
         node_algorithms::init(to_remove);
   }
# 1996 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Compare2>
   void merge_unique(bstree_impl
      <ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, AlgoType, HeaderHolder> &source)

   {
      node_ptr it (node_algorithms::begin_node(source.header_ptr()))
             , itend(node_algorithms::end_node (source.header_ptr()));

      while(it != itend){
         node_ptr const p(it);
         (static_cast<void> (0));
         it = node_algorithms::next_node(it);
         if( node_algorithms::transfer_unique(this->header_ptr(), this->key_node_comp(this->key_comp()), source.header_ptr(), p) ){
            source.sz_traits().decrement();
            this->sz_traits().increment();
         }
      }
   }
# 2032 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 3 4
   template<class Compare2>
   void merge_equal(bstree_impl
      <ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, AlgoType, HeaderHolder> &source)

   {
      node_ptr it (node_algorithms::begin_node(source.header_ptr()))
             , itend(node_algorithms::end_node (source.header_ptr()));

      while(it != itend){
         node_ptr const p(it);
         (static_cast<void> (0));
         it = node_algorithms::next_node(it);
         node_algorithms::transfer_equal(this->header_ptr(), this->key_node_comp(this->key_comp()), source.header_ptr(), p);
         source.sz_traits().decrement();
         this->sz_traits().increment();
      }
   }







   template <class ExtraChecker>
   void check(ExtraChecker extra_checker) const
   {
      typedef detail::key_nodeptr_comp<key_compare, value_traits, key_of_value> nodeptr_comp_t;
      nodeptr_comp_t nodeptr_comp(this->key_comp(), &this->get_value_traits());
      typedef typename get_node_checker<AlgoType, ValueTraits, nodeptr_comp_t, ExtraChecker>::type node_checker_t;
      typename node_checker_t::return_type checker_return;
      node_algorithms::check(this->header_ptr(), node_checker_t(nodeptr_comp, extra_checker), checker_return);
      if (constant_time_size)
         (static_cast<void> (0));
   }







   void check() const
   {
      check(detail::empty_node_checker<ValueTraits>());
   }

   friend bool operator==(const bstree_impl &x, const bstree_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 bstree_impl &x, const bstree_impl &y)
   { return !(x == y); }

   friend bool operator<(const bstree_impl &x, const bstree_impl &y)
   { return ::boost::intrusive::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }

   friend bool operator>(const bstree_impl &x, const bstree_impl &y)
   { return y < x; }

   friend bool operator<=(const bstree_impl &x, const bstree_impl &y)
   { return !(x > y); }

   friend bool operator>=(const bstree_impl &x, const bstree_impl &y)
   { return !(x < y); }

   friend void swap(bstree_impl &x, bstree_impl &y)
   { x.swap(y); }


   private:
   template<class Disposer>
   iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer)
   {
      for(n = 0; b != e; ++n)
        this->erase_and_dispose(b++, disposer);
      return b.unconst();
   }

   iterator private_erase(const_iterator b, const_iterator e, size_type &n)
   {
      for(n = 0; b != e; ++n)
        this->erase(b++);
      return b.unconst();
   }

};






template<class T, class O1 = void, class O2 = void
                , class O3 = void, class O4 = void
                , class O5 = void, class O6 = void>

struct make_bstree
{

   typedef typename pack_options
      < bstree_defaults,

      O1, O2, O3, O4, O5, O6



      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;

   typedef bstree_impl
         < value_traits
         , typename packed_options::key_of_value
         , typename packed_options::compare
         , typename packed_options::size_type
         , packed_options::constant_time_size
         , BsTreeAlgorithms
         , typename packed_options::header_holder_type
         > implementation_defined;

   typedef implementation_defined type;
};





template<class T, class O1, class O2, class O3, class O4, class O5, class O6>



class bstree
   : public make_bstree<T,

      O1, O2, O3, O4, O5, O6



      >::type
{
   typedef typename make_bstree
      <T,

      O1, O2, O3, O4, O5, O6



      >::type Base;
   public: bstree(bstree const &) = delete; bstree& operator=(bstree 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::key_compare key_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   static_assert((detail::is_same<typename value_traits::value_type, T>::value), "(detail::is_same<typename value_traits::value_type, T>::value)");

   bstree()
      : Base()
   {}

   explicit bstree( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   bstree( bool unique, Iterator b, Iterator e
         , const key_compare &cmp = key_compare()
         , const value_traits &v_traits = value_traits())
      : Base(unique, b, e, cmp, v_traits)
   {}

   bstree(bstree && x)
      : Base(::boost::move((Base&)(x)))
   {}

   bstree& operator=(bstree && x)
   { return static_cast<bstree &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   void clone_from(const bstree &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   void clone_from(bstree && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   static bstree &container_from_end_iterator(iterator end_iterator)
   { return static_cast<bstree &>(Base::container_from_end_iterator(end_iterator)); }

   static const bstree &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const bstree &>(Base::container_from_end_iterator(end_iterator)); }

   static bstree &container_from_iterator(iterator it)
   { return static_cast<bstree &>(Base::container_from_iterator(it)); }

   static const bstree &container_from_iterator(const_iterator it)
   { return static_cast<const bstree &>(Base::container_from_iterator(it)); }
};


}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 2245 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/bstree.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 3 4
         


namespace boost {
namespace intrusive {



struct default_rbtree_hook_applier
{ template <class T> struct apply{ typedef typename T::default_rbtree_hook type; }; };

template<>
struct is_default_hook_tag<default_rbtree_hook_applier>
{ static const bool value = true; };

struct rbtree_defaults
   : bstree_defaults
{
   typedef default_rbtree_hook_applier proto_value_traits;
};
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 3 4
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>

class rbtree_impl

   : public bstree_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>

{
   public:
   typedef ValueTraits value_traits;

   typedef bstree_impl< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType
                      , ConstantTimeSize, RbTreeAlgorithms
                      , HeaderHolder> tree_type;
   typedef tree_type implementation_defined;


   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::key_type key_type;
   typedef typename implementation_defined::key_of_value key_of_value;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = implementation_defined::constant_time_size;

   private:


   public: rbtree_impl(rbtree_impl const &) = delete; rbtree_impl& operator=(rbtree_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:



   public:

   typedef typename implementation_defined::insert_commit_data insert_commit_data;


   rbtree_impl()
      : tree_type()
   {}


   explicit rbtree_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : tree_type(cmp, v_traits)
   {}


   template<class Iterator>
   rbtree_impl( bool unique, Iterator b, Iterator e
              , const key_compare &cmp = key_compare()
              , const value_traits &v_traits = value_traits())
      : tree_type(unique, b, e, cmp, v_traits)
   {}


   rbtree_impl(rbtree_impl && x)
      : tree_type(::boost::move((tree_type&)(x)))
   {}


   rbtree_impl& operator=(rbtree_impl && x)
   { return static_cast<rbtree_impl&>(tree_type::operator=(::boost::move((tree_type&)(x)))); }
# 233 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 3 4
   using tree_type::clone_from;




   template <class Cloner, class Disposer>
   void clone_from(rbtree_impl && src, Cloner cloner, Disposer disposer)
   { tree_type::clone_from(::boost::move((tree_type&)(src)), cloner, disposer); }
# 464 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 3 4
};







template<class T, class O1 = void, class O2 = void
                , class O3 = void, class O4 = void
                , class O5 = void, class O6 = void>

struct make_rbtree
{

   typedef typename pack_options
      < rbtree_defaults,

      O1, O2, O3, O4, O5, O6



      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;

   typedef rbtree_impl
         < value_traits
         , typename packed_options::key_of_value
         , typename packed_options::compare
         , 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 O1, class O2, class O3, class O4, class O5, class O6>



class rbtree
   : public make_rbtree<T,

      O1, O2, O3, O4, O5, O6



      >::type
{
   typedef typename make_rbtree
      <T,

      O1, O2, O3, O4, O5, O6



      >::type Base;
   public: rbtree(rbtree const &) = delete; rbtree& operator=(rbtree 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::key_compare key_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;
   typedef typename Base::reverse_iterator reverse_iterator;
   typedef typename Base::const_reverse_iterator const_reverse_iterator;


   static_assert((detail::is_same<typename value_traits::value_type, T>::value), "(detail::is_same<typename value_traits::value_type, T>::value)");

   rbtree()
      : Base()
   {}

   explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   rbtree( bool unique, Iterator b, Iterator e
         , const key_compare &cmp = key_compare()
         , const value_traits &v_traits = value_traits())
      : Base(unique, b, e, cmp, v_traits)
   {}

   rbtree(rbtree && x)
      : Base(::boost::move((Base&)(x)))
   {}

   rbtree& operator=(rbtree && x)
   { return static_cast<rbtree &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   void clone_from(const rbtree &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   void clone_from(rbtree && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   static rbtree &container_from_end_iterator(iterator end_iterator)
   { return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); }

   static const rbtree &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator)); }

   static rbtree &container_from_iterator(iterator it)
   { return static_cast<rbtree &>(Base::container_from_iterator(it)); }

   static const rbtree &container_from_iterator(const_iterator it)
   { return static_cast<const rbtree &>(Base::container_from_iterator(it)); }
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 590 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/rbtree.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 2 3 4




         


namespace boost {
namespace intrusive {


template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
class multiset_impl;
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>

class set_impl

   : public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>

{

   typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder> tree_type;
   public: set_impl(set_impl const &) = delete; set_impl& operator=(set_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   typedef tree_type implementation_defined;


   public:
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::key_type key_type;
   typedef typename implementation_defined::key_of_value key_of_value;
   typedef typename implementation_defined::value_traits value_traits;
   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::insert_commit_data insert_commit_data;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = tree_type::constant_time_size;

   public:

   set_impl()
      : tree_type()
   {}


   explicit set_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : tree_type(cmp, v_traits)
   {}


   template<class Iterator>
   set_impl( Iterator b, Iterator e
           , const key_compare &cmp = key_compare()
           , const value_traits &v_traits = value_traits())
      : tree_type(true, b, e, cmp, v_traits)
   {}


   set_impl(set_impl && x)
      : tree_type(::boost::move((tree_type&)(x)))
   {}


   set_impl& operator=(set_impl && x)
   { return static_cast<set_impl&>(tree_type::operator=(::boost::move((tree_type&)(x)))); }
# 200 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
   using tree_type::clone_from;




   template <class Cloner, class Disposer>
   void clone_from(set_impl && src, Cloner cloner, Disposer disposer)
   { tree_type::clone_from(::boost::move((tree_type&)(src)), cloner, disposer); }


   std::pair<iterator, bool> insert(reference value)
   { return tree_type::insert_unique(value); }


   iterator insert(const_iterator hint, reference value)
   { return tree_type::insert_unique(hint, value); }


   std::pair<iterator, bool> insert_check
      (const key_type &key, insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(key, commit_data); }


   std::pair<iterator, bool> insert_check
      (const_iterator hint, const key_type &key
      ,insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(hint, key, commit_data); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator, bool> insert_check
      (const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(key, comp, commit_data); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator, bool> insert_check
      (const_iterator hint, const KeyType &key
      ,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(hint, key, comp, commit_data); }


   template<class Iterator>
   void insert(Iterator b, Iterator e)
   { tree_type::insert_unique(b, e); }


   iterator insert_commit(reference value, const insert_commit_data &commit_data)
   { return tree_type::insert_unique_commit(value, commit_data); }
# 299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
   size_type count(const key_type &key) const
   { return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }


   template<class KeyType, class KeyTypeKeyCompare>
   size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
   { return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
# 354 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
   std::pair<iterator,iterator> equal_range(const key_type &key)
   { return this->tree_type::lower_bound_range(key); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
   { return this->tree_type::equal_range(key, comp); }


   std::pair<const_iterator, const_iterator>
      equal_range(const key_type &key) const
   { return this->tree_type::lower_bound_range(key); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<const_iterator, const_iterator>
      equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
   { return this->tree_type::equal_range(key, comp); }
# 427 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
   template<class Compare2>
   void merge(set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_unique(source); }


   template<class Compare2>
   void merge(multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_unique(source); }


};
# 463 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
template<class T, class O1 = void, class O2 = void
                , class O3 = void, class O4 = void
                , class O5 = void, class O6 = void>

struct make_set
{

   typedef typename pack_options
      < rbtree_defaults,

      O1, O2, O3, O4, O5, O6



      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;

   typedef set_impl
         < value_traits
         , typename packed_options::key_of_value
         , typename packed_options::compare
         , 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 O1, class O2, class O3, class O4, class O5, class O6>



class set
   : public make_set<T,

   O1, O2, O3, O4, O5, O6



   >::type
{
   typedef typename make_set
      <T,

      O1, O2, O3, O4, O5, O6



      >::type Base;

   public: set(set const &) = delete; set& operator=(set 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::key_compare key_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   static_assert((detail::is_same<typename value_traits::value_type, T>::value), "(detail::is_same<typename value_traits::value_type, T>::value)");

   set()
      : Base()
   {}

   explicit set( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   set( Iterator b, Iterator e
      , const key_compare &cmp = key_compare()
      , const value_traits &v_traits = value_traits())
      : Base(b, e, cmp, v_traits)
   {}

   set(set && x)
      : Base(::boost::move((Base&)(x)))
   {}

   set& operator=(set && x)
   { return static_cast<set &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   void clone_from(const set &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   void clone_from(set && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   static set &container_from_end_iterator(iterator end_iterator)
   { return static_cast<set &>(Base::container_from_end_iterator(end_iterator)); }

   static const set &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const set &>(Base::container_from_end_iterator(end_iterator)); }

   static set &container_from_iterator(iterator it)
   { return static_cast<set &>(Base::container_from_iterator(it)); }

   static const set &container_from_iterator(const_iterator it)
   { return static_cast<const set &>(Base::container_from_iterator(it)); }
};
# 587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>

class multiset_impl

   : public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder>

{

   typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder> tree_type;

   public: multiset_impl(multiset_impl const &) = delete; multiset_impl& operator=(multiset_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:
   typedef tree_type implementation_defined;


   public:
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::key_type key_type;
   typedef typename implementation_defined::key_of_value key_of_value;
   typedef typename implementation_defined::value_traits value_traits;
   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::insert_commit_data insert_commit_data;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = tree_type::constant_time_size;

   public:

   multiset_impl()
      : tree_type()
   {}


   explicit multiset_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : tree_type(cmp, v_traits)
   {}


   template<class Iterator>
   multiset_impl( Iterator b, Iterator e
                , const key_compare &cmp = key_compare()
                , const value_traits &v_traits = value_traits())
      : tree_type(false, b, e, cmp, v_traits)
   {}


   multiset_impl(multiset_impl && x)
      : tree_type(::boost::move((tree_type&)(x)))
   {}


   multiset_impl& operator=(multiset_impl && x)
   { return static_cast<multiset_impl&>(tree_type::operator=(::boost::move((tree_type&)(x)))); }
# 737 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
   using tree_type::clone_from;




   template <class Cloner, class Disposer>
   void clone_from(multiset_impl && src, Cloner cloner, Disposer disposer)
   { tree_type::clone_from(::boost::move((tree_type&)(src)), cloner, disposer); }


   iterator insert(reference value)
   { return tree_type::insert_equal(value); }


   iterator insert(const_iterator hint, reference value)
   { return tree_type::insert_equal(hint, value); }


   template<class Iterator>
   void insert(Iterator b, Iterator e)
   { tree_type::insert_equal(b, e); }
# 922 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
   template<class Compare2>
   void merge(multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_equal(source); }

   template<class Compare2>
   void merge(set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_equal(source); }


};
# 957 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 3 4
template<class T, class O1 = void, class O2 = void
                , class O3 = void, class O4 = void
                , class O5 = void, class O6 = void>

struct make_multiset
{

   typedef typename pack_options
      < rbtree_defaults,

      O1, O2, O3, O4, O5, O6



      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;

   typedef multiset_impl
         < value_traits
         , typename packed_options::key_of_value
         , typename packed_options::compare
         , 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 O1, class O2, class O3, class O4, class O5, class O6>



class multiset
   : public make_multiset<T,

      O1, O2, O3, O4, O5, O6



      >::type
{
   typedef typename make_multiset<T,

      O1, O2, O3, O4, O5, O6



      >::type Base;

   public: multiset(multiset const &) = delete; multiset& operator=(multiset 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::key_compare key_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   static_assert((detail::is_same<typename value_traits::value_type, T>::value), "(detail::is_same<typename value_traits::value_type, T>::value)");

   multiset()
      : Base()
   {}

   explicit multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   multiset( Iterator b, Iterator e
           , const key_compare &cmp = key_compare()
           , const value_traits &v_traits = value_traits())
      : Base(b, e, cmp, v_traits)
   {}

   multiset(multiset && x)
      : Base(::boost::move((Base&)(x)))
   {}

   multiset& operator=(multiset && x)
   { return static_cast<multiset &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   void clone_from(const multiset &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   void clone_from(multiset && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   static multiset &container_from_end_iterator(iterator end_iterator)
   { return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator)); }

   static const multiset &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const multiset &>(Base::container_from_end_iterator(end_iterator)); }

   static multiset &container_from_iterator(iterator it)
   { return static_cast<multiset &>(Base::container_from_iterator(it)); }

   static const multiset &container_from_iterator(const_iterator it)
   { return static_cast<const multiset &>(Base::container_from_iterator(it)); }
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 1072 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/set.hpp" 2 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 2



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/intarith.h" 1
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/intarith.h"

# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/intarith.h"
template<typename T, typename U>
constexpr inline std::make_unsigned_t<std::common_type_t<T, U>> div_round_up(T n, U d) {
  return (n + d - 1) / d;
}


template<typename T, typename U>
constexpr inline std::make_unsigned_t<std::common_type_t<T, U>> round_up_to(T n, U d) {
  return (n % d ? (n + d - n % d) : n);
}

template<typename T, typename U>
constexpr inline std::make_unsigned_t<std::common_type_t<T, U>> shift_round_up(T x, U y) {
  return (x + (1 << y) - 1) >> y;
}




template<typename T>
constexpr inline bool isp2(T x) {
  return (x & (x - 1)) == 0;
}
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/intarith.h"
template<typename T>
constexpr inline T p2align(T x, T align) {
  return x & -align;
}






template<typename T>
constexpr inline T p2phase(T x, T align) {
  return x & (align - 1);
}







template<typename T>
constexpr inline T p2nphase(T x, T align) {
  return -x & (align - 1);
}






template<typename T>
constexpr inline T p2roundup(T x, T align) {
  return -(-x & -align);
}



template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) <= sizeof(unsigned)),
  unsigned>::type ctz(T v) {
  if (v == 0)
    return sizeof(v) * 8;
  return __builtin_ctz(v);
}

template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) > sizeof(unsigned int) &&
   sizeof(T) <= sizeof(unsigned long)),
  unsigned>::type ctz(T v) {
  if (v == 0)
    return sizeof(v) * 8;
  return __builtin_ctzl(v);
}

template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) > sizeof(unsigned long) &&
   sizeof(T) <= sizeof(unsigned long long)),
  unsigned>::type ctz(T v) {
  if (v == 0)
    return sizeof(v) * 8;
  return __builtin_ctzll(v);
}



template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) <= sizeof(unsigned)),
  unsigned>::type clz(T v) {
  if (v == 0)
    return sizeof(v) * 8;
  return __builtin_clz(v);
}

template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) > sizeof(unsigned int) &&
   sizeof(T) <= sizeof(unsigned long)),
  unsigned>::type clz(T v) {
  if (v == 0)
    return sizeof(v) * 8;
  return __builtin_clzl(v);
}

template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) > sizeof(unsigned long) &&
   sizeof(T) <= sizeof(unsigned long long)),
  unsigned>::type clz(T v) {
  if (v == 0)
    return sizeof(v) * 8;
  return __builtin_clzll(v);
}


template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) <= sizeof(unsigned)),
  unsigned>::type cbits(T v) {
  if (v == 0)
    return 0;
  return (sizeof(v) * 8) - __builtin_clz(v);
}

template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) > sizeof(unsigned int) &&
   sizeof(T) <= sizeof(unsigned long)),
  unsigned>::type cbits(T v) {
  if (v == 0)
    return 0;
  return (sizeof(v) * 8) - __builtin_clzl(v);
}

template<class T>
  inline typename std::enable_if<
  (std::is_integral<T>::value &&
   sizeof(T) > sizeof(unsigned long) &&
   sizeof(T) <= sizeof(unsigned long long)),
  unsigned>::type cbits(T v) {
  if (v == 0)
    return 0;
  return (sizeof(v) * 8) - __builtin_clzll(v);
}
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 2





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/convenience.h" 1
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 2

template<typename T, typename=void>
struct denc_traits {
  static constexpr bool supported = false;
  static constexpr bool featured = false;
  static constexpr bool bounded = false;
  static constexpr bool need_contiguous = true;
};

template<typename T>
inline constexpr bool denc_supported = denc_traits<T>::supported;
# 229 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h"
namespace _denc {
template<typename T, typename... Us>
inline constexpr bool is_any_of = (... || std::is_same_v<T, Us>);

template<typename T, typename=void> struct underlying_type {
  using type = T;
};
template<typename T>
struct underlying_type<T, std::enable_if_t<std::is_enum_v<T>>> {
  using type = std::underlying_type_t<T>;
};
template<typename T>
using underlying_type_t = typename underlying_type<T>::type;
}

template<class It>
struct is_const_iterator
  : std::conditional_t<std::is_const_v<std::remove_pointer_t<typename It::pointer>>,
         std::true_type,
         std::false_type>
{};
template<>
struct is_const_iterator<size_t> : std::false_type {};
template<>
struct is_const_iterator<buffer::list::contiguous_appender> : std::false_type {

};
template<class It>
inline constexpr bool is_const_iterator_v = is_const_iterator<It>::value;

template<typename T, class It>
std::enable_if_t<is_const_iterator_v<It>, const T&>
get_pos_add(It& i) {
  return *reinterpret_cast<const T*>(i.get_pos_add(sizeof(T)));
}

template<typename T, class It>
std::enable_if_t<!is_const_iterator_v<It>, T&>
get_pos_add(It& i) {
  return *reinterpret_cast<T*>(i.get_pos_add(sizeof(T)));
}

template<typename T>
struct denc_traits<
  T,
  std::enable_if_t<
    _denc::is_any_of<_denc::underlying_type_t<T>,
       ceph_le64, ceph_le32, ceph_le16, uint8_t

         , int8_t

       >>> {
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = true;
  static constexpr bool need_contiguous = false;
  static void bound_encode(const T &o, size_t& p, uint64_t f=0) {
    p += sizeof(T);
  }
  template<class It>
  static std::enable_if_t<!is_const_iterator_v<It>>
  encode(const T &o, It& p, uint64_t f=0) {
    get_pos_add<T>(p) = o;
  }
  template<class It>
  static std::enable_if_t<is_const_iterator_v<It>>
  decode(T& o, It& p, uint64_t f=0) {
    o = get_pos_add<T>(p);
  }
  static void decode(T& o, buffer::list::const_iterator &p) {
    p.copy(sizeof(T), reinterpret_cast<char*>(&o));
  }
};
# 315 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h"
namespace _denc {

template<typename T, typename=void> struct ExtType {
  using type = void;
};

template<typename T>
struct ExtType<T, std::enable_if_t<std::is_same_v<T, int16_t> ||
       std::is_same_v<T, uint16_t>>> {
  using type = ceph_le16;
};

template<typename T>
struct ExtType<T, std::enable_if_t<std::is_same_v<T, int32_t> ||
       std::is_same_v<T, uint32_t>>> {
  using type = ceph_le32;
};

template<typename T>
struct ExtType<T, std::enable_if_t<std::is_same_v<T, int64_t> ||
       std::is_same_v<T, uint64_t>>> {
  using type = ceph_le64;
};

template<>
struct ExtType<bool> {
  using type = uint8_t;
};
template<typename T>
using ExtType_t = typename ExtType<T>::type;
}

template<typename T>
struct denc_traits<T, std::enable_if_t<!std::is_void_v<_denc::ExtType_t<T>>>>
{
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = true;
  static constexpr bool need_contiguous = false;
  using etype = _denc::ExtType_t<T>;
  static void bound_encode(const T &o, size_t& p, uint64_t f=0) {
    p += sizeof(etype);
  }
  template<class It>
  static std::enable_if_t<!is_const_iterator_v<It>>
  encode(const T &o, It& p, uint64_t f=0) {
    get_pos_add<etype>(p) = o;
  }
  template<class It>
  static std::enable_if_t<is_const_iterator_v<It>>
  decode(T& o, It &p, uint64_t f=0) {
    o = get_pos_add<etype>(p);
  }
  static void decode(T& o, buffer::list::const_iterator &p) {
    etype e;
    p.copy(sizeof(etype), reinterpret_cast<char*>(&e));
    o = e;
  }
};




template<typename T>
inline void denc_varint(T v, size_t& p) {
  p += sizeof(T) + 1;
}

template<typename T>
inline void denc_varint(T v, bufferlist::contiguous_appender& p) {
  uint8_t byte = v & 0x7f;
  v >>= 7;
  while (v) {
    byte |= 0x80;
    get_pos_add<__u8>(p) = byte;
    byte = (v & 0x7f);
    v >>= 7;
  }
  get_pos_add<__u8>(p) = byte;
}

template<typename T>
inline void denc_varint(T& v, bufferptr::const_iterator& p) {
  uint8_t byte = *(__u8*)p.get_pos_add(1);
  v = byte & 0x7f;
  int shift = 7;
  while (byte & 0x80) {
    byte = get_pos_add<__u8>(p);
    v |= (T)(byte & 0x7f) << shift;
    shift += 7;
  }
}






inline void denc_signed_varint(int64_t v, size_t& p) {
  p += sizeof(v) + 2;
}
template<class It>
inline std::enable_if_t<!is_const_iterator_v<It>>
denc_signed_varint(int64_t v, It& p) {
  if (v < 0) {
    v = (-v << 1) | 1;
  } else {
    v <<= 1;
  }
  denc_varint(v, p);
}

template<typename T, class It>
inline std::enable_if_t<is_const_iterator_v<It>>
denc_signed_varint(T& v, It& p)
{
  int64_t i = 0;
  denc_varint(i, p);
  if (i & 1) {
    v = -(i >> 1);
  } else {
    v = i >> 1;
  }
}






inline void denc_varint_lowz(uint64_t v, size_t& p) {
  p += sizeof(v) + 2;
}
inline void denc_varint_lowz(uint64_t v, bufferlist::contiguous_appender& p) {
  int lowznib = v ? (ctz(v) / 4) : 0;
  if (lowznib > 3)
    lowznib = 3;
  v >>= lowznib * 4;
  v <<= 2;
  v |= lowznib;
  denc_varint(v, p);
}

template<typename T>
inline void denc_varint_lowz(T& v, bufferptr::const_iterator& p)
{
  uint64_t i = 0;
  denc_varint(i, p);
  int lowznib = (i & 3);
  i >>= 2;
  i <<= lowznib * 4;
  v = i;
}







inline void denc_signed_varint_lowz(int64_t v, size_t& p) {
  p += sizeof(v) + 2;
}
template<class It>
inline std::enable_if_t<!is_const_iterator_v<It>>
denc_signed_varint_lowz(int64_t v, It& p) {
  bool negative = false;
  if (v < 0) {
    v = -v;
    negative = true;
  }
  unsigned lowznib = v ? (ctz(v) / 4) : 0u;
  if (lowznib > 3)
    lowznib = 3;
  v >>= lowznib * 4;
  v <<= 3;
  v |= lowznib << 1;
  v |= (int)negative;
  denc_varint(v, p);
}

template<typename T, class It>
inline std::enable_if_t<is_const_iterator_v<It>>
denc_signed_varint_lowz(T& v, It& p)
{
  int64_t i = 0;
  denc_varint(i, p);
  int lowznib = (i & 6) >> 1;
  if (i & 1) {
    i >>= 3;
    i <<= lowznib * 4;
    v = -i;
  } else {
    i >>= 3;
    i <<= lowznib * 4;
    v = i;
  }
}
# 525 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h"
inline void denc_lba(uint64_t v, size_t& p) {
  p += sizeof(v) + 2;
}

template<class It>
inline std::enable_if_t<!is_const_iterator_v<It>>
denc_lba(uint64_t v, It& p) {
  int low_zero_nibbles = v ? (int)(ctz(v) / 4) : 0;
  int pos;
  uint32_t word;
  int t = low_zero_nibbles - 3;
  if (t < 0) {
    pos = 3;
    word = 0x7;
  } else if (t < 3) {
    v >>= (low_zero_nibbles * 4);
    pos = t + 1;
    word = (1 << t) - 1;
  } else {
    v >>= 20;
    pos = 3;
    word = 0x3;
  }
  word |= (v << pos) & 0x7fffffff;
  v >>= 31 - pos;
  if (!v) {
    *(ceph_le32*)p.get_pos_add(sizeof(uint32_t)) = word;
    return;
  }
  word |= 0x80000000;
  *(ceph_le32*)p.get_pos_add(sizeof(uint32_t)) = word;
  uint8_t byte = v & 0x7f;
  v >>= 7;
  while (v) {
    byte |= 0x80;
    *(__u8*)p.get_pos_add(1) = byte;
    byte = (v & 0x7f);
    v >>= 7;
  }
  *(__u8*)p.get_pos_add(1) = byte;
}

template<class It>
inline std::enable_if_t<is_const_iterator_v<It>>
denc_lba(uint64_t& v, It& p) {
  uint32_t word = *(ceph_le32*)p.get_pos_add(sizeof(uint32_t));
  int shift;
  switch (word & 7) {
  case 0:
  case 2:
  case 4:
  case 6:
    v = (uint64_t)(word & 0x7ffffffe) << (12 - 1);
    shift = 12 + 30;
    break;
  case 1:
  case 5:
    v = (uint64_t)(word & 0x7ffffffc) << (16 - 2);
    shift = 16 + 29;
    break;
  case 3:
    v = (uint64_t)(word & 0x7ffffff8) << (20 - 3);
    shift = 20 + 28;
    break;
  case 7:
    v = (uint64_t)(word & 0x7ffffff8) >> 3;
    shift = 28;
  }
  uint8_t byte = word >> 24;
  while (byte & 0x80) {
    byte = *(__u8*)p.get_pos_add(1);
    v |= (uint64_t)(byte & 0x7f) << shift;
    shift += 7;
  }
}





template<typename T, typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported> denc(
  const T& o,
  size_t& p,
  uint64_t f=0)
{
  if constexpr (traits::featured) {
    traits::bound_encode(o, p, f);
  } else {
    traits::bound_encode(o, p);
  }
}

template<typename T, class It, typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported && !is_const_iterator_v<It>>
denc(const T& o,
     It& p,
     uint64_t features=0)
{
  if constexpr (traits::featured) {
    traits::encode(o, p, features);
  } else {
    traits::encode(o, p);
  }
}

template<typename T, class It, typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported && is_const_iterator_v<It>>
denc(T& o,
     It& p,
     uint64_t features=0)
{
  if constexpr (traits::featured) {
    traits::decode(o, p, features);
  } else {
    traits::decode(o, p);
  }
}

namespace _denc {
template<typename T, typename = void>
struct has_legacy_denc : std::false_type {};
template<typename T>
struct has_legacy_denc<T, decltype(std::declval<T&>()
       .decode(std::declval<
        bufferlist::const_iterator&>()))>
  : std::true_type {
  static void decode(T& v, bufferlist::const_iterator& p) {
    v.decode(p);
  }
};
template<typename T>
struct has_legacy_denc<T,
         std::enable_if_t<
    !denc_traits<T>::need_contiguous>> : std::true_type {
  static void decode(T& v, bufferlist::const_iterator& p) {
    denc_traits<T>::decode(v, p);
  }
};
}

template<typename T,
  typename traits=denc_traits<T>,
  typename has_legacy_denc=_denc::has_legacy_denc<T>>
inline std::enable_if_t<traits::supported &&
   has_legacy_denc::value> denc(
  T& o,
  buffer::list::const_iterator& p)
{
  has_legacy_denc::decode(o, p);
}







template<typename A>
struct denc_traits<std::basic_string<char,std::char_traits<char>,A>> {
private:
  using value_type = std::basic_string<char,std::char_traits<char>,A>;

public:
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = false;
  static constexpr bool need_contiguous = false;

  static void bound_encode(const value_type& s, size_t& p, uint64_t f=0) {
    p += sizeof(uint32_t) + s.size();
  }
  template<class It>
  static void encode(const value_type& s,
       It& p,
                     uint64_t f=0) {
    denc((uint32_t)s.size(), p);
    memcpy(p.get_pos_add(s.size()), s.data(), s.size());
  }
  template<class It>
  static void decode(value_type& s,
       It& p,
       uint64_t f=0) {
    uint32_t len;
    denc(len, p);
    decode_nohead(len, s, p);
  }
  static void decode(value_type& s, buffer::list::const_iterator& p)
  {
    uint32_t len;
    denc(len, p);
    decode_nohead(len, s, p);
  }
  template<class It>
  static void decode_nohead(size_t len, value_type& s, It& p) {
    s.clear();
    if (len) {
      s.append(p.get_pos_add(len), len);
    }
  }
  static void decode_nohead(size_t len, value_type& s,
                            buffer::list::const_iterator& p) {
    if (len) {
      if constexpr (std::is_same_v<value_type, std::string>) {
        s.clear();
        p.copy(len, s);
      } else {
        s.resize(len);
        p.copy(len, s.data());
      }
    } else {
      s.clear();
    }
  }
  template<class It>
  static std::enable_if_t<!is_const_iterator_v<It>>
  encode_nohead(const value_type& s, It& p) {
    auto len = s.length();
    maybe_inline_memcpy(p.get_pos_add(len), s.data(), len, 16);
  }
};




template<>
struct denc_traits<bufferptr> {
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = false;
  static constexpr bool need_contiguous = false;
  static void bound_encode(const bufferptr& v, size_t& p, uint64_t f=0) {
    p += sizeof(uint32_t) + v.length();
  }
  template <class It>
  static std::enable_if_t<!is_const_iterator_v<It>>
  encode(const bufferptr& v, It& p, uint64_t f=0) {
    denc((uint32_t)v.length(), p);
    p.append(v);
  }
  template <class It>
  static std::enable_if_t<is_const_iterator_v<It>>
  decode(bufferptr& v, It& p, uint64_t f=0) {
    uint32_t len;
    denc(len, p);
    v = p.get_ptr(len);
  }
  static void decode(bufferptr& v, buffer::list::const_iterator& p) {
    uint32_t len;
    denc(len, p);
    bufferlist s;
    p.copy(len, s);
    if (len) {
      if (s.get_num_buffers() == 1)
 v = s.front();
      else
 v = buffer::copy(s.c_str(), s.length());
    }
  }
};




template<>
struct denc_traits<bufferlist> {
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = false;
  static constexpr bool need_contiguous = false;
  static void bound_encode(const bufferlist& v, size_t& p, uint64_t f=0) {
    p += sizeof(uint32_t) + v.length();
  }
  static void encode(const bufferlist& v, buffer::list::contiguous_appender& p,
       uint64_t f=0) {
    denc((uint32_t)v.length(), p);
    p.append(v);
  }
  static void decode(bufferlist& v, buffer::ptr::const_iterator& p, uint64_t f=0) {
    uint32_t len;
    denc(len, p);
    v.clear();
    v.push_back(p.get_ptr(len));
  }
  static void decode(bufferlist& v, buffer::list::const_iterator& p) {
    uint32_t len;
    denc(len, p);
    v.clear();
    p.copy(len, v);
  }
  static void encode_nohead(const bufferlist& v,
       buffer::list::contiguous_appender& p) {
    p.append(v);
  }
  static void decode_nohead(size_t len, bufferlist& v,
       buffer::ptr::const_iterator& p) {
    v.clear();
    if (len) {
      v.append(p.get_ptr(len));
    }
  }
  static void decode_nohead(size_t len, bufferlist& v,
       buffer::list::const_iterator& p) {
    v.clear();
    p.copy(len, v);
  }
};




template<typename A, typename B>
struct denc_traits<
  std::pair<A, B>,
  std::enable_if_t<denc_supported<A> && denc_supported<B>>> {
  typedef denc_traits<A> a_traits;
  typedef denc_traits<B> b_traits;

  static constexpr bool supported = true;
  static constexpr bool featured = a_traits::featured || b_traits::featured ;
  static constexpr bool bounded = a_traits::bounded && b_traits::bounded;
  static constexpr bool need_contiguous = (a_traits::need_contiguous ||
        b_traits::need_contiguous);

  static void bound_encode(const std::pair<A,B>& v, size_t& p, uint64_t f = 0) {
    if constexpr (featured) {
      denc(v.first, p, f);
      denc(v.second, p, f);
    } else {
      denc(v.first, p);
      denc(v.second, p);
    }
  }

  static void encode(const std::pair<A,B>& v, bufferlist::contiguous_appender& p,
       uint64_t f = 0) {
    if constexpr (featured) {
      denc(v.first, p, f);
      denc(v.second, p, f);
    } else {
      denc(v.first, p);
      denc(v.second, p);
    }
  }

  static void decode(std::pair<A,B>& v, buffer::ptr::const_iterator& p, uint64_t f=0) {
    denc(v.first, p, f);
    denc(v.second, p, f);
  }
  template<typename AA=A>
  static std::enable_if_t<!!sizeof(AA) && !need_contiguous>
    decode(std::pair<A,B>& v, buffer::list::const_iterator& p,
     uint64_t f = 0) {
    denc(v.first, p);
    denc(v.second, p);
  }
};

namespace _denc {
  template<template<class...> class C, typename Details, typename ...Ts>
  struct container_base {
  private:
    using container = C<Ts...>;
    using T = typename Details::T;

  public:
    using traits = denc_traits<T>;

    static constexpr bool supported = true;
    static constexpr bool featured = traits::featured;
    static constexpr bool bounded = false;
    static constexpr bool need_contiguous = traits::need_contiguous;

    template<typename U=T>
    static void bound_encode(const container& s, size_t& p, uint64_t f = 0) {
      p += sizeof(uint32_t);
      if constexpr (traits::bounded) {
        if (!s.empty()) {


          size_t elem_size = 0;
          if constexpr (traits::featured) {
            denc(static_cast<const T&>(*s.begin()), elem_size, f);
          } else {
            denc(static_cast<const T&>(*s.begin()), elem_size);
          }
          p += sizeof(uint32_t) + elem_size * s.size();
        }
      } else {
        for (const T& e : s) {
          if constexpr (traits::featured) {
            denc(e, p, f);
          } else {
            denc(e, p);
          }
        }
      }
    }

    template<typename U=T>
    static void encode(const container& s, buffer::list::contiguous_appender& p,
    uint64_t f = 0) {
      denc((uint32_t)s.size(), p);
      if constexpr (traits::featured) {
        encode_nohead(s, p, f);
      } else {
        encode_nohead(s, p);
      }
    }
    static void decode(container& s, buffer::ptr::const_iterator& p, uint64_t f = 0) {
      uint32_t num;
      denc(num, p);
      decode_nohead(num, s, p, f);
    }
    template<typename U=T>
    static std::enable_if_t<!!sizeof(U) && !need_contiguous>
    decode(container& s, buffer::list::const_iterator& p) {
      uint32_t num;
      denc(num, p);
      decode_nohead(num, s, p);
    }


    static void encode_nohead(const container& s, buffer::list::contiguous_appender& p,
         uint64_t f = 0) {
      for (const T& e : s) {
        if constexpr (traits::featured) {
          denc(e, p, f);
        } else {
          denc(e, p);
        }
      }
    }
    static void decode_nohead(size_t num, container& s,
         buffer::ptr::const_iterator& p, uint64_t f=0) {
      s.clear();
      Details::reserve(s, num);
      while (num--) {
 T t;
 denc(t, p, f);
 Details::insert(s, std::move(t));
      }
    }
    template<typename U=T>
    static std::enable_if_t<!!sizeof(U) && !need_contiguous>
    decode_nohead(size_t num, container& s,
    buffer::list::const_iterator& p) {
      s.clear();
      Details::reserve(s, num);
      while (num--) {
 T t;
 denc(t, p);
 Details::insert(s, std::move(t));
      }
    }
  };

  template<typename T>
  class container_has_reserve {
    template<typename U, U> struct SFINAE_match;
    template<typename U>
    static std::true_type test(SFINAE_match<T(*)(typename T::size_type),
          &U::reserve>*);

    template<typename U>
    static std::false_type test(...);

  public:
    static constexpr bool value = decltype(
      test<denc_traits<T>>(0))::value;
  };
  template<typename T>
  inline constexpr bool container_has_reserve_v =
    container_has_reserve<T>::value;


  template<typename Container>
  struct container_details_base {
    using T = typename Container::value_type;
    static void reserve(Container& c, size_t s) {
      if constexpr (container_has_reserve_v<Container>) {
        c.reserve(s);
      }
    }
  };

  template<typename Container>
  struct pushback_details : public container_details_base<Container> {
    template<typename ...Args>
    static void insert(Container& c, Args&& ...args) {
      c.emplace_back(std::forward<Args>(args)...);
    }
  };
}

template<typename T, typename ...Ts>
struct denc_traits<
  std::list<T, Ts...>,
  typename std::enable_if_t<denc_traits<T>::supported>>
  : public _denc::container_base<std::list,
     _denc::pushback_details<std::list<T, Ts...>>,
     T, Ts...> {};

template<typename T, typename ...Ts>
struct denc_traits<
  std::vector<T, Ts...>,
  typename std::enable_if_t<denc_traits<T>::supported>>
  : public _denc::container_base<std::vector,
     _denc::pushback_details<std::vector<T, Ts...>>,
     T, Ts...> {};

namespace _denc {
  template<typename Container>
  struct setlike_details : public container_details_base<Container> {
    using T = typename Container::value_type;
    template<typename ...Args>
    static void insert(Container& c, Args&& ...args) {
      c.emplace_hint(c.cend(), std::forward<Args>(args)...);
    }
  };
}

template<typename T, typename ...Ts>
struct denc_traits<
  std::set<T, Ts...>,
  std::enable_if_t<denc_traits<T>::supported>>
  : public _denc::container_base<std::set,
     _denc::setlike_details<std::set<T, Ts...>>,
     T, Ts...> {};

template<typename T, typename ...Ts>
struct denc_traits<
  boost::container::flat_set<T, Ts...>,
  std::enable_if_t<denc_traits<T>::supported>>
  : public _denc::container_base<
  boost::container::flat_set,
  _denc::setlike_details<boost::container::flat_set<T, Ts...>>,
  T, Ts...> {};

namespace _denc {
  template<typename Container>
  struct maplike_details : public container_details_base<Container> {
    using T = std::pair<typename Container::key_type,
   typename Container::mapped_type>;
    template<typename ...Args>
    static void insert(Container& c, Args&& ...args) {
      c.emplace_hint(c.cend(), std::forward<Args>(args)...);
    }
  };
}

template<typename A, typename B, typename ...Ts>
struct denc_traits<
  std::map<A, B, Ts...>,
  std::enable_if_t<denc_traits<A>::supported &&
     denc_traits<B>::supported>>
  : public _denc::container_base<std::map,
     _denc::maplike_details<std::map<A, B, Ts...>>,
     A, B, Ts...> {};

template<typename A, typename B, typename ...Ts>
struct denc_traits<
  boost::container::flat_map<A, B, Ts...>,
  std::enable_if_t<denc_traits<A>::supported &&
     denc_traits<B>::supported>>
  : public _denc::container_base<
  boost::container::flat_map,
  _denc::maplike_details<boost::container::flat_map<
      A, B, Ts...>>,
  A, B, Ts...> {};

template<typename T, size_t N>
struct denc_traits<
  std::array<T, N>,
  std::enable_if_t<denc_traits<T>::supported>> {
private:
  using container = std::array<T, N>;
public:
  using traits = denc_traits<T>;

  static constexpr bool supported = true;
  static constexpr bool featured = traits::featured;
  static constexpr bool bounded = traits::bounded;
  static constexpr bool need_contiguous = traits::need_contiguous;

  static void bound_encode(const container& s, size_t& p, uint64_t f = 0) {
    if constexpr (traits::bounded) {
      if constexpr (traits::featured) {
        if (!s.empty()) {
          size_t elem_size = 0;
          denc(*s.begin(), elem_size, f);
          p += elem_size * s.size();
        }
      } else {
        size_t elem_size = 0;
        denc(*s.begin(), elem_size);
        p += elem_size * N;
      }
    } else {
      for (const auto& e : s) {
        if constexpr (traits::featured) {
          denc(e, p, f);
        } else {
          denc(e, p);
        }
      }
    }
  }

  static void encode(const container& s, buffer::list::contiguous_appender& p,
  uint64_t f = 0) {
    for (const auto& e : s) {
      if constexpr (traits::featured) {
        denc(e, p, f);
      } else {
        denc(e, p);
      }
    }
  }
  static void decode(container& s, buffer::ptr::const_iterator& p, uint64_t f = 0) {
    for (auto& e : s)
      denc(e, p, f);
  }
  template<typename U=T>
  static std::enable_if_t<!!sizeof(U) &&
     !need_contiguous>
  decode(container& s, buffer::list::const_iterator& p) {
    for (auto& e : s) {
      denc(e, p);
    }
  }
};

template<typename... Ts>
struct denc_traits<
  std::tuple<Ts...>,
  std::enable_if_t<(denc_traits<Ts>::supported && ...)>> {

private:
  static_assert(sizeof...(Ts) > 0,
  "Zero-length tuples are not supported.");
  using container = std::tuple<Ts...>;

public:

  static constexpr bool supported = true;
  static constexpr bool featured = (denc_traits<Ts>::featured || ...);
  static constexpr bool bounded = (denc_traits<Ts>::bounded && ...);
  static constexpr bool need_contiguous =
      (denc_traits<Ts>::need_contiguous || ...);

  template<typename U = container>
  static std::enable_if_t<denc_traits<U>::featured>
  bound_encode(const container& s, size_t& p, uint64_t f) {
    ceph::for_each(s, [&p, f] (const auto& e) {
 if constexpr (denc_traits<std::decay_t<decltype(e)>>::featured) {
   denc(e, p, f);
 } else {
   denc(e, p);
 }
      });
  }
  template<typename U = container>
  static std::enable_if_t<!denc_traits<U>::featured>
  bound_encode(const container& s, size_t& p) {
    ceph::for_each(s, [&p] (const auto& e) {
 denc(e, p);
      });
  }

  template<typename U = container>
  static std::enable_if_t<denc_traits<U>::featured>
  encode(const container& s, buffer::list::contiguous_appender& p, uint64_t f) {
    ceph::for_each(s, [&p, f] (const auto& e) {
 if constexpr (denc_traits<std::decay_t<decltype(e)>>::featured) {
   denc(e, p, f);
 } else {
   denc(e, p);
 }
      });
  }
  template<typename U = container>
  static std::enable_if_t<!denc_traits<U>::featured>
  encode(const container& s, buffer::list::contiguous_appender& p) {
    ceph::for_each(s, [&p] (const auto& e) {
 denc(e, p);
      });
  }

  static void decode(container& s, buffer::ptr::const_iterator& p, uint64_t f = 0) {
    ceph::for_each(s, [&p] (auto& e) {
 denc(e, p);
      });
  }

  template<typename U = container>
  static std::enable_if_t<!denc_traits<U>::need_contiguous>
  decode(container& s, buffer::list::const_iterator& p, uint64_t f = 0) {
    ceph::for_each(s, [&p] (auto& e) {
 denc(e, p);
      });
  }
};




template<typename T>
struct denc_traits<
  boost::optional<T>,
  std::enable_if_t<denc_traits<T>::supported>> {
  using traits = denc_traits<T>;

  static constexpr bool supported = true;
  static constexpr bool featured = traits::featured;
  static constexpr bool bounded = false;
  static constexpr bool need_contiguous = traits::need_contiguous;

  static void bound_encode(const boost::optional<T>& v, size_t& p,
      uint64_t f = 0) {
    p += sizeof(bool);
    if (v) {
      if constexpr (featured) {
        denc(*v, p, f);
      } else {
        denc(*v, p);
      }
    }
  }

  static void encode(const boost::optional<T>& v,
       bufferlist::contiguous_appender& p,
       uint64_t f = 0) {
    denc((bool)v, p);
    if (v) {
      if constexpr (featured) {
        denc(*v, p, f);
      } else {
        denc(*v, p);
      }
    }
  }

  static void decode(boost::optional<T>& v, buffer::ptr::const_iterator& p,
       uint64_t f = 0) {
    bool x;
    denc(x, p, f);
    if (x) {
      v = T{};
      denc(*v, p, f);
    } else {
      v = boost::none;
    }
  }

  template<typename U = T>
  static std::enable_if_t<!!sizeof(U) && !need_contiguous>
  decode(boost::optional<T>& v, buffer::list::const_iterator& p) {
    bool x;
    denc(x, p);
    if (x) {
      v = T{};
      denc(*v, p);
    } else {
      v = boost::none;
    }
  }

  template<typename U = T>
  static void encode_nohead(const boost::optional<T>& v,
       bufferlist::contiguous_appender& p,
       uint64_t f = 0) {
    if (v) {
      if constexpr (featured) {
        denc(*v, p, f);
      } else {
        denc(*v, p);
      }
    }
  }

  static void decode_nohead(bool num, boost::optional<T>& v,
       buffer::ptr::const_iterator& p, uint64_t f = 0) {
    if (num) {
      v = T();
      denc(*v, p, f);
    } else {
      v = boost::none;
    }
  }
};

template<>
struct denc_traits<boost::none_t> {
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = true;
  static constexpr bool need_contiguous = false;

  static void bound_encode(const boost::none_t& v, size_t& p) {
    p += sizeof(bool);
  }

  static void encode(const boost::none_t& v,
       bufferlist::contiguous_appender& p) {
    denc(false, p);
  }
};




template<typename T>
struct denc_traits<
  std::optional<T>,
  std::enable_if_t<denc_traits<T>::supported>> {
  using traits = denc_traits<T>;

  static constexpr bool supported = true;
  static constexpr bool featured = traits::featured;
  static constexpr bool bounded = false;
  static constexpr bool need_contiguous = traits::need_contiguous;

  static void bound_encode(const std::optional<T>& v, size_t& p,
      uint64_t f = 0) {
    p += sizeof(bool);
    if (v) {
      if constexpr (featured) {
        denc(*v, p, f);
      } else {
        denc(*v, p);
      }
    }
  }

  static void encode(const std::optional<T>& v,
       bufferlist::contiguous_appender& p,
       uint64_t f = 0) {
    denc((bool)v, p);
    if (v) {
      if constexpr (featured) {
        denc(*v, p, f);
      } else {
        denc(*v, p);
      }
    }
  }

  static void decode(std::optional<T>& v, buffer::ptr::const_iterator& p,
       uint64_t f = 0) {
    bool x;
    denc(x, p, f);
    if (x) {
      v = T{};
      denc(*v, p, f);
    } else {
      v = std::nullopt;
    }
  }

  template<typename U = T>
  static std::enable_if_t<!!sizeof(U) && !need_contiguous>
  decode(std::optional<T>& v, buffer::list::const_iterator& p) {
    bool x;
    denc(x, p);
    if (x) {
      v = T{};
      denc(*v, p);
    } else {
      v = std::nullopt;
    }
  }

  static void encode_nohead(const std::optional<T>& v,
       bufferlist::contiguous_appender& p,
       uint64_t f = 0) {
    if (v) {
      if constexpr (featured) {
        denc(*v, p, f);
      } else {
        denc(*v, p);
      }
    }
  }

  static void decode_nohead(bool num, std::optional<T>& v,
       buffer::ptr::const_iterator& p, uint64_t f = 0) {
    if (num) {
      v = T();
      denc(*v, p, f);
    } else {
      v = std::nullopt;
    }
  }
};

template<>
struct denc_traits<std::nullopt_t> {
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = true;
  static constexpr bool need_contiguous = false;

  static void bound_encode(const std::nullopt_t& v, size_t& p) {
    p += sizeof(bool);
  }

  static void encode(const std::nullopt_t& v,
       bufferlist::contiguous_appender& p) {
    denc(false, p);
  }
};
# 1491 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h"
namespace ceph {
template<typename T, typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported && !traits::featured> encode(
  const T& o,
  bufferlist& bl,
  uint64_t features_unused=0)
{
  size_t len = 0;
  traits::bound_encode(o, len);
  auto a = bl.get_contiguous_appender(len);
  traits::encode(o, a);
}

template<typename T, typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported && traits::featured> encode(
  const T& o, bufferlist& bl,
  uint64_t features)
{
  size_t len = 0;
  traits::bound_encode(o, len, features);
  auto a = bl.get_contiguous_appender(len);
  traits::encode(o, a, features);
}

template<typename T,
  typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported && !traits::need_contiguous> decode(
  T& o,
  bufferlist::const_iterator& p)
{
  if (p.end())
    throw buffer::end_of_buffer();
  const auto& bl = p.get_bl();
  const auto remaining = bl.length() - p.get_off();

  if (!p.is_pointing_same_raw(bl.back()) && remaining > ceph::_page_size) {
    traits::decode(o, p);
  } else {




    bufferptr tmp;
    auto t = p;
    t.copy_shallow(remaining, tmp);
    auto cp = std::cbegin(tmp);
    traits::decode(o, cp);
    p.advance(cp.get_offset());
  }
}

template<typename T,
  typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported && traits::need_contiguous> decode(
  T& o,
  bufferlist::const_iterator& p)
{
  if (p.end())
    throw buffer::end_of_buffer();




  bufferptr tmp;
  auto t = p;
  t.copy_shallow(p.get_bl().length() - p.get_off(), tmp);
  auto cp = std::cbegin(tmp);
  traits::decode(o, cp);
  p.advance(cp.get_offset());
}


template<typename T, typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported &&
   !traits::featured> encode_nohead(
  const T& o,
  bufferlist& bl)
{
  size_t len = 0;
  traits::bound_encode(o, len);
  auto a = bl.get_contiguous_appender(len);
  traits::encode_nohead(o, a);
}

template<typename T, typename traits=denc_traits<T>>
inline std::enable_if_t<traits::supported && !traits::featured> decode_nohead(
  size_t num,
  T& o,
  bufferlist::const_iterator& p)
{
  if (!num)
    return;
  if (p.end())
    throw buffer::end_of_buffer();
  if constexpr (traits::need_contiguous) {
    bufferptr tmp;
    auto t = p;
    if constexpr (denc_traits<typename T::value_type>::bounded) {
      size_t element_size = 0;
      typename T::value_type v;
      denc_traits<typename T::value_type>::bound_encode(v, element_size);
      t.copy_shallow(num * element_size, tmp);
    } else {
      t.copy_shallow(p.get_bl().length() - p.get_off(), tmp);
    }
    auto cp = std::cbegin(tmp);
    traits::decode_nohead(num, o, cp);
    p.advance(cp.get_offset());
  } else {
    traits::decode_nohead(num, o, p);
  }
}
}
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 2

using namespace ceph;

namespace ceph {
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h"
template<class T>
inline void encode_raw(const T& t, bufferlist& bl)
{
  bl.append((char*)&t, sizeof(t));
}
template<class T>
inline void decode_raw(T& t, bufferlist::const_iterator &p)
{
  p.copy(sizeof(t), (char*)&t);
}





inline void encode(const __u8 &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(__u8 &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }

inline void encode(const __s8 &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(__s8 &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }

inline void encode(const char &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(char &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_le64 &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_le64 &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_le32 &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_le32 &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_le16 &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_le16 &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }


inline void encode(const float &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(float &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const double &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(double &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }

inline void encode(const bool &v, bufferlist& bl) {
  __u8 vv = v;
  encode_raw(vv, bl);
}
inline void decode(bool &v, bufferlist::const_iterator& p) {
  __u8 vv;
  decode_raw(vv, p);
  v = vv;
}
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h"
inline void encode(uint64_t v, ::ceph::bufferlist& bl, uint64_t features=0) { ceph_le64 e; e = v; ::ceph::encode_raw(e, bl); } inline void decode(uint64_t &v, ::ceph::bufferlist::const_iterator& p) { ceph_le64 e; ::ceph::decode_raw(e, p); v = e; }
inline void encode(int64_t v, ::ceph::bufferlist& bl, uint64_t features=0) { ceph_le64 e; e = v; ::ceph::encode_raw(e, bl); } inline void decode(int64_t &v, ::ceph::bufferlist::const_iterator& p) { ceph_le64 e; ::ceph::decode_raw(e, p); v = e; }
inline void encode(uint32_t v, ::ceph::bufferlist& bl, uint64_t features=0) { ceph_le32 e; e = v; ::ceph::encode_raw(e, bl); } inline void decode(uint32_t &v, ::ceph::bufferlist::const_iterator& p) { ceph_le32 e; ::ceph::decode_raw(e, p); v = e; }
inline void encode(int32_t v, ::ceph::bufferlist& bl, uint64_t features=0) { ceph_le32 e; e = v; ::ceph::encode_raw(e, bl); } inline void decode(int32_t &v, ::ceph::bufferlist::const_iterator& p) { ceph_le32 e; ::ceph::decode_raw(e, p); v = e; }
inline void encode(uint16_t v, ::ceph::bufferlist& bl, uint64_t features=0) { ceph_le16 e; e = v; ::ceph::encode_raw(e, bl); } inline void decode(uint16_t &v, ::ceph::bufferlist::const_iterator& p) { ceph_le16 e; ::ceph::decode_raw(e, p); v = e; }
inline void encode(int16_t v, ::ceph::bufferlist& bl, uint64_t features=0) { ceph_le16 e; e = v; ::ceph::encode_raw(e, bl); } inline void decode(int16_t &v, ::ceph::bufferlist::const_iterator& p) { ceph_le16 e; ::ceph::decode_raw(e, p); v = e; }
# 182 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h"
inline void encode(std::string_view s, bufferlist& bl, uint64_t features=0)
{
  __u32 len = s.length();
  encode(len, bl);
  if (len)
    bl.append(s.data(), len);
}
inline void encode(const std::string& s, bufferlist& bl, uint64_t features=0)
{
  return encode(std::string_view(s), bl, features);
}
inline void decode(std::string& s, bufferlist::const_iterator& p)
{
  __u32 len;
  decode(len, p);
  s.clear();
  p.copy(len, s);
}

inline void encode_nohead(std::string_view s, bufferlist& bl)
{
  bl.append(s.data(), s.length());
}
inline void encode_nohead(const std::string& s, bufferlist& bl)
{
  encode_nohead(std::string_view(s), bl);
}
inline void decode_nohead(int len, std::string& s, bufferlist::const_iterator& p)
{
  s.clear();
  p.copy(len, s);
}


inline void encode(const char *s, bufferlist& bl)
{
  encode(std::string_view(s, strlen(s)), bl);
}






inline void encode(const buffer::ptr& bp, bufferlist& bl)
{
  __u32 len = bp.length();
  encode(len, bl);
  if (len)
    bl.append(bp);
}
inline void decode(buffer::ptr& bp, bufferlist::const_iterator& p)
{
  __u32 len;
  decode(len, p);

  bufferlist s;
  p.copy(len, s);

  if (len) {
    if (s.get_num_buffers() == 1)
      bp = s.front();
    else
      bp = buffer::copy(s.c_str(), s.length());
  }
}


inline void encode(const bufferlist& s, bufferlist& bl)
{
  __u32 len = s.length();
  encode(len, bl);
  bl.append(s);
}
inline void encode_destructively(bufferlist& s, bufferlist& bl)
{
  __u32 len = s.length();
  encode(len, bl);
  bl.claim_append(s);
}
inline void decode(bufferlist& s, bufferlist::const_iterator& p)
{
  __u32 len;
  decode(len, p);
  s.clear();
  p.copy(len, s);
}

inline void encode_nohead(const bufferlist& s, bufferlist& bl)
{
  bl.append(s);
}
inline void decode_nohead(int len, bufferlist& s, bufferlist::const_iterator& p)
{
  s.clear();
  p.copy(len, s);
}



template<typename Clock, typename Duration,
         typename std::enable_if_t<converts_to_timespec_v<Clock>>* = nullptr>
void encode(const std::chrono::time_point<Clock, Duration>& t,
     ceph::bufferlist &bl) {
  auto ts = Clock::to_timespec(t);

  uint32_t s = ts.tv_sec;
  uint32_t ns = ts.tv_nsec;
  encode(s, bl);
  encode(ns, bl);
}

template<typename Clock, typename Duration,
         typename std::enable_if_t<converts_to_timespec_v<Clock>>* = nullptr>
void decode(std::chrono::time_point<Clock, Duration>& t,
     bufferlist::const_iterator& p) {
  uint32_t s;
  uint32_t ns;
  decode(s, p);
  decode(ns, p);
  struct timespec ts = {
    static_cast<time_t>(s),
    static_cast<long int>(ns)};

  t = Clock::from_timespec(ts);
}

template<typename Rep, typename Period,
         typename std::enable_if_t<std::is_integral_v<Rep>>* = nullptr>
void encode(const std::chrono::duration<Rep, Period>& d,
     ceph::bufferlist &bl) {
  using namespace std::chrono;
  uint32_t s = duration_cast<seconds>(d).count();
  uint32_t ns = (duration_cast<nanoseconds>(d) % seconds(1)).count();
  encode(s, bl);
  encode(ns, bl);
}

template<typename Rep, typename Period,
         typename std::enable_if_t<std::is_integral_v<Rep>>* = nullptr>
void decode(std::chrono::duration<Rep, Period>& d,
     bufferlist::const_iterator& p) {
  uint32_t s;
  uint32_t ns;
  decode(s, p);
  decode(ns, p);
  d = std::chrono::seconds(s) + std::chrono::nanoseconds(ns);
}




template<typename T>
inline void encode(const boost::optional<T> &p, bufferlist &bl);
template<typename T>
inline void decode(boost::optional<T> &p, bufferlist::const_iterator &bp);
template<class A, class B, class C>
inline void encode(const boost::tuple<A, B, C> &t, bufferlist& bl);
template<class A, class B, class C>
inline void decode(boost::tuple<A, B, C> &t, bufferlist::const_iterator &bp);
template<class A, class B,
  typename a_traits=denc_traits<A>, typename b_traits=denc_traits<B>>
inline std::enable_if_t<!a_traits::supported || !b_traits::supported>
encode(const std::pair<A,B> &p, bufferlist &bl, uint64_t features);
template<class A, class B,
  typename a_traits=denc_traits<A>, typename b_traits=denc_traits<B>>
inline std::enable_if_t<!a_traits::supported ||
   !b_traits::supported>
encode(const std::pair<A,B> &p, bufferlist &bl);
template<class A, class B,
  typename a_traits=denc_traits<A>, typename b_traits=denc_traits<B>>
inline std::enable_if_t<!a_traits::supported ||
   !b_traits::supported>
decode(std::pair<A,B> &pa, bufferlist::const_iterator &p);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::list<T, Alloc>& ls, bufferlist& bl);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::list<T,Alloc>& ls, bufferlist& bl, uint64_t features);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode(std::list<T,Alloc>& ls, bufferlist::const_iterator& p);
template<class T, class Alloc>
inline void encode(const std::list<std::shared_ptr<T>, Alloc>& ls,
     bufferlist& bl);
template<class T, class Alloc>
inline void encode(const std::list<std::shared_ptr<T>, Alloc>& ls,
     bufferlist& bl, uint64_t features);
template<class T, class Alloc>
inline void decode(std::list<std::shared_ptr<T>, Alloc>& ls,
     bufferlist::const_iterator& p);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::set<T,Comp,Alloc>& s, bufferlist& bl);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode(std::set<T,Comp,Alloc>& s, bufferlist::const_iterator& p);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode_nohead(const std::set<T,Comp,Alloc>& s, bufferlist& bl);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode_nohead(int len, std::set<T,Comp,Alloc>& s, bufferlist::iterator& p);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const boost::container::flat_set<T, Comp, Alloc>& s, bufferlist& bl);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode(boost::container::flat_set<T, Comp, Alloc>& s, bufferlist::const_iterator& p);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode_nohead(const boost::container::flat_set<T, Comp, Alloc>& s,
       bufferlist& bl);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode_nohead(int len, boost::container::flat_set<T, Comp, Alloc>& s,
       bufferlist::iterator& p);
template<class T, class Comp, class Alloc>
inline void encode(const std::multiset<T,Comp,Alloc>& s, bufferlist& bl);
template<class T, class Comp, class Alloc>
inline void decode(std::multiset<T,Comp,Alloc>& s, bufferlist::const_iterator& p);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::vector<T,Alloc>& v, bufferlist& bl, uint64_t features);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::vector<T,Alloc>& v, bufferlist& bl);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode(std::vector<T,Alloc>& v, bufferlist::const_iterator& p);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode_nohead(const std::vector<T,Alloc>& v, bufferlist& bl);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode_nohead(int len, std::vector<T,Alloc>& v, bufferlist::const_iterator& p);
template<class T,class Alloc>
inline void encode(const std::vector<std::shared_ptr<T>,Alloc>& v,
     bufferlist& bl,
     uint64_t features);
template<class T, class Alloc>
inline void encode(const std::vector<std::shared_ptr<T>,Alloc>& v,
     bufferlist& bl);
template<class T, class Alloc>
inline void decode(std::vector<std::shared_ptr<T>,Alloc>& v,
     bufferlist::const_iterator& p);

template<class T, std::size_t N, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const boost::container::small_vector<T,N,Alloc>& v, bufferlist& bl, uint64_t features);
template<class T, std::size_t N, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const boost::container::small_vector<T,N,Alloc>& v, bufferlist& bl);
template<class T, std::size_t N, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode(boost::container::small_vector<T,N,Alloc>& v, bufferlist::const_iterator& p);
template<class T, std::size_t N, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode_nohead(const boost::container::small_vector<T,N,Alloc>& v, bufferlist& bl);
template<class T, std::size_t N, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode_nohead(int len, boost::container::small_vector<T,N,Alloc>& v, bufferlist::const_iterator& p);

template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported ||
   !u_traits::supported>
encode(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
encode(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl, uint64_t features);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
decode(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc>
inline void decode_noclear(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
encode_nohead(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
encode_nohead(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl, uint64_t features);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
decode_nohead(int n, std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
  inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
encode(const boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist& bl);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
encode(const boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist& bl,
       uint64_t features);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
decode(boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc>
inline void decode_noclear(boost::container::flat_map<T,U,Comp,Alloc>& m,
      bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
encode_nohead(const boost::container::flat_map<T,U,Comp,Alloc>& m,
       bufferlist& bl);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
encode_nohead(const boost::container::flat_map<T,U,Comp,Alloc>& m,
       bufferlist& bl, uint64_t features);
template<class T, class U, class Comp, class Alloc,
  typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
decode_nohead(int n, boost::container::flat_map<T,U,Comp,Alloc>& m,
       bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc>
inline void encode(const std::multimap<T,U,Comp,Alloc>& m, bufferlist& bl);
template<class T, class U, class Comp, class Alloc>
inline void decode(std::multimap<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Hash, class Pred, class Alloc>
inline void encode(const unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist& bl,
     uint64_t features);
template<class T, class U, class Hash, class Pred, class Alloc>
inline void encode(const unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist& bl);
template<class T, class U, class Hash, class Pred, class Alloc>
inline void decode(unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class Hash, class Pred, class Alloc>
inline void encode(const ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist& bl);
template<class T, class Hash, class Pred, class Alloc>
inline void decode(ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class Alloc>
inline void encode(const std::deque<T,Alloc>& ls, bufferlist& bl, uint64_t features);
template<class T, class Alloc>
inline void encode(const std::deque<T,Alloc>& ls, bufferlist& bl);
template<class T, class Alloc>
inline void decode(std::deque<T,Alloc>& ls, bufferlist::const_iterator& p);
template<class T, size_t N, typename traits = denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::array<T, N>& v, bufferlist& bl, uint64_t features);
template<class T, size_t N, typename traits = denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::array<T, N>& v, bufferlist& bl);
template<class T, size_t N, typename traits = denc_traits<T>>
inline std::enable_if_t<!traits::supported>
decode(std::array<T, N>& v, bufferlist::const_iterator& p);


template<class T>
inline void decode(T &o, const bufferlist& bl)
{
  auto p = bl.begin();
  decode(o, p);
  do { static const ceph::assert_data assert_data_ctx = {"p.end()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h", 541, __PRETTY_FUNCTION__}; ((p.end()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
}


template<typename T>
inline void encode(const boost::optional<T> &p, bufferlist &bl)
{
  __u8 present = static_cast<bool>(p);
  encode(present, bl);
  if (p)
    encode(p.get(), bl);
}

#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
template<typename T>
inline void decode(boost::optional<T> &p, bufferlist::const_iterator &bp)
{
  __u8 present;
  decode(present, bp);
  if (present) {
    p = T{};
    decode(p.get(), bp);
  } else {
    p = boost::none;
  }
}
#pragma GCC diagnostic pop
#pragma GCC diagnostic warning "-Wpragmas"


template<typename... Ts>
inline void encode(const std::tuple<Ts...> &t, bufferlist& bl)
{
  ceph::for_each(t, [&bl](const auto& e) {
      encode(e, bl);
    });
}
template<typename... Ts>
inline void decode(std::tuple<Ts...> &t, bufferlist::const_iterator &bp)
{
  ceph::for_each(t, [&bp](auto& e) {
      decode(e, bp);
    });
}


template<class A, class B, class C>
inline void encode(const boost::tuple<A, B, C> &t, bufferlist& bl)
{
  encode(boost::get<0>(t), bl);
  encode(boost::get<1>(t), bl);
  encode(boost::get<2>(t), bl);
}
template<class A, class B, class C>
inline void decode(boost::tuple<A, B, C> &t, bufferlist::const_iterator &bp)
{
  decode(boost::get<0>(t), bp);
  decode(boost::get<1>(t), bp);
  decode(boost::get<2>(t), bp);
}


template<class A, class B,
  typename a_traits, typename b_traits>
inline std::enable_if_t<!a_traits::supported || !b_traits::supported>
  encode(const std::pair<A,B> &p, bufferlist &bl, uint64_t features)
{
  encode(p.first, bl, features);
  encode(p.second, bl, features);
}
template<class A, class B,
  typename a_traits, typename b_traits>
inline std::enable_if_t<!a_traits::supported ||
   !b_traits::supported>
  encode(const std::pair<A,B> &p, bufferlist &bl)
{
  encode(p.first, bl);
  encode(p.second, bl);
}
template<class A, class B, typename a_traits, typename b_traits>
inline std::enable_if_t<!a_traits::supported ||
   !b_traits::supported>
  decode(std::pair<A,B> &pa, bufferlist::const_iterator &p)
{
  decode(pa.first, p);
  decode(pa.second, p);
}


template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode(const std::list<T, Alloc>& ls, bufferlist& bl)
{
  __u32 n = (__u32)(ls.size());
  encode(n, bl);
  for (auto p = ls.begin(); p != ls.end(); ++p)
    encode(*p, bl);
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode(const std::list<T,Alloc>& ls, bufferlist& bl, uint64_t features)
{

  if (!ls.empty()) {
    unsigned pos = bl.length();
    unsigned n = 0;
    encode(n, bl);
    for (auto p = ls.begin(); p != ls.end(); ++p) {
      n++;
      encode(*p, bl, features);
    }
    ceph_le32 en;
    en = n;
    bl.copy_in(pos, sizeof(en), (char*)&en);
  } else {
    __u32 n = (__u32)(ls.size());
    encode(n, bl);
    for (auto p = ls.begin(); p != ls.end(); ++p)
      encode(*p, bl, features);
  }
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  decode(std::list<T,Alloc>& ls, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  ls.clear();
  while (n--) {
    ls.emplace_back();
    decode(ls.back(), p);
  }
}


template<class T, class Alloc>
inline void encode(const std::list<std::shared_ptr<T>, Alloc>& ls,
     bufferlist& bl)
{
  __u32 n = (__u32)(ls.size());
  encode(n, bl);
  for (const auto& ref : ls) {
    encode(*ref, bl);
  }
}
template<class T, class Alloc>
inline void encode(const std::list<std::shared_ptr<T>, Alloc>& ls,
     bufferlist& bl, uint64_t features)
{
  __u32 n = (__u32)(ls.size());
  encode(n, bl);
  for (const auto& ref : ls) {
    encode(*ref, bl, features);
  }
}
template<class T, class Alloc>
inline void decode(std::list<std::shared_ptr<T>, Alloc>& ls,
     bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  ls.clear();
  while (n--) {
    auto ref = std::make_shared<T>();
    decode(*ref, p);
    ls.emplace_back(std::move(ref));
  }
}


template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode(const std::set<T,Comp,Alloc>& s, bufferlist& bl)
{
  __u32 n = (__u32)(s.size());
  encode(n, bl);
  for (auto p = s.begin(); p != s.end(); ++p)
    encode(*p, bl);
}
template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  decode(std::set<T,Comp,Alloc>& s, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  s.clear();
  while (n--) {
    T v;
    decode(v, p);
    s.insert(v);
  }
}

template<class T, class Comp, class Alloc, typename traits>
inline typename std::enable_if<!traits::supported>::type
  encode_nohead(const std::set<T,Comp,Alloc>& s, bufferlist& bl)
{
  for (auto p = s.begin(); p != s.end(); ++p)
    encode(*p, bl);
}
template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  decode_nohead(int len, std::set<T,Comp,Alloc>& s, bufferlist::const_iterator& p)
{
  for (int i=0; i<len; i++) {
    T v;
    decode(v, p);
    s.insert(v);
  }
}


template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
encode(const boost::container::flat_set<T, Comp, Alloc>& s, bufferlist& bl)
{
  __u32 n = (__u32)(s.size());
  encode(n, bl);
  for (const auto& e : s)
    encode(e, bl);
}
template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
decode(boost::container::flat_set<T, Comp, Alloc>& s, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  s.clear();
  s.reserve(n);
  while (n--) {
    T v;
    decode(v, p);
    s.insert(v);
  }
}

template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
encode_nohead(const boost::container::flat_set<T, Comp, Alloc>& s,
       bufferlist& bl)
{
  for (const auto& e : s)
    encode(e, bl);
}
template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
decode_nohead(int len, boost::container::flat_set<T, Comp, Alloc>& s,
       bufferlist::iterator& p)
{
  s.reserve(len);
  for (int i=0; i<len; i++) {
    T v;
    decode(v, p);
    s.insert(v);
  }
}


template<class T, class Comp, class Alloc>
inline void encode(const std::multiset<T,Comp,Alloc>& s, bufferlist& bl)
{
  __u32 n = (__u32)(s.size());
  encode(n, bl);
  for (auto p = s.begin(); p != s.end(); ++p)
    encode(*p, bl);
}
template<class T, class Comp, class Alloc>
inline void decode(std::multiset<T,Comp,Alloc>& s, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  s.clear();
  while (n--) {
    T v;
    decode(v, p);
    s.insert(v);
  }
}

template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode(const std::vector<T,Alloc>& v, bufferlist& bl, uint64_t features)
{
  __u32 n = (__u32)(v.size());
  encode(n, bl);
  for (auto p = v.begin(); p != v.end(); ++p)
    encode(*p, bl, features);
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode(const std::vector<T,Alloc>& v, bufferlist& bl)
{
  __u32 n = (__u32)(v.size());
  encode(n, bl);
  for (auto p = v.begin(); p != v.end(); ++p)
    encode(*p, bl);
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  decode(std::vector<T,Alloc>& v, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  v.resize(n);
  for (__u32 i=0; i<n; i++)
    decode(v[i], p);
}

template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode_nohead(const std::vector<T,Alloc>& v, bufferlist& bl)
{
  for (auto p = v.begin(); p != v.end(); ++p)
    encode(*p, bl);
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  decode_nohead(int len, std::vector<T,Alloc>& v, bufferlist::const_iterator& p)
{
  v.resize(len);
  for (__u32 i=0; i<v.size(); i++)
    decode(v[i], p);
}


template<class T, std::size_t N, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode(const boost::container::small_vector<T,N,Alloc>& v, bufferlist& bl, uint64_t features)
{
  __u32 n = (__u32)(v.size());
  encode(n, bl);
  for (const auto& i : v)
    encode(i, bl, features);
}
template<class T, std::size_t N, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode(const boost::container::small_vector<T,N,Alloc>& v, bufferlist& bl)
{
  __u32 n = (__u32)(v.size());
  encode(n, bl);
  for (const auto& i : v)
    encode(i, bl);
}
template<class T, std::size_t N, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  decode(boost::container::small_vector<T,N,Alloc>& v, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  v.resize(n);
  for (auto& i : v)
    decode(i, p);
}

template<class T, std::size_t N, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  encode_nohead(const boost::container::small_vector<T,N,Alloc>& v, bufferlist& bl)
{
  for (const auto& i : v)
    encode(i, bl);
}
template<class T, std::size_t N, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
  decode_nohead(int len, boost::container::small_vector<T,N,Alloc>& v, bufferlist::const_iterator& p)
{
  v.resize(len);
  for (auto& i : v)
    decode(i, p);
}



template<class T,class Alloc>
inline void encode(const std::vector<std::shared_ptr<T>,Alloc>& v,
     bufferlist& bl,
     uint64_t features)
{
  __u32 n = (__u32)(v.size());
  encode(n, bl);
  for (const auto& ref : v) {
    if (ref)
      encode(*ref, bl, features);
    else
      encode(T(), bl, features);
  }
}
template<class T, class Alloc>
inline void encode(const std::vector<std::shared_ptr<T>,Alloc>& v,
     bufferlist& bl)
{
  __u32 n = (__u32)(v.size());
  encode(n, bl);
  for (const auto& ref : v) {
    if (ref)
      encode(*ref, bl);
    else
      encode(T(), bl);
  }
}
template<class T, class Alloc>
inline void decode(std::vector<std::shared_ptr<T>,Alloc>& v,
     bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  v.clear();
  v.reserve(n);
  while (n--) {
    auto ref = std::make_shared<T>();
    decode(*ref, p);
    v.emplace_back(std::move(ref));
  }
}


template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported ||
   !u_traits::supported>
  encode(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl);
    encode(p->second, bl);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  encode(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl, uint64_t features)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl, features);
    encode(p->second, bl, features);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  decode(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  m.clear();
  while (n--) {
    T k;
    decode(k, p);
    decode(m[k], p);
  }
}
template<class T, class U, class Comp, class Alloc>
inline void decode_noclear(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  while (n--) {
    T k;
    decode(k, p);
    decode(m[k], p);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  encode_nohead(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl)
{
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl);
    encode(p->second, bl);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  encode_nohead(const std::map<T,U,Comp,Alloc>& m, bufferlist& bl, uint64_t features)
{
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl, features);
    encode(p->second, bl, features);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  decode_nohead(int n, std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
  m.clear();
  while (n--) {
    T k;
    decode(k, p);
    decode(m[k], p);
  }
}


template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
  inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  encode(const boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist& bl)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (typename boost::container::flat_map<T,U,Comp>::const_iterator p
  = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl);
    encode(p->second, bl);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
  inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  encode(const boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist& bl,
  uint64_t features)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl, features);
    encode(p->second, bl, features);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
  inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  decode(boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  m.clear();
  m.reserve(n);
  while (n--) {
    T k;
    decode(k, p);
    decode(m[k], p);
  }
}
template<class T, class U, class Comp, class Alloc>
inline void decode_noclear(boost::container::flat_map<T,U,Comp,Alloc>& m,
      bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  m.reserve(m.size() + n);
  while (n--) {
    T k;
    decode(k, p);
    decode(m[k], p);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
  inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  encode_nohead(const boost::container::flat_map<T,U,Comp,Alloc>& m,
  bufferlist& bl)
{
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl);
    encode(p->second, bl);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
  inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  encode_nohead(const boost::container::flat_map<T,U,Comp,Alloc>& m,
  bufferlist& bl, uint64_t features)
{
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl, features);
    encode(p->second, bl, features);
  }
}
template<class T, class U, class Comp, class Alloc,
  typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
  decode_nohead(int n, boost::container::flat_map<T,U,Comp,Alloc>& m,
  bufferlist::const_iterator& p)
{
  m.clear();
  while (n--) {
    T k;
    decode(k, p);
    decode(m[k], p);
  }
}


template<class T, class U, class Comp, class Alloc>
inline void encode(const std::multimap<T,U,Comp,Alloc>& m, bufferlist& bl)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl);
    encode(p->second, bl);
  }
}
template<class T, class U, class Comp, class Alloc>
inline void decode(std::multimap<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  m.clear();
  while (n--) {
    typename std::pair<T,U> tu = std::pair<T,U>();
    decode(tu.first, p);
    typename std::multimap<T,U,Comp,Alloc>::iterator it = m.insert(tu);
    decode(it->second, p);
  }
}


template<class T, class U, class Hash, class Pred, class Alloc>
inline void encode(const unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist& bl,
     uint64_t features)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl, features);
    encode(p->second, bl, features);
  }
}
template<class T, class U, class Hash, class Pred, class Alloc>
inline void encode(const unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist& bl)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (auto p = m.begin(); p != m.end(); ++p) {
    encode(p->first, bl);
    encode(p->second, bl);
  }
}
template<class T, class U, class Hash, class Pred, class Alloc>
inline void decode(unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  m.clear();
  while (n--) {
    T k;
    decode(k, p);
    decode(m[k], p);
  }
}


template<class T, class Hash, class Pred, class Alloc>
inline void encode(const ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist& bl)
{
  __u32 n = (__u32)(m.size());
  encode(n, bl);
  for (auto p = m.begin(); p != m.end(); ++p)
    encode(*p, bl);
}
template<class T, class Hash, class Pred, class Alloc>
inline void decode(ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  m.clear();
  while (n--) {
    T k;
    decode(k, p);
    m.insert(k);
  }
}


template<class T, class Alloc>
inline void encode(const std::deque<T,Alloc>& ls, bufferlist& bl, uint64_t features)
{
  __u32 n = ls.size();
  encode(n, bl);
  for (auto p = ls.begin(); p != ls.end(); ++p)
    encode(*p, bl, features);
}
template<class T, class Alloc>
inline void encode(const std::deque<T,Alloc>& ls, bufferlist& bl)
{
  __u32 n = ls.size();
  encode(n, bl);
  for (auto p = ls.begin(); p != ls.end(); ++p)
    encode(*p, bl);
}
template<class T, class Alloc>
inline void decode(std::deque<T,Alloc>& ls, bufferlist::const_iterator& p)
{
  __u32 n;
  decode(n, p);
  ls.clear();
  while (n--) {
    ls.emplace_back();
    decode(ls.back(), p);
  }
}


template<class T, size_t N, typename traits>
inline std::enable_if_t<!traits::supported>
encode(const std::array<T, N>& v, bufferlist& bl, uint64_t features)
{
  for (const auto& e : v)
    encode(e, bl, features);
}
template<class T, size_t N, typename traits>
inline std::enable_if_t<!traits::supported>
encode(const std::array<T, N>& v, bufferlist& bl)
{
  for (const auto& e : v)
    encode(e, bl);
}
template<class T, size_t N, typename traits>
inline std::enable_if_t<!traits::supported>
decode(std::array<T, N>& v, bufferlist::const_iterator& p)
{
  for (auto& e : v)
    decode(e, p);
}
}
# 1447 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h"
namespace ceph {





inline ssize_t decode_file(int fd, std::string &str)
{
  bufferlist bl;
  __u32 len = 0;
  bl.read_fd(fd, sizeof(len));
  decode(len, bl);
  bl.read_fd(fd, len);
  decode(str, bl);
  return bl.length();
}

inline ssize_t decode_file(int fd, bufferptr &bp)
{
  bufferlist bl;
  __u32 len = 0;
  bl.read_fd(fd, sizeof(len));
  decode(len, bl);
  bl.read_fd(fd, len);
  auto bli = std::cbegin(bl);

  decode(bp, bli);
  return bl.length();
}
}
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h" 2


# 1 "/usr/include/c++/10/random" 1 3
# 32 "/usr/include/c++/10/random" 3
       
# 33 "/usr/include/c++/10/random" 3





# 1 "/usr/include/c++/10/cmath" 1 3
# 39 "/usr/include/c++/10/cmath" 3
       
# 40 "/usr/include/c++/10/cmath" 3
# 39 "/usr/include/c++/10/random" 2 3
# 1 "/usr/include/c++/10/cstdlib" 1 3
# 39 "/usr/include/c++/10/cstdlib" 3
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 40 "/usr/include/c++/10/random" 2 3
# 49 "/usr/include/c++/10/random" 3
# 1 "/usr/include/c++/10/bits/random.h" 1 3
# 40 "/usr/include/c++/10/bits/random.h" 3

# 40 "/usr/include/c++/10/bits/random.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 71 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, size_t __bits,
    typename _UniformRandomNumberGenerator>
    _RealType
    generate_canonical(_UniformRandomNumberGenerator& __g);




  namespace __detail
  {
    template<typename _UIntType, size_t __w,
      bool = __w < static_cast<size_t>
     (std::numeric_limits<_UIntType>::digits)>
      struct _Shift
      { static const _UIntType __value = 0; };

    template<typename _UIntType, size_t __w>
      struct _Shift<_UIntType, __w, true>
      { static const _UIntType __value = _UIntType(1) << __w; };

    template<int __s,
      int __which = ((__s <= 8 * sizeof (int))
       + (__s <= 8 * sizeof (long))
       + (__s <= 8 * sizeof (long long))

       + (__s <= 128))>
      struct _Select_uint_least_t
      {
 static_assert(__which < 0,
        "sorry, would be too much trouble for a slow result");
      };

    template<int __s>
      struct _Select_uint_least_t<__s, 4>
      { typedef unsigned int type; };

    template<int __s>
      struct _Select_uint_least_t<__s, 3>
      { typedef unsigned long type; };

    template<int __s>
      struct _Select_uint_least_t<__s, 2>
      { typedef unsigned long long type; };


    template<int __s>
      struct _Select_uint_least_t<__s, 1>
      { typedef unsigned __int128 type; };



    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
      bool __big_enough = (!(__m & (__m - 1))
      || (_Tp(-1) - __c) / __a >= __m - 1),
             bool __schrage_ok = __m % __a < __m / __a>
      struct _Mod
      {
 typedef typename _Select_uint_least_t<std::__lg(__a)
           + std::__lg(__m) + 2>::type _Tp2;
 static _Tp
 __calc(_Tp __x)
 { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); }
      };


    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
      struct _Mod<_Tp, __m, __a, __c, false, true>
      {
 static _Tp
 __calc(_Tp __x);
      };




    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
      struct _Mod<_Tp, __m, __a, __c, true, __s>
      {
 static _Tp
 __calc(_Tp __x)
 {
   _Tp __res = __a * __x + __c;
   if (__m)
     __res %= __m;
   return __res;
 }
      };

    template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
      inline _Tp
      __mod(_Tp __x)
      { return _Mod<_Tp, __m, __a, __c>::__calc(__x); }





    template<typename _Engine, typename _DInputType>
      struct _Adaptor
      {
 static_assert(std::is_floating_point<_DInputType>::value,
        "template argument must be a floating point type");

      public:
 _Adaptor(_Engine& __g)
 : _M_g(__g) { }

 _DInputType
 min() const
 { return _DInputType(0); }

 _DInputType
 max() const
 { return _DInputType(1); }






 _DInputType
 operator()()
 {
   return std::generate_canonical<_DInputType,
                             std::numeric_limits<_DInputType>::digits,
                             _Engine>(_M_g);
 }

      private:
 _Engine& _M_g;
      };

    template<typename _Sseq>
      using __seed_seq_generate_t = decltype(
   std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
       std::declval<uint_least32_t*>()));



    template<typename _Sseq, typename _Engine, typename _Res,
      typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
      using __is_seed_seq = __and_<
        __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
 is_unsigned<typename _Sseq::result_type>,
 __not_<is_convertible<_Sseq, _Res>>
      >;

  }
# 258 "/usr/include/c++/10/bits/random.h" 3
  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    class linear_congruential_engine
    {
      static_assert(std::is_unsigned<_UIntType>::value,
      "result_type must be an unsigned integral type");
      static_assert(__m == 0u || (__a < __m && __c < __m),
      "template argument substituting __m out of bounds");

      template<typename _Sseq>
 using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
   _Sseq, linear_congruential_engine, _UIntType>::value>::type;

    public:

      typedef _UIntType result_type;


      static constexpr result_type multiplier = __a;

      static constexpr result_type increment = __c;

      static constexpr result_type modulus = __m;
      static constexpr result_type default_seed = 1u;





      linear_congruential_engine() : linear_congruential_engine(default_seed)
      { }
# 296 "/usr/include/c++/10/bits/random.h" 3
      explicit
      linear_congruential_engine(result_type __s)
      { seed(__s); }







      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
        explicit
        linear_congruential_engine(_Sseq& __q)
        { seed(__q); }







      void
      seed(result_type __s = default_seed);
# 327 "/usr/include/c++/10/bits/random.h" 3
      template<typename _Sseq>
        _If_seed_seq<_Sseq>
        seed(_Sseq& __q);







      static constexpr result_type
      min()
      { return __c == 0u ? 1u : 0u; }




      static constexpr result_type
      max()
      { return __m - 1u; }




      void
      discard(unsigned long long __z)
      {
 for (; __z != 0ULL; --__z)
   (*this)();
      }




      result_type
      operator()()
      {
 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
 return _M_x;
      }
# 379 "/usr/include/c++/10/bits/random.h" 3
      friend bool
      operator==(const linear_congruential_engine& __lhs,
   const linear_congruential_engine& __rhs)
      { return __lhs._M_x == __rhs._M_x; }
# 392 "/usr/include/c++/10/bits/random.h" 3
      template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
        _UIntType1 __m1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::linear_congruential_engine<_UIntType1,
     __a1, __c1, __m1>& __lcr);
# 412 "/usr/include/c++/10/bits/random.h" 3
      template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
        _UIntType1 __m1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::linear_congruential_engine<_UIntType1, __a1,
     __c1, __m1>& __lcr);

    private:
      _UIntType _M_x;
    };
# 434 "/usr/include/c++/10/bits/random.h" 3
  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    inline bool
    operator!=(const std::linear_congruential_engine<_UIntType, __a,
        __c, __m>& __lhs,
        const std::linear_congruential_engine<_UIntType, __a,
        __c, __m>& __rhs)
    { return !(__lhs == __rhs); }
# 471 "/usr/include/c++/10/bits/random.h" 3
  template<typename _UIntType, size_t __w,
    size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t,
    _UIntType __c, size_t __l, _UIntType __f>
    class mersenne_twister_engine
    {
      static_assert(std::is_unsigned<_UIntType>::value,
      "result_type must be an unsigned integral type");
      static_assert(1u <= __m && __m <= __n,
      "template argument substituting __m out of bounds");
      static_assert(__r <= __w, "template argument substituting "
      "__r out of bound");
      static_assert(__u <= __w, "template argument substituting "
      "__u out of bound");
      static_assert(__s <= __w, "template argument substituting "
      "__s out of bound");
      static_assert(__t <= __w, "template argument substituting "
      "__t out of bound");
      static_assert(__l <= __w, "template argument substituting "
      "__l out of bound");
      static_assert(__w <= std::numeric_limits<_UIntType>::digits,
      "template argument substituting __w out of bound");
      static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
      "template argument substituting __a out of bound");
      static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
      "template argument substituting __b out of bound");
      static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
      "template argument substituting __c out of bound");
      static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
      "template argument substituting __d out of bound");
      static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
      "template argument substituting __f out of bound");

      template<typename _Sseq>
 using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
   _Sseq, mersenne_twister_engine, _UIntType>::value>::type;

    public:

      typedef _UIntType result_type;


      static constexpr size_t word_size = __w;
      static constexpr size_t state_size = __n;
      static constexpr size_t shift_size = __m;
      static constexpr size_t mask_bits = __r;
      static constexpr result_type xor_mask = __a;
      static constexpr size_t tempering_u = __u;
      static constexpr result_type tempering_d = __d;
      static constexpr size_t tempering_s = __s;
      static constexpr result_type tempering_b = __b;
      static constexpr size_t tempering_t = __t;
      static constexpr result_type tempering_c = __c;
      static constexpr size_t tempering_l = __l;
      static constexpr result_type initialization_multiplier = __f;
      static constexpr result_type default_seed = 5489u;



      mersenne_twister_engine() : mersenne_twister_engine(default_seed) { }

      explicit
      mersenne_twister_engine(result_type __sd)
      { seed(__sd); }







      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
        explicit
        mersenne_twister_engine(_Sseq& __q)
        { seed(__q); }

      void
      seed(result_type __sd = default_seed);

      template<typename _Sseq>
        _If_seed_seq<_Sseq>
        seed(_Sseq& __q);




      static constexpr result_type
      min()
      { return 0; }




      static constexpr result_type
      max()
      { return __detail::_Shift<_UIntType, __w>::__value - 1; }




      void
      discard(unsigned long long __z);

      result_type
      operator()();
# 590 "/usr/include/c++/10/bits/random.h" 3
      friend bool
      operator==(const mersenne_twister_engine& __lhs,
   const mersenne_twister_engine& __rhs)
      { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
  && __lhs._M_p == __rhs._M_p); }
# 608 "/usr/include/c++/10/bits/random.h" 3
      template<typename _UIntType1,
        size_t __w1, size_t __n1,
        size_t __m1, size_t __r1,
        _UIntType1 __a1, size_t __u1,
        _UIntType1 __d1, size_t __s1,
        _UIntType1 __b1, size_t __t1,
        _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
        typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
     __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
     __l1, __f1>& __x);
# 634 "/usr/include/c++/10/bits/random.h" 3
      template<typename _UIntType1,
        size_t __w1, size_t __n1,
        size_t __m1, size_t __r1,
        _UIntType1 __a1, size_t __u1,
        _UIntType1 __d1, size_t __s1,
        _UIntType1 __b1, size_t __t1,
        _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
        typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
     __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
     __l1, __f1>& __x);

    private:
      void _M_gen_rand();

      _UIntType _M_x[state_size];
      size_t _M_p;
    };
# 667 "/usr/include/c++/10/bits/random.h" 3
  template<typename _UIntType, size_t __w,
    size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t,
    _UIntType __c, size_t __l, _UIntType __f>
    inline bool
    operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
        __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
        const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
        __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
    { return !(__lhs == __rhs); }
# 695 "/usr/include/c++/10/bits/random.h" 3
  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    class subtract_with_carry_engine
    {
      static_assert(std::is_unsigned<_UIntType>::value,
      "result_type must be an unsigned integral type");
      static_assert(0u < __s && __s < __r,
      "0 < s < r");
      static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
      "template argument substituting __w out of bounds");

      template<typename _Sseq>
 using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
   _Sseq, subtract_with_carry_engine, _UIntType>::value>::type;

    public:

      typedef _UIntType result_type;


      static constexpr size_t word_size = __w;
      static constexpr size_t short_lag = __s;
      static constexpr size_t long_lag = __r;
      static constexpr result_type default_seed = 19780503u;

      subtract_with_carry_engine() : subtract_with_carry_engine(default_seed)
      { }





      explicit
      subtract_with_carry_engine(result_type __sd)
      { seed(__sd); }







      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
        explicit
        subtract_with_carry_engine(_Sseq& __q)
        { seed(__q); }
# 753 "/usr/include/c++/10/bits/random.h" 3
      void
      seed(result_type __sd = default_seed);





      template<typename _Sseq>
 _If_seed_seq<_Sseq>
        seed(_Sseq& __q);





      static constexpr result_type
      min()
      { return 0; }





      static constexpr result_type
      max()
      { return __detail::_Shift<_UIntType, __w>::__value - 1; }




      void
      discard(unsigned long long __z)
      {
 for (; __z != 0ULL; --__z)
   (*this)();
      }




      result_type
      operator()();
# 808 "/usr/include/c++/10/bits/random.h" 3
      friend bool
      operator==(const subtract_with_carry_engine& __lhs,
   const subtract_with_carry_engine& __rhs)
      { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
  && __lhs._M_carry == __rhs._M_carry
  && __lhs._M_p == __rhs._M_p); }
# 827 "/usr/include/c++/10/bits/random.h" 3
      template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
        typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::subtract_with_carry_engine<_UIntType1, __w1,
     __s1, __r1>& __x);
# 846 "/usr/include/c++/10/bits/random.h" 3
      template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
        typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::subtract_with_carry_engine<_UIntType1, __w1,
     __s1, __r1>& __x);

    private:

      _UIntType _M_x[long_lag];
      _UIntType _M_carry;
      size_t _M_p;
    };
# 872 "/usr/include/c++/10/bits/random.h" 3
  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    inline bool
    operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
        __s, __r>& __lhs,
        const std::subtract_with_carry_engine<_UIntType, __w,
        __s, __r>& __rhs)
    { return !(__lhs == __rhs); }
# 887 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RandomNumberEngine, size_t __p, size_t __r>
    class discard_block_engine
    {
      static_assert(1 <= __r && __r <= __p,
      "template argument substituting __r out of bounds");

    public:

      typedef typename _RandomNumberEngine::result_type result_type;

      template<typename _Sseq>
 using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
   _Sseq, discard_block_engine, result_type>::value>::type;


      static constexpr size_t block_size = __p;
      static constexpr size_t used_block = __r;






      discard_block_engine()
      : _M_b(), _M_n(0) { }







      explicit
      discard_block_engine(const _RandomNumberEngine& __rng)
      : _M_b(__rng), _M_n(0) { }







      explicit
      discard_block_engine(_RandomNumberEngine&& __rng)
      : _M_b(std::move(__rng)), _M_n(0) { }







      explicit
      discard_block_engine(result_type __s)
      : _M_b(__s), _M_n(0) { }






      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
        explicit
        discard_block_engine(_Sseq& __q)
 : _M_b(__q), _M_n(0)
        { }





      void
      seed()
      {
 _M_b.seed();
 _M_n = 0;
      }





      void
      seed(result_type __s)
      {
 _M_b.seed(__s);
 _M_n = 0;
      }






      template<typename _Sseq>
        _If_seed_seq<_Sseq>
        seed(_Sseq& __q)
        {
   _M_b.seed(__q);
   _M_n = 0;
 }





      const _RandomNumberEngine&
      base() const noexcept
      { return _M_b; }




      static constexpr result_type
      min()
      { return _RandomNumberEngine::min(); }




      static constexpr result_type
      max()
      { return _RandomNumberEngine::max(); }




      void
      discard(unsigned long long __z)
      {
 for (; __z != 0ULL; --__z)
   (*this)();
      }




      result_type
      operator()();
# 1038 "/usr/include/c++/10/bits/random.h" 3
      friend bool
      operator==(const discard_block_engine& __lhs,
   const discard_block_engine& __rhs)
      { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
# 1054 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
        typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::discard_block_engine<_RandomNumberEngine1,
     __p1, __r1>& __x);
# 1072 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
        typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::discard_block_engine<_RandomNumberEngine1,
     __p1, __r1>& __x);

    private:
      _RandomNumberEngine _M_b;
      size_t _M_n;
    };
# 1095 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RandomNumberEngine, size_t __p, size_t __r>
    inline bool
    operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
        __r>& __lhs,
        const std::discard_block_engine<_RandomNumberEngine, __p,
        __r>& __rhs)
    { return !(__lhs == __rhs); }






  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
    class independent_bits_engine
    {
      static_assert(std::is_unsigned<_UIntType>::value,
      "result_type must be an unsigned integral type");
      static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
      "template argument substituting __w out of bounds");

      template<typename _Sseq>
 using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
   _Sseq, independent_bits_engine, _UIntType>::value>::type;

    public:

      typedef _UIntType result_type;






      independent_bits_engine()
      : _M_b() { }







      explicit
      independent_bits_engine(const _RandomNumberEngine& __rng)
      : _M_b(__rng) { }







      explicit
      independent_bits_engine(_RandomNumberEngine&& __rng)
      : _M_b(std::move(__rng)) { }







      explicit
      independent_bits_engine(result_type __s)
      : _M_b(__s) { }






      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
        explicit
        independent_bits_engine(_Sseq& __q)
        : _M_b(__q)
        { }





      void
      seed()
      { _M_b.seed(); }





      void
      seed(result_type __s)
      { _M_b.seed(__s); }






      template<typename _Sseq>
        _If_seed_seq<_Sseq>
        seed(_Sseq& __q)
        { _M_b.seed(__q); }





      const _RandomNumberEngine&
      base() const noexcept
      { return _M_b; }




      static constexpr result_type
      min()
      { return 0U; }




      static constexpr result_type
      max()
      { return __detail::_Shift<_UIntType, __w>::__value - 1; }




      void
      discard(unsigned long long __z)
      {
 for (; __z != 0ULL; --__z)
   (*this)();
      }




      result_type
      operator()();
# 1249 "/usr/include/c++/10/bits/random.h" 3
      friend bool
      operator==(const independent_bits_engine& __lhs,
   const independent_bits_engine& __rhs)
      { return __lhs._M_b == __rhs._M_b; }
# 1266 "/usr/include/c++/10/bits/random.h" 3
      template<typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::independent_bits_engine<_RandomNumberEngine,
     __w, _UIntType>& __x)
 {
   __is >> __x._M_b;
   return __is;
 }

    private:
      _RandomNumberEngine _M_b;
    };
# 1292 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
    inline bool
    operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
        _UIntType>& __lhs,
        const std::independent_bits_engine<_RandomNumberEngine, __w,
        _UIntType>& __rhs)
    { return !(__lhs == __rhs); }
# 1310 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const std::independent_bits_engine<_RandomNumberEngine,
        __w, _UIntType>& __x)
    {
      __os << __x.base();
      return __os;
    }







  template<typename _RandomNumberEngine, size_t __k>
    class shuffle_order_engine
    {
      static_assert(1u <= __k, "template argument substituting "
      "__k out of bound");

    public:

      typedef typename _RandomNumberEngine::result_type result_type;

      template<typename _Sseq>
 using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
   _Sseq, shuffle_order_engine, result_type>::value>::type;

      static constexpr size_t table_size = __k;






      shuffle_order_engine()
      : _M_b()
      { _M_initialize(); }







      explicit
      shuffle_order_engine(const _RandomNumberEngine& __rng)
      : _M_b(__rng)
      { _M_initialize(); }







      explicit
      shuffle_order_engine(_RandomNumberEngine&& __rng)
      : _M_b(std::move(__rng))
      { _M_initialize(); }







      explicit
      shuffle_order_engine(result_type __s)
      : _M_b(__s)
      { _M_initialize(); }






      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
        explicit
        shuffle_order_engine(_Sseq& __q)
        : _M_b(__q)
        { _M_initialize(); }





      void
      seed()
      {
 _M_b.seed();
 _M_initialize();
      }





      void
      seed(result_type __s)
      {
 _M_b.seed(__s);
 _M_initialize();
      }






      template<typename _Sseq>
        _If_seed_seq<_Sseq>
        seed(_Sseq& __q)
        {
   _M_b.seed(__q);
   _M_initialize();
 }




      const _RandomNumberEngine&
      base() const noexcept
      { return _M_b; }




      static constexpr result_type
      min()
      { return _RandomNumberEngine::min(); }




      static constexpr result_type
      max()
      { return _RandomNumberEngine::max(); }




      void
      discard(unsigned long long __z)
      {
 for (; __z != 0ULL; --__z)
   (*this)();
      }




      result_type
      operator()();
# 1479 "/usr/include/c++/10/bits/random.h" 3
      friend bool
      operator==(const shuffle_order_engine& __lhs,
   const shuffle_order_engine& __rhs)
      { return (__lhs._M_b == __rhs._M_b
  && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
  && __lhs._M_y == __rhs._M_y); }
# 1497 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RandomNumberEngine1, size_t __k1,
        typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::shuffle_order_engine<_RandomNumberEngine1,
     __k1>& __x);
# 1515 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RandomNumberEngine1, size_t __k1,
        typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);

    private:
      void _M_initialize()
      {
 for (size_t __i = 0; __i < __k; ++__i)
   _M_v[__i] = _M_b();
 _M_y = _M_b();
      }

      _RandomNumberEngine _M_b;
      result_type _M_v[__k];
      result_type _M_y;
    };
# 1545 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RandomNumberEngine, size_t __k>
    inline bool
    operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
        __k>& __lhs,
        const std::shuffle_order_engine<_RandomNumberEngine,
        __k>& __rhs)
    { return !(__lhs == __rhs); }





  typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
  minstd_rand0;




  typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
  minstd_rand;
# 1574 "/usr/include/c++/10/bits/random.h" 3
  typedef mersenne_twister_engine<
    uint_fast32_t,
    32, 624, 397, 31,
    0x9908b0dfUL, 11,
    0xffffffffUL, 7,
    0x9d2c5680UL, 15,
    0xefc60000UL, 18, 1812433253UL> mt19937;




  typedef mersenne_twister_engine<
    uint_fast64_t,
    64, 312, 156, 31,
    0xb5026f5aa96619e9ULL, 29,
    0x5555555555555555ULL, 17,
    0x71d67fffeda60000ULL, 37,
    0xfff7eee000000000ULL, 43,
    6364136223846793005ULL> mt19937_64;

  typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
    ranlux24_base;

  typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
    ranlux48_base;

  typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;

  typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;

  typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;

  typedef minstd_rand0 default_random_engine;





  class random_device
  {
  public:

    typedef unsigned int result_type;



    random_device() { _M_init("default"); }

    explicit
    random_device(const std::string& __token) { _M_init(__token); }


    ~random_device()
    { _M_fini(); }


    static constexpr result_type
    min()
    { return std::numeric_limits<result_type>::min(); }

    static constexpr result_type
    max()
    { return std::numeric_limits<result_type>::max(); }

    double
    entropy() const noexcept
    {

      return this->_M_getentropy();



    }

    result_type
    operator()()
    { return this->_M_getval(); }


    random_device(const random_device&) = delete;
    void operator=(const random_device&) = delete;

  private:

    void _M_init(const std::string& __token);
    void _M_init_pretr1(const std::string& __token);
    void _M_fini();

    result_type _M_getval();
    result_type _M_getval_pretr1();
    double _M_getentropy() const noexcept;

    void _M_init(const char*, size_t);

    union
    {
      struct
      {
 void* _M_file;
 result_type (*_M_func)(void*);
 int _M_fd;
      };
      mt19937 _M_mt;
    };
  };
# 1700 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType>
    inline bool
    operator!=(const std::uniform_int_distribution<_IntType>& __d1,
        const std::uniform_int_distribution<_IntType>& __d2)
    { return !(__d1 == __d2); }
# 1716 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>&,
        const std::uniform_int_distribution<_IntType>&);
# 1730 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>&,
        std::uniform_int_distribution<_IntType>&);
# 1743 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class uniform_real_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef uniform_real_distribution<_RealType> distribution_type;

 param_type() : param_type(0) { }

 explicit
 param_type(_RealType __a, _RealType __b = _RealType(1))
 : _M_a(__a), _M_b(__b)
 {
   do { if (! (_M_a <= _M_b)) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 1764, __PRETTY_FUNCTION__, "_M_a <= _M_b"); } 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:
 _RealType _M_a;
 _RealType _M_b;
      };

    public:





      uniform_real_distribution() : uniform_real_distribution(0.0) { }







      explicit
      uniform_real_distribution(_RealType __a, _RealType __b = _RealType(1))
      : _M_param(__a, __b)
      { }

      explicit
      uniform_real_distribution(const param_type& __p)
      : _M_param(__p)
      { }






      void
      reset() { }

      result_type
      a() const
      { return _M_param.a(); }

      result_type
      b() const
      { return _M_param.b(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return this->a(); }




      result_type
      max() const
      { return this->b(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
        { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 {
   __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
     __aurng(__urng);
   return (__aurng() * (__p.b() - __p.a())) + __p.a();
 }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const uniform_real_distribution& __d1,
   const uniform_real_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _IntType>
    inline bool
    operator!=(const std::uniform_real_distribution<_IntType>& __d1,
        const std::uniform_real_distribution<_IntType>& __d2)
    { return !(__d1 == __d2); }
# 1937 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>&,
        const std::uniform_real_distribution<_RealType>&);
# 1951 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>&,
        std::uniform_real_distribution<_RealType>&);
# 1973 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class normal_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef normal_distribution<_RealType> distribution_type;

 param_type() : param_type(0.0) { }

 explicit
 param_type(_RealType __mean, _RealType __stddev = _RealType(1))
 : _M_mean(__mean), _M_stddev(__stddev)
 {
   do { if (! (_M_stddev > _RealType(0))) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 1994, __PRETTY_FUNCTION__, "_M_stddev > _RealType(0)"); } while (false);
 }

 _RealType
 mean() const
 { return _M_mean; }

 _RealType
 stddev() const
 { return _M_stddev; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return (__p1._M_mean == __p2._M_mean
    && __p1._M_stddev == __p2._M_stddev); }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_mean;
 _RealType _M_stddev;
      };

    public:
      normal_distribution() : normal_distribution(0.0) { }





      explicit
      normal_distribution(result_type __mean,
     result_type __stddev = result_type(1))
      : _M_param(__mean, __stddev), _M_saved_available(false)
      { }

      explicit
      normal_distribution(const param_type& __p)
      : _M_param(__p), _M_saved_available(false)
      { }




      void
      reset()
      { _M_saved_available = false; }




      _RealType
      mean() const
      { return _M_param.mean(); }




      _RealType
      stddev() const
      { return _M_param.stddev(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return std::numeric_limits<result_type>::lowest(); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






      template<typename _RealType1>
 friend bool
        operator==(const std::normal_distribution<_RealType1>& __d1,
     const std::normal_distribution<_RealType1>& __d2);
# 2142 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::normal_distribution<_RealType1>& __x);
# 2157 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::normal_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
      result_type _M_saved;
      bool _M_saved_available;
    };




  template<typename _RealType>
    inline bool
    operator!=(const std::normal_distribution<_RealType>& __d1,
        const std::normal_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 2194 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class lognormal_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef lognormal_distribution<_RealType> distribution_type;

 param_type() : param_type(0.0) { }

 explicit
 param_type(_RealType __m, _RealType __s = _RealType(1))
 : _M_m(__m), _M_s(__s)
 { }

 _RealType
 m() const
 { return _M_m; }

 _RealType
 s() const
 { return _M_s; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_m;
 _RealType _M_s;
      };

      lognormal_distribution() : lognormal_distribution(0.0) { }

      explicit
      lognormal_distribution(_RealType __m, _RealType __s = _RealType(1))
      : _M_param(__m, __s), _M_nd()
      { }

      explicit
      lognormal_distribution(const param_type& __p)
      : _M_param(__p), _M_nd()
      { }




      void
      reset()
      { _M_nd.reset(); }




      _RealType
      m() const
      { return _M_param.m(); }

      _RealType
      s() const
      { return _M_param.s(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
        { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p)
        { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






      friend bool
      operator==(const lognormal_distribution& __d1,
   const lognormal_distribution& __d2)
      { return (__d1._M_param == __d2._M_param
  && __d1._M_nd == __d2._M_nd); }
# 2353 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::lognormal_distribution<_RealType1>& __x);
# 2368 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::lognormal_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;

      std::normal_distribution<result_type> _M_nd;
    };




  template<typename _RealType>
    inline bool
    operator!=(const std::lognormal_distribution<_RealType>& __d1,
        const std::lognormal_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 2405 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class gamma_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef gamma_distribution<_RealType> distribution_type;
 friend class gamma_distribution<_RealType>;

 param_type() : param_type(1.0) { }

 explicit
 param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1))
 : _M_alpha(__alpha_val), _M_beta(__beta_val)
 {
   do { if (! (_M_alpha > _RealType(0))) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 2427, __PRETTY_FUNCTION__, "_M_alpha > _RealType(0)"); } while (false);
   _M_initialize();
 }

 _RealType
 alpha() const
 { return _M_alpha; }

 _RealType
 beta() const
 { return _M_beta; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return (__p1._M_alpha == __p2._M_alpha
    && __p1._M_beta == __p2._M_beta); }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 void
 _M_initialize();

 _RealType _M_alpha;
 _RealType _M_beta;

 _RealType _M_malpha, _M_a2;
      };

    public:



      gamma_distribution() : gamma_distribution(1.0) { }





      explicit
      gamma_distribution(_RealType __alpha_val,
    _RealType __beta_val = _RealType(1))
      : _M_param(__alpha_val, __beta_val), _M_nd()
      { }

      explicit
      gamma_distribution(const param_type& __p)
      : _M_param(__p), _M_nd()
      { }




      void
      reset()
      { _M_nd.reset(); }




      _RealType
      alpha() const
      { return _M_param.alpha(); }




      _RealType
      beta() const
      { return _M_param.beta(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






      friend bool
      operator==(const gamma_distribution& __d1,
   const gamma_distribution& __d2)
      { return (__d1._M_param == __d2._M_param
  && __d1._M_nd == __d2._M_nd); }
# 2585 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::gamma_distribution<_RealType1>& __x);
# 2599 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::gamma_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;

      std::normal_distribution<result_type> _M_nd;
    };




   template<typename _RealType>
     inline bool
     operator!=(const std::gamma_distribution<_RealType>& __d1,
  const std::gamma_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 2633 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class chi_squared_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef chi_squared_distribution<_RealType> distribution_type;

 param_type() : param_type(1) { }

 explicit
 param_type(_RealType __n)
 : _M_n(__n)
 { }

 _RealType
 n() const
 { return _M_n; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_n == __p2._M_n; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_n;
      };

      chi_squared_distribution() : chi_squared_distribution(1) { }

      explicit
      chi_squared_distribution(_RealType __n)
      : _M_param(__n), _M_gd(__n / 2)
      { }

      explicit
      chi_squared_distribution(const param_type& __p)
      : _M_param(__p), _M_gd(__p.n() / 2)
      { }




      void
      reset()
      { _M_gd.reset(); }




      _RealType
      n() const
      { return _M_param.n(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      {
 _M_param = __param;
 typedef typename std::gamma_distribution<result_type>::param_type
   param_type;
 _M_gd.param(param_type{__param.n() / 2});
      }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return 2 * _M_gd(__urng); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p)
        {
   typedef typename std::gamma_distribution<result_type>::param_type
     param_type;
   return 2 * _M_gd(__urng, param_type(__p.n() / 2));
 }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
        { this->__generate_impl(__f, __t, __urng); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { typename std::gamma_distribution<result_type>::param_type
     __p2(__p.n() / 2);
   this->__generate_impl(__f, __t, __urng, __p2); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng)
        { this->__generate_impl(__f, __t, __urng); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { typename std::gamma_distribution<result_type>::param_type
     __p2(__p.n() / 2);
   this->__generate_impl(__f, __t, __urng, __p2); }






      friend bool
      operator==(const chi_squared_distribution& __d1,
   const chi_squared_distribution& __d2)
      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
# 2801 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::chi_squared_distribution<_RealType1>& __x);
# 2816 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::chi_squared_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const typename
   std::gamma_distribution<result_type>::param_type& __p);

      param_type _M_param;

      std::gamma_distribution<result_type> _M_gd;
    };




  template<typename _RealType>
    inline bool
    operator!=(const std::chi_squared_distribution<_RealType>& __d1,
        const std::chi_squared_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 2857 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class cauchy_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef cauchy_distribution<_RealType> distribution_type;

 param_type() : param_type(0) { }

 explicit
 param_type(_RealType __a, _RealType __b = _RealType(1))
 : _M_a(__a), _M_b(__b)
 { }

 _RealType
 a() const
 { return _M_a; }

 _RealType
 b() const
 { return _M_b; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_a;
 _RealType _M_b;
      };

      cauchy_distribution() : cauchy_distribution(0.0) { }

      explicit
      cauchy_distribution(_RealType __a, _RealType __b = 1.0)
      : _M_param(__a, __b)
      { }

      explicit
      cauchy_distribution(const param_type& __p)
      : _M_param(__p)
      { }




      void
      reset()
      { }




      _RealType
      a() const
      { return _M_param.a(); }

      _RealType
      b() const
      { return _M_param.b(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return std::numeric_limits<result_type>::lowest(); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const cauchy_distribution& __d1,
   const cauchy_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _RealType>
    inline bool
    operator!=(const std::cauchy_distribution<_RealType>& __d1,
        const std::cauchy_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 3034 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const std::cauchy_distribution<_RealType>& __x);
# 3049 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        std::cauchy_distribution<_RealType>& __x);
# 3065 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class fisher_f_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef fisher_f_distribution<_RealType> distribution_type;

 param_type() : param_type(1) { }

 explicit
 param_type(_RealType __m, _RealType __n = _RealType(1))
 : _M_m(__m), _M_n(__n)
 { }

 _RealType
 m() const
 { return _M_m; }

 _RealType
 n() const
 { return _M_n; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_m;
 _RealType _M_n;
      };

      fisher_f_distribution() : fisher_f_distribution(1.0) { }

      explicit
      fisher_f_distribution(_RealType __m,
       _RealType __n = _RealType(1))
      : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
      { }

      explicit
      fisher_f_distribution(const param_type& __p)
      : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
      { }




      void
      reset()
      {
 _M_gd_x.reset();
 _M_gd_y.reset();
      }




      _RealType
      m() const
      { return _M_param.m(); }

      _RealType
      n() const
      { return _M_param.n(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p)
        {
   typedef typename std::gamma_distribution<result_type>::param_type
     param_type;
   return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
    / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
 }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate_impl(__f, __t, __urng); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate_impl(__f, __t, __urng); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






      friend bool
      operator==(const fisher_f_distribution& __d1,
   const fisher_f_distribution& __d2)
      { return (__d1._M_param == __d2._M_param
  && __d1._M_gd_x == __d2._M_gd_x
  && __d1._M_gd_y == __d2._M_gd_y); }
# 3240 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::fisher_f_distribution<_RealType1>& __x);
# 3255 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::fisher_f_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;

      std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
    };




  template<typename _RealType>
    inline bool
    operator!=(const std::fisher_f_distribution<_RealType>& __d1,
        const std::fisher_f_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 3297 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class student_t_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef student_t_distribution<_RealType> distribution_type;

 param_type() : param_type(1) { }

 explicit
 param_type(_RealType __n)
 : _M_n(__n)
 { }

 _RealType
 n() const
 { return _M_n; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_n == __p2._M_n; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_n;
      };

      student_t_distribution() : student_t_distribution(1.0) { }

      explicit
      student_t_distribution(_RealType __n)
      : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
      { }

      explicit
      student_t_distribution(const param_type& __p)
      : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
      { }




      void
      reset()
      {
 _M_nd.reset();
 _M_gd.reset();
      }




      _RealType
      n() const
      { return _M_param.n(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return std::numeric_limits<result_type>::lowest(); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
        operator()(_UniformRandomNumberGenerator& __urng)
        { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p)
        {
   typedef typename std::gamma_distribution<result_type>::param_type
     param_type;

   const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
   return _M_nd(__urng) * std::sqrt(__p.n() / __g);
        }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate_impl(__f, __t, __urng); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate_impl(__f, __t, __urng); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






      friend bool
      operator==(const student_t_distribution& __d1,
   const student_t_distribution& __d2)
      { return (__d1._M_param == __d2._M_param
  && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
# 3462 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::student_t_distribution<_RealType1>& __x);
# 3477 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::student_t_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng);
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;

      std::normal_distribution<result_type> _M_nd;
      std::gamma_distribution<result_type> _M_gd;
    };




  template<typename _RealType>
    inline bool
    operator!=(const std::student_t_distribution<_RealType>& __d1,
        const std::student_t_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 3525 "/usr/include/c++/10/bits/random.h" 3
  class bernoulli_distribution
  {
  public:

    typedef bool result_type;


    struct param_type
    {
      typedef bernoulli_distribution distribution_type;

      param_type() : param_type(0.5) { }

      explicit
      param_type(double __p)
      : _M_p(__p)
      {
 do { if (! ((_M_p >= 0.0) && (_M_p <= 1.0))) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 3542, __PRETTY_FUNCTION__, "(_M_p >= 0.0) && (_M_p <= 1.0)"); } while (false);
      }

      double
      p() const
      { return _M_p; }

      friend bool
      operator==(const param_type& __p1, const param_type& __p2)
      { return __p1._M_p == __p2._M_p; }

      friend bool
      operator!=(const param_type& __p1, const param_type& __p2)
      { return !(__p1 == __p2); }

    private:
      double _M_p;
    };

  public:



    bernoulli_distribution() : bernoulli_distribution(0.5) { }







    explicit
    bernoulli_distribution(double __p)
    : _M_param(__p)
    { }

    explicit
    bernoulli_distribution(const param_type& __p)
    : _M_param(__p)
    { }






    void
    reset() { }




    double
    p() const
    { return _M_param.p(); }




    param_type
    param() const
    { return _M_param; }





    void
    param(const param_type& __param)
    { _M_param = __param; }




    result_type
    min() const
    { return std::numeric_limits<result_type>::min(); }




    result_type
    max() const
    { return std::numeric_limits<result_type>::max(); }




    template<typename _UniformRandomNumberGenerator>
      result_type
      operator()(_UniformRandomNumberGenerator& __urng)
      { return this->operator()(__urng, _M_param); }

    template<typename _UniformRandomNumberGenerator>
      result_type
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __p)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);
 if ((__aurng() - __aurng.min())
      < __p.p() * (__aurng.max() - __aurng.min()))
   return true;
 return false;
      }

    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      __generate(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng)
      { this->__generate(__f, __t, __urng, _M_param); }

    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      __generate(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng, const param_type& __p)
      { this->__generate_impl(__f, __t, __urng, __p); }

    template<typename _UniformRandomNumberGenerator>
      void
      __generate(result_type* __f, result_type* __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p)
      { this->__generate_impl(__f, __t, __urng, __p); }





    friend bool
    operator==(const bernoulli_distribution& __d1,
        const bernoulli_distribution& __d2)
    { return __d1._M_param == __d2._M_param; }

  private:
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p);

    param_type _M_param;
  };





  inline bool
  operator!=(const std::bernoulli_distribution& __d1,
      const std::bernoulli_distribution& __d2)
  { return !(__d1 == __d2); }
# 3708 "/usr/include/c++/10/bits/random.h" 3
  template<typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const std::bernoulli_distribution& __x);
# 3722 "/usr/include/c++/10/bits/random.h" 3
  template<typename _CharT, typename _Traits>
    inline std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        std::bernoulli_distribution& __x)
    {
      double __p;
      if (__is >> __p)
 __x.param(bernoulli_distribution::param_type(__p));
      return __is;
    }
# 3741 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType = int>
    class binomial_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "result_type must be an integral type");

    public:

      typedef _IntType result_type;


      struct param_type
      {
 typedef binomial_distribution<_IntType> distribution_type;
 friend class binomial_distribution<_IntType>;

 param_type() : param_type(1) { }

 explicit
 param_type(_IntType __t, double __p = 0.5)
 : _M_t(__t), _M_p(__p)
 {
   do { if (! ((_M_t >= _IntType(0)) && (_M_p >= 0.0) && (_M_p <= 1.0))) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 3763, __PRETTY_FUNCTION__, "(_M_t >= _IntType(0)) && (_M_p >= 0.0) && (_M_p <= 1.0)"); } while (false)

                     ;
   _M_initialize();
 }

 _IntType
 t() const
 { return _M_t; }

 double
 p() const
 { return _M_p; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 void
 _M_initialize();

 _IntType _M_t;
 double _M_p;

 double _M_q;

 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
        _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;

 bool _M_easy;
      };



      binomial_distribution() : binomial_distribution(1) { }

      explicit
      binomial_distribution(_IntType __t, double __p = 0.5)
      : _M_param(__t, __p), _M_nd()
      { }

      explicit
      binomial_distribution(const param_type& __p)
      : _M_param(__p), _M_nd()
      { }




      void
      reset()
      { _M_nd.reset(); }




      _IntType
      t() const
      { return _M_param.t(); }




      double
      p() const
      { return _M_param.p(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return 0; }




      result_type
      max() const
      { return _M_param.t(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






 friend bool
        operator==(const binomial_distribution& __d1,
     const binomial_distribution& __d2)

 { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
# 3923 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1,
        typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::binomial_distribution<_IntType1>& __x);
# 3939 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1,
        typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::binomial_distribution<_IntType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      template<typename _UniformRandomNumberGenerator>
 result_type
 _M_waiting(_UniformRandomNumberGenerator& __urng,
     _IntType __t, double __q);

      param_type _M_param;


      std::normal_distribution<double> _M_nd;
    };




  template<typename _IntType>
    inline bool
    operator!=(const std::binomial_distribution<_IntType>& __d1,
        const std::binomial_distribution<_IntType>& __d2)
    { return !(__d1 == __d2); }
# 3981 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType = int>
    class geometric_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "result_type must be an integral type");

    public:

      typedef _IntType result_type;


      struct param_type
      {
 typedef geometric_distribution<_IntType> distribution_type;
 friend class geometric_distribution<_IntType>;

 param_type() : param_type(0.5) { }

 explicit
 param_type(double __p)
 : _M_p(__p)
 {
   do { if (! ((_M_p > 0.0) && (_M_p < 1.0))) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 4003, __PRETTY_FUNCTION__, "(_M_p > 0.0) && (_M_p < 1.0)"); } while (false);
   _M_initialize();
 }

 double
 p() const
 { return _M_p; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_p == __p2._M_p; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 void
 _M_initialize()
 { _M_log_1_p = std::log(1.0 - _M_p); }

 double _M_p;

 double _M_log_1_p;
      };



      geometric_distribution() : geometric_distribution(0.5) { }

      explicit
      geometric_distribution(double __p)
      : _M_param(__p)
      { }

      explicit
      geometric_distribution(const param_type& __p)
      : _M_param(__p)
      { }






      void
      reset() { }




      double
      p() const
      { return _M_param.p(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return 0; }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const geometric_distribution& __d1,
   const geometric_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _IntType>
    inline bool
    operator!=(const std::geometric_distribution<_IntType>& __d1,
        const std::geometric_distribution<_IntType>& __d2)
    { return !(__d1 == __d2); }
# 4162 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const std::geometric_distribution<_IntType>& __x);
# 4177 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        std::geometric_distribution<_IntType>& __x);
# 4191 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType = int>
    class negative_binomial_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "result_type must be an integral type");

    public:

      typedef _IntType result_type;


      struct param_type
      {
 typedef negative_binomial_distribution<_IntType> distribution_type;

 param_type() : param_type(1) { }

 explicit
 param_type(_IntType __k, double __p = 0.5)
 : _M_k(__k), _M_p(__p)
 {
   do { if (! ((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0))) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 4212, __PRETTY_FUNCTION__, "(_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0)"); } while (false);
 }

 _IntType
 k() const
 { return _M_k; }

 double
 p() const
 { return _M_p; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _IntType _M_k;
 double _M_p;
      };

      negative_binomial_distribution() : negative_binomial_distribution(1) { }

      explicit
      negative_binomial_distribution(_IntType __k, double __p = 0.5)
      : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
      { }

      explicit
      negative_binomial_distribution(const param_type& __p)
      : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
      { }




      void
      reset()
      { _M_gd.reset(); }




      _IntType
      k() const
      { return _M_param.k(); }




      double
      p() const
      { return _M_param.p(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
        operator()(_UniformRandomNumberGenerator& __urng);

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate_impl(__f, __t, __urng); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate_impl(__f, __t, __urng); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






      friend bool
      operator==(const negative_binomial_distribution& __d1,
   const negative_binomial_distribution& __d2)
      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
# 4359 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::negative_binomial_distribution<_IntType1>& __x);
# 4374 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::negative_binomial_distribution<_IntType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng);
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;

      std::gamma_distribution<double> _M_gd;
    };




  template<typename _IntType>
    inline bool
    operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
        const std::negative_binomial_distribution<_IntType>& __d2)
    { return !(__d1 == __d2); }
# 4422 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType = int>
    class poisson_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "result_type must be an integral type");

    public:

      typedef _IntType result_type;


      struct param_type
      {
 typedef poisson_distribution<_IntType> distribution_type;
 friend class poisson_distribution<_IntType>;

 param_type() : param_type(1.0) { }

 explicit
 param_type(double __mean)
 : _M_mean(__mean)
 {
   do { if (! (_M_mean > 0.0)) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 4444, __PRETTY_FUNCTION__, "_M_mean > 0.0"); } while (false);
   _M_initialize();
 }

 double
 mean() const
 { return _M_mean; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_mean == __p2._M_mean; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:

 void
 _M_initialize();

 double _M_mean;

 double _M_lm_thr;

 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;

      };



      poisson_distribution() : poisson_distribution(1.0) { }

      explicit
      poisson_distribution(double __mean)
      : _M_param(__mean), _M_nd()
      { }

      explicit
      poisson_distribution(const param_type& __p)
      : _M_param(__p), _M_nd()
      { }




      void
      reset()
      { _M_nd.reset(); }




      double
      mean() const
      { return _M_param.mean(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return 0; }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }






      friend bool
      operator==(const poisson_distribution& __d1,
   const poisson_distribution& __d2)

      { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
# 4589 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::poisson_distribution<_IntType1>& __x);
# 4604 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::poisson_distribution<_IntType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;


      std::normal_distribution<double> _M_nd;
    };




  template<typename _IntType>
    inline bool
    operator!=(const std::poisson_distribution<_IntType>& __d1,
        const std::poisson_distribution<_IntType>& __d2)
    { return !(__d1 == __d2); }
# 4648 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class exponential_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef exponential_distribution<_RealType> distribution_type;

 param_type() : param_type(1.0) { }

 explicit
 param_type(_RealType __lambda)
 : _M_lambda(__lambda)
 {
   do { if (! (_M_lambda > _RealType(0))) std::__replacement_assert("/usr/include/c++/10/bits/random.h", 4669, __PRETTY_FUNCTION__, "_M_lambda > _RealType(0)"); } while (false);
 }

 _RealType
 lambda() const
 { return _M_lambda; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_lambda == __p2._M_lambda; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_lambda;
      };

    public:




      exponential_distribution() : exponential_distribution(1.0) { }





      explicit
      exponential_distribution(_RealType __lambda)
      : _M_param(__lambda)
      { }

      explicit
      exponential_distribution(const param_type& __p)
      : _M_param(__p)
      { }






      void
      reset() { }




      _RealType
      lambda() const
      { return _M_param.lambda(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
        { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 {
   __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
     __aurng(__urng);
   return -std::log(result_type(1) - __aurng()) / __p.lambda();
 }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const exponential_distribution& __d1,
   const exponential_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _RealType>
    inline bool
    operator!=(const std::exponential_distribution<_RealType>& __d1,
        const std::exponential_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 4833 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const std::exponential_distribution<_RealType>& __x);
# 4848 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        std::exponential_distribution<_RealType>& __x);
# 4863 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class weibull_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef weibull_distribution<_RealType> distribution_type;

 param_type() : param_type(1.0) { }

 explicit
 param_type(_RealType __a, _RealType __b = _RealType(1.0))
 : _M_a(__a), _M_b(__b)
 { }

 _RealType
 a() const
 { return _M_a; }

 _RealType
 b() const
 { return _M_b; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_a;
 _RealType _M_b;
      };

      weibull_distribution() : weibull_distribution(1.0) { }

      explicit
      weibull_distribution(_RealType __a, _RealType __b = _RealType(1))
      : _M_param(__a, __b)
      { }

      explicit
      weibull_distribution(const param_type& __p)
      : _M_param(__p)
      { }




      void
      reset()
      { }




      _RealType
      a() const
      { return _M_param.a(); }




      _RealType
      b() const
      { return _M_param.b(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const weibull_distribution& __d1,
   const weibull_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _RealType>
    inline bool
    operator!=(const std::weibull_distribution<_RealType>& __d1,
        const std::weibull_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 5043 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const std::weibull_distribution<_RealType>& __x);
# 5058 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        std::weibull_distribution<_RealType>& __x);
# 5073 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class extreme_value_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef extreme_value_distribution<_RealType> distribution_type;

 param_type() : param_type(0.0) { }

 explicit
 param_type(_RealType __a, _RealType __b = _RealType(1.0))
 : _M_a(__a), _M_b(__b)
 { }

 _RealType
 a() const
 { return _M_a; }

 _RealType
 b() const
 { return _M_b; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _RealType _M_a;
 _RealType _M_b;
      };

      extreme_value_distribution() : extreme_value_distribution(0.0) { }

      explicit
      extreme_value_distribution(_RealType __a, _RealType __b = _RealType(1))
      : _M_param(__a, __b)
      { }

      explicit
      extreme_value_distribution(const param_type& __p)
      : _M_param(__p)
      { }




      void
      reset()
      { }




      _RealType
      a() const
      { return _M_param.a(); }




      _RealType
      b() const
      { return _M_param.b(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return std::numeric_limits<result_type>::lowest(); }




      result_type
      max() const
      { return std::numeric_limits<result_type>::max(); }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const extreme_value_distribution& __d1,
   const extreme_value_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _RealType>
    inline bool
    operator!=(const std::extreme_value_distribution<_RealType>& __d1,
        const std::extreme_value_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 5253 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const std::extreme_value_distribution<_RealType>& __x);
# 5268 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        std::extreme_value_distribution<_RealType>& __x);
# 5280 "/usr/include/c++/10/bits/random.h" 3
  template<typename _IntType = int>
    class discrete_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "result_type must be an integral type");

    public:

      typedef _IntType result_type;


      struct param_type
      {
 typedef discrete_distribution<_IntType> distribution_type;
 friend class discrete_distribution<_IntType>;

 param_type()
 : _M_prob(), _M_cp()
 { }

 template<typename _InputIterator>
   param_type(_InputIterator __wbegin,
       _InputIterator __wend)
   : _M_prob(__wbegin, __wend), _M_cp()
   { _M_initialize(); }

 param_type(initializer_list<double> __wil)
 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
 { _M_initialize(); }

 template<typename _Func>
   param_type(size_t __nw, double __xmin, double __xmax,
       _Func __fw);


 param_type(const param_type&) = default;
 param_type& operator=(const param_type&) = default;

 std::vector<double>
 probabilities() const
 { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_prob == __p2._M_prob; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 void
 _M_initialize();

 std::vector<double> _M_prob;
 std::vector<double> _M_cp;
      };

      discrete_distribution()
      : _M_param()
      { }

      template<typename _InputIterator>
 discrete_distribution(_InputIterator __wbegin,
         _InputIterator __wend)
 : _M_param(__wbegin, __wend)
 { }

      discrete_distribution(initializer_list<double> __wl)
      : _M_param(__wl)
      { }

      template<typename _Func>
 discrete_distribution(size_t __nw, double __xmin, double __xmax,
         _Func __fw)
 : _M_param(__nw, __xmin, __xmax, __fw)
 { }

      explicit
      discrete_distribution(const param_type& __p)
      : _M_param(__p)
      { }




      void
      reset()
      { }




      std::vector<double>
      probabilities() const
      {
 return _M_param._M_prob.empty()
   ? std::vector<double>(1, 1.0) : _M_param._M_prob;
      }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return result_type(0); }




      result_type
      max() const
      {
 return _M_param._M_prob.empty()
   ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
      }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const discrete_distribution& __d1,
   const discrete_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }
# 5466 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::discrete_distribution<_IntType1>& __x);
# 5482 "/usr/include/c++/10/bits/random.h" 3
      template<typename _IntType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::discrete_distribution<_IntType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _IntType>
    inline bool
    operator!=(const std::discrete_distribution<_IntType>& __d1,
        const std::discrete_distribution<_IntType>& __d2)
    { return !(__d1 == __d2); }
# 5515 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class piecewise_constant_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef piecewise_constant_distribution<_RealType> distribution_type;
 friend class piecewise_constant_distribution<_RealType>;

 param_type()
 : _M_int(), _M_den(), _M_cp()
 { }

 template<typename _InputIteratorB, typename _InputIteratorW>
   param_type(_InputIteratorB __bfirst,
       _InputIteratorB __bend,
       _InputIteratorW __wbegin);

 template<typename _Func>
   param_type(initializer_list<_RealType> __bi, _Func __fw);

 template<typename _Func>
   param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
       _Func __fw);


 param_type(const param_type&) = default;
 param_type& operator=(const param_type&) = default;

 std::vector<_RealType>
 intervals() const
 {
   if (_M_int.empty())
     {
       std::vector<_RealType> __tmp(2);
       __tmp[1] = _RealType(1);
       return __tmp;
     }
   else
     return _M_int;
 }

 std::vector<double>
 densities() const
 { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 void
 _M_initialize();

 std::vector<_RealType> _M_int;
 std::vector<double> _M_den;
 std::vector<double> _M_cp;
      };

      piecewise_constant_distribution()
      : _M_param()
      { }

      template<typename _InputIteratorB, typename _InputIteratorW>
 piecewise_constant_distribution(_InputIteratorB __bfirst,
     _InputIteratorB __bend,
     _InputIteratorW __wbegin)
 : _M_param(__bfirst, __bend, __wbegin)
 { }

      template<typename _Func>
 piecewise_constant_distribution(initializer_list<_RealType> __bl,
     _Func __fw)
 : _M_param(__bl, __fw)
 { }

      template<typename _Func>
 piecewise_constant_distribution(size_t __nw,
     _RealType __xmin, _RealType __xmax,
     _Func __fw)
 : _M_param(__nw, __xmin, __xmax, __fw)
 { }

      explicit
      piecewise_constant_distribution(const param_type& __p)
      : _M_param(__p)
      { }




      void
      reset()
      { }




      std::vector<_RealType>
      intervals() const
      {
 if (_M_param._M_int.empty())
   {
     std::vector<_RealType> __tmp(2);
     __tmp[1] = _RealType(1);
     return __tmp;
   }
 else
   return _M_param._M_int;
      }




      std::vector<double>
      densities() const
      {
 return _M_param._M_den.empty()
   ? std::vector<double>(1, 1.0) : _M_param._M_den;
      }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      {
 return _M_param._M_int.empty()
   ? result_type(0) : _M_param._M_int.front();
      }




      result_type
      max() const
      {
 return _M_param._M_int.empty()
   ? result_type(1) : _M_param._M_int.back();
      }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const piecewise_constant_distribution& __d1,
   const piecewise_constant_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }
# 5737 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::piecewise_constant_distribution<_RealType1>& __x);
# 5753 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::piecewise_constant_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _RealType>
    inline bool
    operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
        const std::piecewise_constant_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 5786 "/usr/include/c++/10/bits/random.h" 3
  template<typename _RealType = double>
    class piecewise_linear_distribution
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "result_type must be a floating point type");

    public:

      typedef _RealType result_type;


      struct param_type
      {
 typedef piecewise_linear_distribution<_RealType> distribution_type;
 friend class piecewise_linear_distribution<_RealType>;

 param_type()
 : _M_int(), _M_den(), _M_cp(), _M_m()
 { }

 template<typename _InputIteratorB, typename _InputIteratorW>
   param_type(_InputIteratorB __bfirst,
       _InputIteratorB __bend,
       _InputIteratorW __wbegin);

 template<typename _Func>
   param_type(initializer_list<_RealType> __bl, _Func __fw);

 template<typename _Func>
   param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
       _Func __fw);


 param_type(const param_type&) = default;
 param_type& operator=(const param_type&) = default;

 std::vector<_RealType>
 intervals() const
 {
   if (_M_int.empty())
     {
       std::vector<_RealType> __tmp(2);
       __tmp[1] = _RealType(1);
       return __tmp;
     }
   else
     return _M_int;
 }

 std::vector<double>
 densities() const
 { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 void
 _M_initialize();

 std::vector<_RealType> _M_int;
 std::vector<double> _M_den;
 std::vector<double> _M_cp;
 std::vector<double> _M_m;
      };

      piecewise_linear_distribution()
      : _M_param()
      { }

      template<typename _InputIteratorB, typename _InputIteratorW>
 piecewise_linear_distribution(_InputIteratorB __bfirst,
          _InputIteratorB __bend,
          _InputIteratorW __wbegin)
 : _M_param(__bfirst, __bend, __wbegin)
 { }

      template<typename _Func>
 piecewise_linear_distribution(initializer_list<_RealType> __bl,
          _Func __fw)
 : _M_param(__bl, __fw)
 { }

      template<typename _Func>
 piecewise_linear_distribution(size_t __nw,
          _RealType __xmin, _RealType __xmax,
          _Func __fw)
 : _M_param(__nw, __xmin, __xmax, __fw)
 { }

      explicit
      piecewise_linear_distribution(const param_type& __p)
      : _M_param(__p)
      { }




      void
      reset()
      { }




      std::vector<_RealType>
      intervals() const
      {
 if (_M_param._M_int.empty())
   {
     std::vector<_RealType> __tmp(2);
     __tmp[1] = _RealType(1);
     return __tmp;
   }
 else
   return _M_param._M_int;
      }





      std::vector<double>
      densities() const
      {
 return _M_param._M_den.empty()
   ? std::vector<double>(2, 1.0) : _M_param._M_den;
      }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      {
 return _M_param._M_int.empty()
   ? result_type(0) : _M_param._M_int.front();
      }




      result_type
      max() const
      {
 return _M_param._M_int.empty()
   ? result_type(1) : _M_param._M_int.back();
      }




      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng)
 { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomNumberGenerator>
 result_type
 operator()(_UniformRandomNumberGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomNumberGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomNumberGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const piecewise_linear_distribution& __d1,
   const piecewise_linear_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }
# 6010 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
     const std::piecewise_linear_distribution<_RealType1>& __x);
# 6026 "/usr/include/c++/10/bits/random.h" 3
      template<typename _RealType1, typename _CharT, typename _Traits>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>& __is,
     std::piecewise_linear_distribution<_RealType1>& __x);

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomNumberGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomNumberGenerator& __urng,
   const param_type& __p);

      param_type _M_param;
    };





  template<typename _RealType>
    inline bool
    operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
        const std::piecewise_linear_distribution<_RealType>& __d2)
    { return !(__d1 == __d2); }
# 6067 "/usr/include/c++/10/bits/random.h" 3
  class seed_seq
  {
  public:

    typedef uint_least32_t result_type;


    seed_seq() noexcept
    : _M_v()
    { }

    template<typename _IntType>
      seed_seq(std::initializer_list<_IntType> il);

    template<typename _InputIterator>
      seed_seq(_InputIterator __begin, _InputIterator __end);


    template<typename _RandomAccessIterator>
      void
      generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);


    size_t size() const noexcept
    { return _M_v.size(); }

    template<typename _OutputIterator>
      void
      param(_OutputIterator __dest) const
      { std::copy(_M_v.begin(), _M_v.end(), __dest); }


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

  private:
    std::vector<result_type> _M_v;
  };






}
# 50 "/usr/include/c++/10/random" 2 3
# 1 "/usr/include/c++/10/x86_64-redhat-linux/bits/opt_random.h" 1 3
# 38 "/usr/include/c++/10/x86_64-redhat-linux/bits/opt_random.h" 3
       
# 39 "/usr/include/c++/10/x86_64-redhat-linux/bits/opt_random.h" 3


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

# 217 "/usr/include/c++/10/x86_64-redhat-linux/bits/opt_random.h" 3

}
# 51 "/usr/include/c++/10/random" 2 3
# 1 "/usr/include/c++/10/bits/random.tcc" 1 3
# 33 "/usr/include/c++/10/bits/random.tcc" 3
# 1 "/usr/include/c++/10/numeric" 1 3
# 58 "/usr/include/c++/10/numeric" 3
       
# 59 "/usr/include/c++/10/numeric" 3



# 1 "/usr/include/c++/10/bits/stl_numeric.h" 1 3
# 64 "/usr/include/c++/10/bits/stl_numeric.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 85 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _ForwardIterator, typename _Tp>
    void
    iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
    {

     

     

      ;

      for (; __first != __last; ++__first)
 {
   *__first = __value;
   ++__value;
 }
    }





# 130 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _Tp>
    inline _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
    {

     
      ;

      for (; __first != __last; ++__first)
 __init = __init + *__first;
      return __init;
    }
# 156 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    inline _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
        _BinaryOperation __binary_op)
    {

     
      ;

      for (; __first != __last; ++__first)
 __init = __binary_op(__init, *__first);
      return __init;
    }
# 184 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
    inline _Tp
    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _Tp __init)
    {

     
     
      ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 __init = __init + (*__first1 * *__first2);
      return __init;
    }
# 215 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
    typename _BinaryOperation1, typename _BinaryOperation2>
    inline _Tp
    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
    _InputIterator2 __first2, _Tp __init,
    _BinaryOperation1 __binary_op1,
    _BinaryOperation2 __binary_op2)
    {

     
     
      ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 __init = __binary_op1(__init,
         __binary_op2(*__first1, *__first2));
      return __init;
    }
# 248 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    partial_sum(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      ;

      if (__first == __last)
 return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
 {
   __value = __value + *__first;
   *++__result = __value;
 }
      return ++__result;
    }
# 288 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation>
    _OutputIterator
    partial_sum(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, _BinaryOperation __binary_op)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      ;

      if (__first == __last)
 return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
 {
   __value = __binary_op(__value, *__first);
   *++__result = __value;
 }
      return ++__result;
    }
# 328 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    adjacent_difference(_InputIterator __first,
   _InputIterator __last, _OutputIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      ;

      if (__first == __last)
 return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
 {
   _ValueType __tmp = *__first;
   *++__result = __tmp - __value;
   __value = std::move(__tmp);
 }
      return ++__result;
    }
# 370 "/usr/include/c++/10/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation>
    _OutputIterator
    adjacent_difference(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result, _BinaryOperation __binary_op)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;


     
     

      ;

      if (__first == __last)
 return __result;
      _ValueType __value = *__first;
      *__result = __value;
      while (++__first != __last)
 {
   _ValueType __tmp = *__first;
   *++__result = __binary_op(__tmp, __value);
   __value = std::move(__tmp);
 }
      return ++__result;
    }






}
# 63 "/usr/include/c++/10/numeric" 2 3
# 79 "/usr/include/c++/10/numeric" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __detail
{

  template<typename _Tp>
    constexpr
    enable_if_t<__and_<is_integral<_Tp>, is_signed<_Tp>>::value, _Tp>
    __abs_integral(_Tp __val)
    { return __val < 0 ? -__val : __val; }

  template<typename _Tp>
    constexpr
    enable_if_t<__and_<is_integral<_Tp>, is_unsigned<_Tp>>::value, _Tp>
    __abs_integral(_Tp __val)
    { return __val; }

  void __abs_integral(bool) = delete;

  template<typename _Mn, typename _Nn>
    constexpr common_type_t<_Mn, _Nn>
    __gcd(_Mn __m, _Nn __n)
    {
      return __m == 0 ? __detail::__abs_integral(__n)
 : __n == 0 ? __detail::__abs_integral(__m)
 : __detail::__gcd(__n, __m % __n);
    }


  template<typename _Mn, typename _Nn>
    constexpr common_type_t<_Mn, _Nn>
    __lcm(_Mn __m, _Nn __n)
    {
      return (__m != 0 && __n != 0)
 ? (__detail::__abs_integral(__m) / __detail::__gcd(__m, __n))
   * __detail::__abs_integral(__n)
 : 0;
    }
}
# 129 "/usr/include/c++/10/numeric" 3
  template<typename _Mn, typename _Nn>
    constexpr common_type_t<_Mn, _Nn>
    gcd(_Mn __m, _Nn __n)
    {
      static_assert(is_integral_v<_Mn>, "gcd arguments are integers");
      static_assert(is_integral_v<_Nn>, "gcd arguments are integers");
      static_assert(!is_same_v<remove_cv_t<_Mn>, bool>,
      "gcd arguments are not bools");
      static_assert(!is_same_v<remove_cv_t<_Nn>, bool>,
      "gcd arguments are not bools");
      return __detail::__gcd(__m, __n);
    }


  template<typename _Mn, typename _Nn>
    constexpr common_type_t<_Mn, _Nn>
    lcm(_Mn __m, _Nn __n)
    {
      static_assert(is_integral_v<_Mn>, "lcm arguments are integers");
      static_assert(is_integral_v<_Nn>, "lcm arguments are integers");
      static_assert(!is_same_v<remove_cv_t<_Mn>, bool>,
      "lcm arguments are not bools");
      static_assert(!is_same_v<remove_cv_t<_Nn>, bool>,
      "lcm arguments are not bools");
      return __detail::__lcm(__m, __n);
    }




}
# 225 "/usr/include/c++/10/numeric" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 251 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    _Tp
    reduce(_InputIterator __first, _InputIterator __last, _Tp __init,
    _BinaryOperation __binary_op)
    {
      using value_type = typename iterator_traits<_InputIterator>::value_type;
      static_assert(is_invocable_r_v<_Tp, _BinaryOperation&, _Tp&, _Tp&>);
      static_assert(is_convertible_v<value_type, _Tp>);
      if constexpr (__is_random_access_iter<_InputIterator>::value)
 {
   while ((__last - __first) >= 4)
     {
       _Tp __v1 = __binary_op(__first[0], __first[1]);
       _Tp __v2 = __binary_op(__first[2], __first[3]);
       _Tp __v3 = __binary_op(__v1, __v2);
       __init = __binary_op(__init, __v3);
       __first += 4;
     }
 }
      for (; __first != __last; ++__first)
 __init = __binary_op(__init, *__first);
      return __init;
    }
# 286 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _Tp>
    inline _Tp
    reduce(_InputIterator __first, _InputIterator __last, _Tp __init)
    { return std::reduce(__first, __last, std::move(__init), plus<>()); }
# 302 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator>
    inline typename iterator_traits<_InputIterator>::value_type
    reduce(_InputIterator __first, _InputIterator __last)
    {
      using value_type = typename iterator_traits<_InputIterator>::value_type;
      return std::reduce(__first, __last, value_type{}, plus<>());
    }
# 328 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
    typename _BinaryOperation1, typename _BinaryOperation2>
    _Tp
    transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _Tp __init,
       _BinaryOperation1 __binary_op1,
       _BinaryOperation2 __binary_op2)
    {
      if constexpr (__and_v<__is_random_access_iter<_InputIterator1>,
       __is_random_access_iter<_InputIterator2>>)
 {
   while ((__last1 - __first1) >= 4)
     {
       _Tp __v1 = __binary_op1(__binary_op2(__first1[0], __first2[0]),
          __binary_op2(__first1[1], __first2[1]));
       _Tp __v2 = __binary_op1(__binary_op2(__first1[2], __first2[2]),
          __binary_op2(__first1[3], __first2[3]));
       _Tp __v3 = __binary_op1(__v1, __v2);
       __init = __binary_op1(__init, __v3);
       __first1 += 4;
       __first2 += 4;
     }
 }
      for (; __first1 != __last1; ++__first1, (void) ++__first2)
 __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
      return __init;
    }
# 371 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
    inline _Tp
    transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _Tp __init)
    {
      return std::transform_reduce(__first1, __last1, __first2,
       std::move(__init),
       plus<>(), multiplies<>());
    }
# 395 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _Tp,
    typename _BinaryOperation, typename _UnaryOperation>
    _Tp
    transform_reduce(_InputIterator __first, _InputIterator __last, _Tp __init,
       _BinaryOperation __binary_op, _UnaryOperation __unary_op)
    {
      if constexpr (__is_random_access_iter<_InputIterator>::value)
 {
   while ((__last - __first) >= 4)
     {
       _Tp __v1 = __binary_op(__unary_op(__first[0]),
         __unary_op(__first[1]));
       _Tp __v2 = __binary_op(__unary_op(__first[2]),
         __unary_op(__first[3]));
       _Tp __v3 = __binary_op(__v1, __v2);
       __init = __binary_op(__init, __v3);
       __first += 4;
     }
 }
      for (; __first != __last; ++__first)
 __init = __binary_op(__init, __unary_op(*__first));
      return __init;
    }
# 437 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp,
    typename _BinaryOperation>
    _OutputIterator
    exclusive_scan(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Tp __init,
     _BinaryOperation __binary_op)
    {
      while (__first != __last)
 {
   auto __v = __init;
   __init = __binary_op(__init, *__first);
   ++__first;
   *__result++ = std::move(__v);
 }
      return __result;
    }
# 471 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    inline _OutputIterator
    exclusive_scan(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Tp __init)
    {
      return std::exclusive_scan(__first, __last, __result, std::move(__init),
     plus<>());
    }
# 498 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation, typename _Tp>
    _OutputIterator
    inclusive_scan(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _BinaryOperation __binary_op,
     _Tp __init)
    {
      for (; __first != __last; ++__first)
 *__result++ = __init = __binary_op(__init, *__first);
      return __result;
    }
# 526 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation>
    _OutputIterator
    inclusive_scan(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _BinaryOperation __binary_op)
    {
      if (__first != __last)
 {
   auto __init = *__first;
   *__result++ = __init;
   ++__first;
   if (__first != __last)
     __result = std::inclusive_scan(__first, __last, __result,
        __binary_op, std::move(__init));
 }
      return __result;
    }
# 559 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    inclusive_scan(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result)
    { return std::inclusive_scan(__first, __last, __result, plus<>()); }
# 585 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp,
    typename _BinaryOperation, typename _UnaryOperation>
    _OutputIterator
    transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result, _Tp __init,
        _BinaryOperation __binary_op,
        _UnaryOperation __unary_op)
    {
      while (__first != __last)
 {
   auto __v = __init;
   __init = __binary_op(__init, __unary_op(*__first));
   ++__first;
   *__result++ = std::move(__v);
 }
      return __result;
    }
# 623 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation, typename _UnaryOperation, typename _Tp>
    _OutputIterator
    transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result,
        _BinaryOperation __binary_op,
        _UnaryOperation __unary_op,
        _Tp __init)
    {
      for (; __first != __last; ++__first)
 *__result++ = __init = __binary_op(__init, __unary_op(*__first));
      return __result;
    }
# 656 "/usr/include/c++/10/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
   typename _BinaryOperation, typename _UnaryOperation>
    _OutputIterator
    transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result,
        _BinaryOperation __binary_op,
        _UnaryOperation __unary_op)
    {
      if (__first != __last)
 {
   auto __init = __unary_op(*__first);
   *__result++ = __init;
   ++__first;
   if (__first != __last)
     __result = std::transform_inclusive_scan(__first, __last, __result,
           __binary_op, __unary_op,
           std::move(__init));
 }
      return __result;
    }




}







# 1 "/usr/include/c++/10/pstl/glue_numeric_defs.h" 1 3
# 15 "/usr/include/c++/10/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);

}
# 689 "/usr/include/c++/10/numeric" 2 3
# 34 "/usr/include/c++/10/bits/random.tcc" 2 3

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





  namespace __detail
  {






    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
      _Tp
      _Mod<_Tp, __m, __a, __c, false, true>::
      __calc(_Tp __x)
      {
 if (__a == 1)
   __x %= __m;
 else
   {
     static const _Tp __q = __m / __a;
     static const _Tp __r = __m % __a;

     _Tp __t1 = __a * (__x % __q);
     _Tp __t2 = __r * (__x / __q);
     if (__t1 >= __t2)
       __x = __t1 - __t2;
     else
       __x = __m - __t2 + __t1;
   }

 if (__c != 0)
   {
     const _Tp __d = __m - __x;
     if (__d > __c)
       __x += __c;
     else
       __x = __c - __d;
   }
 return __x;
      }

    template<typename _InputIterator, typename _OutputIterator,
      typename _Tp>
      _OutputIterator
      __normalize(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result, const _Tp& __factor)
      {
 for (; __first != __last; ++__first, ++__result)
   *__result = *__first / __factor;
 return __result;
      }

  }

  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    constexpr _UIntType
    linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;

  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    constexpr _UIntType
    linear_congruential_engine<_UIntType, __a, __c, __m>::increment;

  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    constexpr _UIntType
    linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;

  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    constexpr _UIntType
    linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;





  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    void
    linear_congruential_engine<_UIntType, __a, __c, __m>::
    seed(result_type __s)
    {
      if ((__detail::__mod<_UIntType, __m>(__c) == 0)
   && (__detail::__mod<_UIntType, __m>(__s) == 0))
 _M_x = 1;
      else
 _M_x = __detail::__mod<_UIntType, __m>(__s);
    }




  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
    template<typename _Sseq>
      auto
      linear_congruential_engine<_UIntType, __a, __c, __m>::
      seed(_Sseq& __q)
      -> _If_seed_seq<_Sseq>
      {
 const _UIntType __k0 = __m == 0 ? std::numeric_limits<_UIntType>::digits
                                 : std::__lg(__m);
 const _UIntType __k = (__k0 + 31) / 32;
 uint_least32_t __arr[__k + 3];
 __q.generate(__arr + 0, __arr + __k + 3);
 _UIntType __factor = 1u;
 _UIntType __sum = 0u;
 for (size_t __j = 0; __j < __k; ++__j)
   {
     __sum += __arr[__j + 3] * __factor;
     __factor *= __detail::_Shift<_UIntType, 32>::__value;
   }
 seed(__sum);
      }

  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const linear_congruential_engine<_UIntType,
      __a, __c, __m>& __lcr)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
      __os.fill(__os.widen(' '));

      __os << __lcr._M_x;

      __os.flags(__flags);
      __os.fill(__fill);
      return __os;
    }

  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec);

      __is >> __lcr._M_x;

      __is.flags(__flags);
      return __is;
    }


  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::word_size;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::state_size;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::shift_size;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::mask_bits;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr _UIntType
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::xor_mask;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::tempering_u;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr _UIntType
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::tempering_d;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::tempering_s;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr _UIntType
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::tempering_b;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::tempering_t;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr _UIntType
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::tempering_c;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr size_t
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::tempering_l;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr _UIntType
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::
                                              initialization_multiplier;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    constexpr _UIntType
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::default_seed;

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    void
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::
    seed(result_type __sd)
    {
      _M_x[0] = __detail::__mod<_UIntType,
 __detail::_Shift<_UIntType, __w>::__value>(__sd);

      for (size_t __i = 1; __i < state_size; ++__i)
 {
   _UIntType __x = _M_x[__i - 1];
   __x ^= __x >> (__w - 2);
   __x *= __f;
   __x += __detail::__mod<_UIntType, __n>(__i);
   _M_x[__i] = __detail::__mod<_UIntType,
     __detail::_Shift<_UIntType, __w>::__value>(__x);
 }
      _M_p = state_size;
    }

  template<typename _UIntType,
    size_t __w, size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    template<typename _Sseq>
      auto
      mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
         __s, __b, __t, __c, __l, __f>::
      seed(_Sseq& __q)
      -> _If_seed_seq<_Sseq>
      {
 const _UIntType __upper_mask = (~_UIntType()) << __r;
 const size_t __k = (__w + 31) / 32;
 uint_least32_t __arr[__n * __k];
 __q.generate(__arr + 0, __arr + __n * __k);

 bool __zero = true;
 for (size_t __i = 0; __i < state_size; ++__i)
   {
     _UIntType __factor = 1u;
     _UIntType __sum = 0u;
     for (size_t __j = 0; __j < __k; ++__j)
       {
  __sum += __arr[__k * __i + __j] * __factor;
  __factor *= __detail::_Shift<_UIntType, 32>::__value;
       }
     _M_x[__i] = __detail::__mod<_UIntType,
       __detail::_Shift<_UIntType, __w>::__value>(__sum);

     if (__zero)
       {
  if (__i == 0)
    {
      if ((_M_x[0] & __upper_mask) != 0u)
        __zero = false;
    }
  else if (_M_x[__i] != 0u)
    __zero = false;
       }
   }
        if (__zero)
          _M_x[0] = __detail::_Shift<_UIntType, __w - 1>::__value;
 _M_p = state_size;
      }

  template<typename _UIntType, size_t __w,
    size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    void
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::
    _M_gen_rand(void)
    {
      const _UIntType __upper_mask = (~_UIntType()) << __r;
      const _UIntType __lower_mask = ~__upper_mask;

      for (size_t __k = 0; __k < (__n - __m); ++__k)
        {
   _UIntType __y = ((_M_x[__k] & __upper_mask)
      | (_M_x[__k + 1] & __lower_mask));
   _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
         ^ ((__y & 0x01) ? __a : 0));
        }

      for (size_t __k = (__n - __m); __k < (__n - 1); ++__k)
 {
   _UIntType __y = ((_M_x[__k] & __upper_mask)
      | (_M_x[__k + 1] & __lower_mask));
   _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
         ^ ((__y & 0x01) ? __a : 0));
 }

      _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
         | (_M_x[0] & __lower_mask));
      _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
         ^ ((__y & 0x01) ? __a : 0));
      _M_p = 0;
    }

  template<typename _UIntType, size_t __w,
    size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    void
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::
    discard(unsigned long long __z)
    {
      while (__z > state_size - _M_p)
 {
   __z -= state_size - _M_p;
   _M_gen_rand();
 }
      _M_p += __z;
    }

  template<typename _UIntType, size_t __w,
    size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f>
    typename
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::result_type
    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
       __s, __b, __t, __c, __l, __f>::
    operator()()
    {

      if (_M_p >= state_size)
 _M_gen_rand();


      result_type __z = _M_x[_M_p++];
      __z ^= (__z >> __u) & __d;
      __z ^= (__z << __s) & __b;
      __z ^= (__z << __t) & __c;
      __z ^= (__z >> __l);

      return __z;
    }

  template<typename _UIntType, size_t __w,
    size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const mersenne_twister_engine<_UIntType, __w, __n, __m,
        __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
      __os.fill(__space);

      for (size_t __i = 0; __i < __n; ++__i)
 __os << __x._M_x[__i] << __space;
      __os << __x._M_p;

      __os.flags(__flags);
      __os.fill(__fill);
      return __os;
    }

  template<typename _UIntType, size_t __w,
    size_t __n, size_t __m, size_t __r,
    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
    _UIntType __b, size_t __t, _UIntType __c, size_t __l,
    _UIntType __f, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        mersenne_twister_engine<_UIntType, __w, __n, __m,
        __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      for (size_t __i = 0; __i < __n; ++__i)
 __is >> __x._M_x[__i];
      __is >> __x._M_p;

      __is.flags(__flags);
      return __is;
    }


  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    constexpr size_t
    subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;

  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    constexpr size_t
    subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;

  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    constexpr size_t
    subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;

  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    constexpr _UIntType
    subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;

  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    void
    subtract_with_carry_engine<_UIntType, __w, __s, __r>::
    seed(result_type __value)
    {
      std::linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
 __lcg(__value == 0u ? default_seed : __value);

      const size_t __n = (__w + 31) / 32;

      for (size_t __i = 0; __i < long_lag; ++__i)
 {
   _UIntType __sum = 0u;
   _UIntType __factor = 1u;
   for (size_t __j = 0; __j < __n; ++__j)
     {
       __sum += __detail::__mod<uint_least32_t,
         __detail::_Shift<uint_least32_t, 32>::__value>
    (__lcg()) * __factor;
       __factor *= __detail::_Shift<_UIntType, 32>::__value;
     }
   _M_x[__i] = __detail::__mod<_UIntType,
     __detail::_Shift<_UIntType, __w>::__value>(__sum);
 }
      _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
      _M_p = 0;
    }

  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    template<typename _Sseq>
      auto
      subtract_with_carry_engine<_UIntType, __w, __s, __r>::
      seed(_Sseq& __q)
      -> _If_seed_seq<_Sseq>
      {
 const size_t __k = (__w + 31) / 32;
 uint_least32_t __arr[__r * __k];
 __q.generate(__arr + 0, __arr + __r * __k);

 for (size_t __i = 0; __i < long_lag; ++__i)
   {
     _UIntType __sum = 0u;
     _UIntType __factor = 1u;
     for (size_t __j = 0; __j < __k; ++__j)
       {
  __sum += __arr[__k * __i + __j] * __factor;
  __factor *= __detail::_Shift<_UIntType, 32>::__value;
       }
     _M_x[__i] = __detail::__mod<_UIntType,
       __detail::_Shift<_UIntType, __w>::__value>(__sum);
   }
 _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
 _M_p = 0;
      }

  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
    typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::
      result_type
    subtract_with_carry_engine<_UIntType, __w, __s, __r>::
    operator()()
    {

      long __ps = _M_p - short_lag;
      if (__ps < 0)
 __ps += long_lag;




      _UIntType __xi;
      if (_M_x[__ps] >= _M_x[_M_p] + _M_carry)
 {
   __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry;
   _M_carry = 0;
 }
      else
 {
   __xi = (__detail::_Shift<_UIntType, __w>::__value
    - _M_x[_M_p] - _M_carry + _M_x[__ps]);
   _M_carry = 1;
 }
      _M_x[_M_p] = __xi;


      if (++_M_p >= long_lag)
 _M_p = 0;

      return __xi;
    }

  template<typename _UIntType, size_t __w, size_t __s, size_t __r,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const subtract_with_carry_engine<_UIntType,
      __w, __s, __r>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
      __os.fill(__space);

      for (size_t __i = 0; __i < __r; ++__i)
 __os << __x._M_x[__i] << __space;
      __os << __x._M_carry << __space << __x._M_p;

      __os.flags(__flags);
      __os.fill(__fill);
      return __os;
    }

  template<typename _UIntType, size_t __w, size_t __s, size_t __r,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      for (size_t __i = 0; __i < __r; ++__i)
 __is >> __x._M_x[__i];
      __is >> __x._M_carry;
      __is >> __x._M_p;

      __is.flags(__flags);
      return __is;
    }


  template<typename _RandomNumberEngine, size_t __p, size_t __r>
    constexpr size_t
    discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;

  template<typename _RandomNumberEngine, size_t __p, size_t __r>
    constexpr size_t
    discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;

  template<typename _RandomNumberEngine, size_t __p, size_t __r>
    typename discard_block_engine<_RandomNumberEngine,
      __p, __r>::result_type
    discard_block_engine<_RandomNumberEngine, __p, __r>::
    operator()()
    {
      if (_M_n >= used_block)
 {
   _M_b.discard(block_size - _M_n);
   _M_n = 0;
 }
      ++_M_n;
      return _M_b();
    }

  template<typename _RandomNumberEngine, size_t __p, size_t __r,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const discard_block_engine<_RandomNumberEngine,
        __p, __r>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
      __os.fill(__space);

      __os << __x.base() << __space << __x._M_n;

      __os.flags(__flags);
      __os.fill(__fill);
      return __os;
    }

  template<typename _RandomNumberEngine, size_t __p, size_t __r,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      __is >> __x._M_b >> __x._M_n;

      __is.flags(__flags);
      return __is;
    }


  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
    typename independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
      result_type
    independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
    operator()()
    {
      typedef typename _RandomNumberEngine::result_type _Eresult_type;
      const _Eresult_type __r
 = (_M_b.max() - _M_b.min() < std::numeric_limits<_Eresult_type>::max()
    ? _M_b.max() - _M_b.min() + 1 : 0);
      const unsigned __edig = std::numeric_limits<_Eresult_type>::digits;
      const unsigned __m = __r ? std::__lg(__r) : __edig;

      typedef typename std::common_type<_Eresult_type, result_type>::type
 __ctype;
      const unsigned __cdig = std::numeric_limits<__ctype>::digits;

      unsigned __n, __n0;
      __ctype __s0, __s1, __y0, __y1;

      for (size_t __i = 0; __i < 2; ++__i)
 {
   __n = (__w + __m - 1) / __m + __i;
   __n0 = __n - __w % __n;
   const unsigned __w0 = __w / __n;

   __s0 = 0;
   __s1 = 0;
   if (__w0 < __cdig)
     {
       __s0 = __ctype(1) << __w0;
       __s1 = __s0 << 1;
     }

   __y0 = 0;
   __y1 = 0;
   if (__r)
     {
       __y0 = __s0 * (__r / __s0);
       if (__s1)
  __y1 = __s1 * (__r / __s1);

       if (__r - __y0 <= __y0 / __n)
  break;
     }
   else
     break;
 }

      result_type __sum = 0;
      for (size_t __k = 0; __k < __n0; ++__k)
 {
   __ctype __u;
   do
     __u = _M_b() - _M_b.min();
   while (__y0 && __u >= __y0);
   __sum = __s0 * __sum + (__s0 ? __u % __s0 : __u);
 }
      for (size_t __k = __n0; __k < __n; ++__k)
 {
   __ctype __u;
   do
     __u = _M_b() - _M_b.min();
   while (__y1 && __u >= __y1);
   __sum = __s1 * __sum + (__s1 ? __u % __s1 : __u);
 }
      return __sum;
    }


  template<typename _RandomNumberEngine, size_t __k>
    constexpr size_t
    shuffle_order_engine<_RandomNumberEngine, __k>::table_size;

  template<typename _RandomNumberEngine, size_t __k>
    typename shuffle_order_engine<_RandomNumberEngine, __k>::result_type
    shuffle_order_engine<_RandomNumberEngine, __k>::
    operator()()
    {
      size_t __j = __k * ((_M_y - _M_b.min())
     / (_M_b.max() - _M_b.min() + 1.0L));
      _M_y = _M_v[__j];
      _M_v[__j] = _M_b();

      return _M_y;
    }

  template<typename _RandomNumberEngine, size_t __k,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const shuffle_order_engine<_RandomNumberEngine, __k>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
      __os.fill(__space);

      __os << __x.base();
      for (size_t __i = 0; __i < __k; ++__i)
 __os << __space << __x._M_v[__i];
      __os << __space << __x._M_y;

      __os.flags(__flags);
      __os.fill(__fill);
      return __os;
    }

  template<typename _RandomNumberEngine, size_t __k,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        shuffle_order_engine<_RandomNumberEngine, __k>& __x)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      __is >> __x._M_b;
      for (size_t __i = 0; __i < __k; ++__i)
 __is >> __x._M_v[__i];
      __is >> __x._M_y;

      __is.flags(__flags);
      return __is;
    }


  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const uniform_int_distribution<_IntType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);

      __os << __x.a() << __space << __x.b();

      __os.flags(__flags);
      __os.fill(__fill);
      return __os;
    }

  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        uniform_int_distribution<_IntType>& __x)
    {
      using param_type
 = typename uniform_int_distribution<_IntType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _IntType __a, __b;
      if (__is >> __a >> __b)
 __x.param(param_type(__a, __b));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      uniform_real_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);
 auto __range = __p.b() - __p.a();
 while (__f != __t)
   *__f++ = __aurng() * __range + __p.a();
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const uniform_real_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.a() << __space << __x.b();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        uniform_real_distribution<_RealType>& __x)
    {
      using param_type
 = typename uniform_real_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::skipws);

      _RealType __a, __b;
      if (__is >> __a >> __b)
 __x.param(param_type(__a, __b));

      __is.flags(__flags);
      return __is;
    }


  template<typename _ForwardIterator,
    typename _UniformRandomNumberGenerator>
    void
    std::bernoulli_distribution::
    __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
      _UniformRandomNumberGenerator& __urng,
      const param_type& __p)
    {
     
      __detail::_Adaptor<_UniformRandomNumberGenerator, double>
 __aurng(__urng);
      auto __limit = __p.p() * (__aurng.max() - __aurng.min());

      while (__f != __t)
 *__f++ = (__aurng() - __aurng.min()) < __limit;
    }

  template<typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const bernoulli_distribution& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__os.widen(' '));
      __os.precision(std::numeric_limits<double>::max_digits10);

      __os << __x.p();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }


  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename geometric_distribution<_IntType>::result_type
      geometric_distribution<_IntType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {


 const double __naf =
   (1 - std::numeric_limits<double>::epsilon()) / 2;

 const double __thr =
   std::numeric_limits<_IntType>::max() + __naf;
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 double __cand;
 do
   __cand = std::floor(std::log(1.0 - __aurng()) / __param._M_log_1_p);
 while (__cand >= __thr);

 return result_type(__cand + __naf);
      }

  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      geometric_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {



 const double __naf =
   (1 - std::numeric_limits<double>::epsilon()) / 2;

 const double __thr =
   std::numeric_limits<_IntType>::max() + __naf;
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 while (__f != __t)
   {
     double __cand;
     do
       __cand = std::floor(std::log(1.0 - __aurng())
      / __param._M_log_1_p);
     while (__cand >= __thr);

     *__f++ = __cand + __naf;
   }
      }

  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const geometric_distribution<_IntType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__os.widen(' '));
      __os.precision(std::numeric_limits<double>::max_digits10);

      __os << __x.p();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        geometric_distribution<_IntType>& __x)
    {
      using param_type = typename geometric_distribution<_IntType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::skipws);

      double __p;
      if (__is >> __p)
 __x.param(param_type(__p));

      __is.flags(__flags);
      return __is;
    }


  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename negative_binomial_distribution<_IntType>::result_type
      negative_binomial_distribution<_IntType>::
      operator()(_UniformRandomNumberGenerator& __urng)
      {
 const double __y = _M_gd(__urng);


 std::poisson_distribution<result_type> __poisson(__y);
 return __poisson(__urng);
      }

  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename negative_binomial_distribution<_IntType>::result_type
      negative_binomial_distribution<_IntType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __p)
      {
 typedef typename std::gamma_distribution<double>::param_type
   param_type;

 const double __y =
   _M_gd(__urng, param_type(__p.k(), (1.0 - __p.p()) / __p.p()));

 std::poisson_distribution<result_type> __poisson(__y);
 return __poisson(__urng);
      }

  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      negative_binomial_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng)
      {

 while (__f != __t)
   {
     const double __y = _M_gd(__urng);


     std::poisson_distribution<result_type> __poisson(__y);
     *__f++ = __poisson(__urng);
   }
      }

  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      negative_binomial_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 typename std::gamma_distribution<result_type>::param_type
   __p2(__p.k(), (1.0 - __p.p()) / __p.p());

 while (__f != __t)
   {
     const double __y = _M_gd(__urng, __p2);

     std::poisson_distribution<result_type> __poisson(__y);
     *__f++ = __poisson(__urng);
   }
      }

  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const negative_binomial_distribution<_IntType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__os.widen(' '));
      __os.precision(std::numeric_limits<double>::max_digits10);

      __os << __x.k() << __space << __x.p()
    << __space << __x._M_gd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        negative_binomial_distribution<_IntType>& __x)
    {
      using param_type
 = typename negative_binomial_distribution<_IntType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::skipws);

      _IntType __k;
      double __p;
      if (__is >> __k >> __p >> __x._M_gd)
 __x.param(param_type(__k, __p));

      __is.flags(__flags);
      return __is;
    }


  template<typename _IntType>
    void
    poisson_distribution<_IntType>::param_type::
    _M_initialize()
    {

      if (_M_mean >= 12)
 {
   const double __m = std::floor(_M_mean);
   _M_lm_thr = std::log(_M_mean);
   _M_lfm = std::lgamma(__m + 1);
   _M_sm = std::sqrt(__m);

   const double __pi_4 = 0.7853981633974483096156608458198757L;
   const double __dx = std::sqrt(2 * __m * std::log(32 * __m
             / __pi_4));
   _M_d = std::round(std::max<double>(6.0, std::min(__m, __dx)));
   const double __cx = 2 * __m + _M_d;
   _M_scx = std::sqrt(__cx / 2);
   _M_1cx = 1 / __cx;

   _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx);
   _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2))
  / _M_d;
 }
      else

 _M_lm_thr = std::exp(-_M_mean);
      }
# 1265 "/usr/include/c++/10/bits/random.tcc" 3
  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename poisson_distribution<_IntType>::result_type
      poisson_distribution<_IntType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 if (__param.mean() >= 12)
   {
     double __x;


     const double __naf =
       (1 - std::numeric_limits<double>::epsilon()) / 2;
     const double __thr =
       std::numeric_limits<_IntType>::max() + __naf;

     const double __m = std::floor(__param.mean());

     const double __spi_2 = 1.2533141373155002512078826424055226L;
     const double __c1 = __param._M_sm * __spi_2;
     const double __c2 = __param._M_c2b + __c1;
     const double __c3 = __c2 + 1;
     const double __c4 = __c3 + 1;

     const double __178 = 0.0128205128205128205128205128205128L;

     const double __e178 = 1.0129030479320018583185514777512983L;
     const double __c5 = __c4 + __e178;
     const double __c = __param._M_cb + __c5;
     const double __2cx = 2 * (2 * __m + __param._M_d);

     bool __reject = true;
     do
       {
  const double __u = __c * __aurng();
  const double __e = -std::log(1.0 - __aurng());

  double __w = 0.0;

  if (__u <= __c1)
    {
      const double __n = _M_nd(__urng);
      const double __y = -std::abs(__n) * __param._M_sm - 1;
      __x = std::floor(__y);
      __w = -__n * __n / 2;
      if (__x < -__m)
        continue;
    }
  else if (__u <= __c2)
    {
      const double __n = _M_nd(__urng);
      const double __y = 1 + std::abs(__n) * __param._M_scx;
      __x = std::ceil(__y);
      __w = __y * (2 - __y) * __param._M_1cx;
      if (__x > __param._M_d)
        continue;
    }
  else if (__u <= __c3)


    __x = -1;
  else if (__u <= __c4)
    __x = 0;
  else if (__u <= __c5)
    {
      __x = 1;

      __w = __178;
    }
  else
    {
      const double __v = -std::log(1.0 - __aurng());
      const double __y = __param._M_d
         + __v * __2cx / __param._M_d;
      __x = std::ceil(__y);
      __w = -__param._M_d * __param._M_1cx * (1 + __y / 2);
    }

  __reject = (__w - __e - __x * __param._M_lm_thr
       > __param._M_lfm - std::lgamma(__x + __m + 1));

  __reject |= __x + __m >= __thr;

       } while (__reject);

     return result_type(__x + __m + __naf);
   }
 else

   {
     _IntType __x = 0;
     double __prod = 1.0;

     do
       {
  __prod *= __aurng();
  __x += 1;
       }
     while (__prod > __param._M_lm_thr);

     return __x - 1;
   }
      }

  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      poisson_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {


 while (__f != __t)
   *__f++ = this->operator()(__urng, __param);
      }

  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const poisson_distribution<_IntType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<double>::max_digits10);

      __os << __x.mean() << __space << __x._M_nd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        poisson_distribution<_IntType>& __x)
    {
      using param_type = typename poisson_distribution<_IntType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::skipws);

      double __mean;
      if (__is >> __mean >> __x._M_nd)
 __x.param(param_type(__mean));

      __is.flags(__flags);
      return __is;
    }


  template<typename _IntType>
    void
    binomial_distribution<_IntType>::param_type::
    _M_initialize()
    {
      const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;

      _M_easy = true;


      if (_M_t * __p12 >= 8)
 {
   _M_easy = false;
   const double __np = std::floor(_M_t * __p12);
   const double __pa = __np / _M_t;
   const double __1p = 1 - __pa;

   const double __pi_4 = 0.7853981633974483096156608458198757L;
   const double __d1x =
     std::sqrt(__np * __1p * std::log(32 * __np
          / (81 * __pi_4 * __1p)));
   _M_d1 = std::round(std::max<double>(1.0, __d1x));
   const double __d2x =
     std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
          / (__pi_4 * __pa)));
   _M_d2 = std::round(std::max<double>(1.0, __d2x));


   const double __spi_2 = 1.2533141373155002512078826424055226L;
   _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np));
   _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p));
   _M_c = 2 * _M_d1 / __np;
   _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2;
   const double __a12 = _M_a1 + _M_s2 * __spi_2;
   const double __s1s = _M_s1 * _M_s1;
   _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p))
        * 2 * __s1s / _M_d1
        * std::exp(-_M_d1 * _M_d1 / (2 * __s1s)));
   const double __s2s = _M_s2 * _M_s2;
   _M_s = (_M_a123 + 2 * __s2s / _M_d2
    * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
   _M_lf = (std::lgamma(__np + 1)
     + std::lgamma(_M_t - __np + 1));
   _M_lp1p = std::log(__pa / __1p);

   _M_q = -std::log(1 - (__p12 - __pa) / __1p);
 }
      else

 _M_q = -std::log(1 - __p12);
    }

  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename binomial_distribution<_IntType>::result_type
      binomial_distribution<_IntType>::
      _M_waiting(_UniformRandomNumberGenerator& __urng,
   _IntType __t, double __q)
      {
 _IntType __x = 0;
 double __sum = 0.0;
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 do
   {
     if (__t == __x)
       return __x;
     const double __e = -std::log(1.0 - __aurng());
     __sum += __e / (__t - __x);
     __x += 1;
   }
 while (__sum <= __q);

 return __x - 1;
      }
# 1520 "/usr/include/c++/10/bits/random.tcc" 3
  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename binomial_distribution<_IntType>::result_type
      binomial_distribution<_IntType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 result_type __ret;
 const _IntType __t = __param.t();
 const double __p = __param.p();
 const double __p12 = __p <= 0.5 ? __p : 1.0 - __p;
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);


 if (!__param._M_easy)
   {
     double __x;


     const double __naf =
       (1 - std::numeric_limits<double>::epsilon()) / 2;
     const double __thr =
       std::numeric_limits<_IntType>::max() + __naf;

     const double __np = std::floor(__t * __p12);


     const double __spi_2 = 1.2533141373155002512078826424055226L;
     const double __a1 = __param._M_a1;
     const double __a12 = __a1 + __param._M_s2 * __spi_2;
     const double __a123 = __param._M_a123;
     const double __s1s = __param._M_s1 * __param._M_s1;
     const double __s2s = __param._M_s2 * __param._M_s2;

     bool __reject;
     do
       {
  const double __u = __param._M_s * __aurng();

  double __v;

  if (__u <= __a1)
    {
      const double __n = _M_nd(__urng);
      const double __y = __param._M_s1 * std::abs(__n);
      __reject = __y >= __param._M_d1;
      if (!__reject)
        {
   const double __e = -std::log(1.0 - __aurng());
   __x = std::floor(__y);
   __v = -__e - __n * __n / 2 + __param._M_c;
        }
    }
  else if (__u <= __a12)
    {
      const double __n = _M_nd(__urng);
      const double __y = __param._M_s2 * std::abs(__n);
      __reject = __y >= __param._M_d2;
      if (!__reject)
        {
   const double __e = -std::log(1.0 - __aurng());
   __x = std::floor(-__y);
   __v = -__e - __n * __n / 2;
        }
    }
  else if (__u <= __a123)
    {
      const double __e1 = -std::log(1.0 - __aurng());
      const double __e2 = -std::log(1.0 - __aurng());

      const double __y = __param._M_d1
         + 2 * __s1s * __e1 / __param._M_d1;
      __x = std::floor(__y);
      __v = (-__e2 + __param._M_d1 * (1 / (__t - __np)
          -__y / (2 * __s1s)));
      __reject = false;
    }
  else
    {
      const double __e1 = -std::log(1.0 - __aurng());
      const double __e2 = -std::log(1.0 - __aurng());

      const double __y = __param._M_d2
         + 2 * __s2s * __e1 / __param._M_d2;
      __x = std::floor(-__y);
      __v = -__e2 - __param._M_d2 * __y / (2 * __s2s);
      __reject = false;
    }

  __reject = __reject || __x < -__np || __x > __t - __np;
  if (!__reject)
    {
      const double __lfx =
        std::lgamma(__np + __x + 1)
        + std::lgamma(__t - (__np + __x) + 1);
      __reject = __v > __param._M_lf - __lfx
        + __x * __param._M_lp1p;
    }

  __reject |= __x + __np >= __thr;
       }
     while (__reject);

     __x += __np + __naf;

     const _IntType __z = _M_waiting(__urng, __t - _IntType(__x),
         __param._M_q);
     __ret = _IntType(__x) + __z;
   }
 else

   __ret = _M_waiting(__urng, __t, __param._M_q);

 if (__p12 != __p)
   __ret = __t - __ret;
 return __ret;
      }

  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      binomial_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {


 while (__f != __t)
   *__f++ = this->operator()(__urng, __param);
      }

  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const binomial_distribution<_IntType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<double>::max_digits10);

      __os << __x.t() << __space << __x.p()
    << __space << __x._M_nd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _IntType,
    typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        binomial_distribution<_IntType>& __x)
    {
      using param_type = typename binomial_distribution<_IntType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _IntType __t;
      double __p;
      if (__is >> __t >> __p >> __x._M_nd)
 __x.param(param_type(__t, __p));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      std::exponential_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);
 while (__f != __t)
   *__f++ = -std::log(result_type(1) - __aurng()) / __p.lambda();
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const exponential_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__os.widen(' '));
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.lambda();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        exponential_distribution<_RealType>& __x)
    {
      using param_type
 = typename exponential_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __lambda;
      if (__is >> __lambda)
 __x.param(param_type(__lambda));

      __is.flags(__flags);
      return __is;
    }
# 1766 "/usr/include/c++/10/bits/random.tcc" 3
  template<typename _RealType>
    template<typename _UniformRandomNumberGenerator>
      typename normal_distribution<_RealType>::result_type
      normal_distribution<_RealType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 result_type __ret;
 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);

 if (_M_saved_available)
   {
     _M_saved_available = false;
     __ret = _M_saved;
   }
 else
   {
     result_type __x, __y, __r2;
     do
       {
  __x = result_type(2.0) * __aurng() - 1.0;
  __y = result_type(2.0) * __aurng() - 1.0;
  __r2 = __x * __x + __y * __y;
       }
     while (__r2 > 1.0 || __r2 == 0.0);

     const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
     _M_saved = __x * __mult;
     _M_saved_available = true;
     __ret = __y * __mult;
   }

 __ret = __ret * __param.stddev() + __param.mean();
 return __ret;
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      normal_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {


 if (__f == __t)
   return;

 if (_M_saved_available)
   {
     _M_saved_available = false;
     *__f++ = _M_saved * __param.stddev() + __param.mean();

     if (__f == __t)
       return;
   }

 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);

 while (__f + 1 < __t)
   {
     result_type __x, __y, __r2;
     do
       {
  __x = result_type(2.0) * __aurng() - 1.0;
  __y = result_type(2.0) * __aurng() - 1.0;
  __r2 = __x * __x + __y * __y;
       }
     while (__r2 > 1.0 || __r2 == 0.0);

     const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
     *__f++ = __y * __mult * __param.stddev() + __param.mean();
     *__f++ = __x * __mult * __param.stddev() + __param.mean();
   }

 if (__f != __t)
   {
     result_type __x, __y, __r2;
     do
       {
  __x = result_type(2.0) * __aurng() - 1.0;
  __y = result_type(2.0) * __aurng() - 1.0;
  __r2 = __x * __x + __y * __y;
       }
     while (__r2 > 1.0 || __r2 == 0.0);

     const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
     _M_saved = __x * __mult;
     _M_saved_available = true;
     *__f = __y * __mult * __param.stddev() + __param.mean();
   }
      }

  template<typename _RealType>
    bool
    operator==(const std::normal_distribution<_RealType>& __d1,
        const std::normal_distribution<_RealType>& __d2)
    {
      if (__d1._M_param == __d2._M_param
   && __d1._M_saved_available == __d2._M_saved_available)
 {
   if (__d1._M_saved_available
       && __d1._M_saved == __d2._M_saved)
     return true;
   else if(!__d1._M_saved_available)
     return true;
   else
     return false;
 }
      else
 return false;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const normal_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.mean() << __space << __x.stddev()
    << __space << __x._M_saved_available;
      if (__x._M_saved_available)
 __os << __space << __x._M_saved;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        normal_distribution<_RealType>& __x)
    {
      using param_type = typename normal_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      double __mean, __stddev;
      bool __saved_avail;
      if (__is >> __mean >> __stddev >> __saved_avail)
 {
   if (__saved_avail && (__is >> __x._M_saved))
     {
       __x._M_saved_available = __saved_avail;
       __x.param(param_type(__mean, __stddev));
     }
 }

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      lognormal_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

   while (__f != __t)
     *__f++ = std::exp(__p.s() * _M_nd(__urng) + __p.m());
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const lognormal_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.m() << __space << __x.s()
    << __space << __x._M_nd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        lognormal_distribution<_RealType>& __x)
    {
      using param_type
 = typename lognormal_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __m, __s;
      if (__is >> __m >> __s >> __x._M_nd)
 __x.param(param_type(__m, __s));

      __is.flags(__flags);
      return __is;
    }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      std::chi_squared_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng)
      {

 while (__f != __t)
   *__f++ = 2 * _M_gd(__urng);
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      std::chi_squared_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const typename
        std::gamma_distribution<result_type>::param_type& __p)
      {

 while (__f != __t)
   *__f++ = 2 * _M_gd(__urng, __p);
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const chi_squared_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.n() << __space << __x._M_gd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        chi_squared_distribution<_RealType>& __x)
    {
      using param_type
 = typename chi_squared_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __n;
      if (__is >> __n >> __x._M_gd)
 __x.param(param_type(__n));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _UniformRandomNumberGenerator>
      typename cauchy_distribution<_RealType>::result_type
      cauchy_distribution<_RealType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __p)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);
 _RealType __u;
 do
   __u = __aurng();
 while (__u == 0.5);

 const _RealType __pi = 3.1415926535897932384626433832795029L;
 return __p.a() + __p.b() * std::tan(__pi * __u);
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      cauchy_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 const _RealType __pi = 3.1415926535897932384626433832795029L;
 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);
 while (__f != __t)
   {
     _RealType __u;
     do
       __u = __aurng();
     while (__u == 0.5);

     *__f++ = __p.a() + __p.b() * std::tan(__pi * __u);
   }
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const cauchy_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.a() << __space << __x.b();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        cauchy_distribution<_RealType>& __x)
    {
      using param_type = typename cauchy_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __a, __b;
      if (__is >> __a >> __b)
 __x.param(param_type(__a, __b));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      std::fisher_f_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng)
      {

 while (__f != __t)
   *__f++ = ((_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()));
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      std::fisher_f_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 typedef typename std::gamma_distribution<result_type>::param_type
   param_type;
 param_type __p1(__p.m() / 2);
 param_type __p2(__p.n() / 2);
 while (__f != __t)
   *__f++ = ((_M_gd_x(__urng, __p1) * n())
      / (_M_gd_y(__urng, __p2) * m()));
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const fisher_f_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.m() << __space << __x.n()
    << __space << __x._M_gd_x << __space << __x._M_gd_y;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        fisher_f_distribution<_RealType>& __x)
    {
      using param_type
 = typename fisher_f_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __m, __n;
      if (__is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y)
 __x.param(param_type(__m, __n));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      std::student_t_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng)
      {

 while (__f != __t)
   *__f++ = _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng));
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      std::student_t_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 typename std::gamma_distribution<result_type>::param_type
   __p2(__p.n() / 2, 2);
 while (__f != __t)
   *__f++ = _M_nd(__urng) * std::sqrt(__p.n() / _M_gd(__urng, __p2));
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const student_t_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.n() << __space << __x._M_nd << __space << __x._M_gd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        student_t_distribution<_RealType>& __x)
    {
      using param_type
 = typename student_t_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __n;
      if (__is >> __n >> __x._M_nd >> __x._M_gd)
 __x.param(param_type(__n));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    void
    gamma_distribution<_RealType>::param_type::
    _M_initialize()
    {
      _M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType(1.0) : _M_alpha;

      const _RealType __a1 = _M_malpha - _RealType(1.0) / _RealType(3.0);
      _M_a2 = _RealType(1.0) / std::sqrt(_RealType(9.0) * __a1);
    }






  template<typename _RealType>
    template<typename _UniformRandomNumberGenerator>
      typename gamma_distribution<_RealType>::result_type
      gamma_distribution<_RealType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);

 result_type __u, __v, __n;
 const result_type __a1 = (__param._M_malpha
      - _RealType(1.0) / _RealType(3.0));

 do
   {
     do
       {
  __n = _M_nd(__urng);
  __v = result_type(1.0) + __param._M_a2 * __n;
       }
     while (__v <= 0.0);

     __v = __v * __v * __v;
     __u = __aurng();
   }
 while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n
        && (std::log(__u) > (0.5 * __n * __n + __a1
        * (1.0 - __v + std::log(__v)))));

 if (__param.alpha() == __param._M_malpha)
   return __a1 * __v * __param.beta();
 else
   {
     do
       __u = __aurng();
     while (__u == 0.0);

     return (std::pow(__u, result_type(1.0) / __param.alpha())
      * __a1 * __v * __param.beta());
   }
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      gamma_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {

 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);

 result_type __u, __v, __n;
 const result_type __a1 = (__param._M_malpha
      - _RealType(1.0) / _RealType(3.0));

 if (__param.alpha() == __param._M_malpha)
   while (__f != __t)
     {
       do
  {
    do
      {
        __n = _M_nd(__urng);
        __v = result_type(1.0) + __param._M_a2 * __n;
      }
    while (__v <= 0.0);

    __v = __v * __v * __v;
    __u = __aurng();
  }
       while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n
       && (std::log(__u) > (0.5 * __n * __n + __a1
       * (1.0 - __v + std::log(__v)))));

       *__f++ = __a1 * __v * __param.beta();
     }
 else
   while (__f != __t)
     {
       do
  {
    do
      {
        __n = _M_nd(__urng);
        __v = result_type(1.0) + __param._M_a2 * __n;
      }
    while (__v <= 0.0);

    __v = __v * __v * __v;
    __u = __aurng();
  }
       while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n
       && (std::log(__u) > (0.5 * __n * __n + __a1
       * (1.0 - __v + std::log(__v)))));

       do
  __u = __aurng();
       while (__u == 0.0);

       *__f++ = (std::pow(__u, result_type(1.0) / __param.alpha())
   * __a1 * __v * __param.beta());
     }
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const gamma_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.alpha() << __space << __x.beta()
    << __space << __x._M_nd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        gamma_distribution<_RealType>& __x)
    {
      using param_type = typename gamma_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __alpha_val, __beta_val;
      if (__is >> __alpha_val >> __beta_val >> __x._M_nd)
 __x.param(param_type(__alpha_val, __beta_val));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _UniformRandomNumberGenerator>
      typename weibull_distribution<_RealType>::result_type
      weibull_distribution<_RealType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __p)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);
 return __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
      result_type(1) / __p.a());
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      weibull_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);
 auto __inv_a = result_type(1) / __p.a();

 while (__f != __t)
   *__f++ = __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
          __inv_a);
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const weibull_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.a() << __space << __x.b();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        weibull_distribution<_RealType>& __x)
    {
      using param_type = typename weibull_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __a, __b;
      if (__is >> __a >> __b)
 __x.param(param_type(__a, __b));

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    template<typename _UniformRandomNumberGenerator>
      typename extreme_value_distribution<_RealType>::result_type
      extreme_value_distribution<_RealType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __p)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);
 return __p.a() - __p.b() * std::log(-std::log(result_type(1)
            - __aurng()));
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      extreme_value_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __p)
      {

 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
   __aurng(__urng);

 while (__f != __t)
   *__f++ = __p.a() - __p.b() * std::log(-std::log(result_type(1)
         - __aurng()));
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const extreme_value_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.a() << __space << __x.b();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        extreme_value_distribution<_RealType>& __x)
    {
      using param_type
 = typename extreme_value_distribution<_RealType>::param_type;
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __a, __b;
      if (__is >> __a >> __b)
 __x.param(param_type(__a, __b));

      __is.flags(__flags);
      return __is;
    }


  template<typename _IntType>
    void
    discrete_distribution<_IntType>::param_type::
    _M_initialize()
    {
      if (_M_prob.size() < 2)
 {
   _M_prob.clear();
   return;
 }

      const double __sum = std::accumulate(_M_prob.begin(),
        _M_prob.end(), 0.0);

      __detail::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(),
       __sum);

      _M_cp.reserve(_M_prob.size());
      std::partial_sum(_M_prob.begin(), _M_prob.end(),
         std::back_inserter(_M_cp));

      _M_cp[_M_cp.size() - 1] = 1.0;
    }

  template<typename _IntType>
    template<typename _Func>
      discrete_distribution<_IntType>::param_type::
      param_type(size_t __nw, double __xmin, double __xmax, _Func __fw)
      : _M_prob(), _M_cp()
      {
 const size_t __n = __nw == 0 ? 1 : __nw;
 const double __delta = (__xmax - __xmin) / __n;

 _M_prob.reserve(__n);
 for (size_t __k = 0; __k < __nw; ++__k)
   _M_prob.push_back(__fw(__xmin + __k * __delta + 0.5 * __delta));

 _M_initialize();
      }

  template<typename _IntType>
    template<typename _UniformRandomNumberGenerator>
      typename discrete_distribution<_IntType>::result_type
      discrete_distribution<_IntType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 if (__param._M_cp.empty())
   return result_type(0);

 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 const double __p = __aurng();
 auto __pos = std::lower_bound(__param._M_cp.begin(),
          __param._M_cp.end(), __p);

 return __pos - __param._M_cp.begin();
      }

  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      discrete_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {


 if (__param._M_cp.empty())
   {
     while (__f != __t)
       *__f++ = result_type(0);
     return;
   }

 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 while (__f != __t)
   {
     const double __p = __aurng();
     auto __pos = std::lower_bound(__param._M_cp.begin(),
       __param._M_cp.end(), __p);

     *__f++ = __pos - __param._M_cp.begin();
   }
      }

  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const discrete_distribution<_IntType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<double>::max_digits10);

      std::vector<double> __prob = __x.probabilities();
      __os << __prob.size();
      for (auto __dit = __prob.begin(); __dit != __prob.end(); ++__dit)
 __os << __space << *__dit;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

namespace __detail
{
  template<typename _ValT, typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    __extract_params(basic_istream<_CharT, _Traits>& __is,
       vector<_ValT>& __vals, size_t __n)
    {
      __vals.reserve(__n);
      while (__n--)
 {
   _ValT __val;
   if (__is >> __val)
     __vals.push_back(__val);
   else
     break;
 }
      return __is;
    }
}

  template<typename _IntType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        discrete_distribution<_IntType>& __x)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      size_t __n;
      if (__is >> __n)
 {
   std::vector<double> __prob_vec;
   if (__detail::__extract_params(__is, __prob_vec, __n))
     __x.param({__prob_vec.begin(), __prob_vec.end()});
 }

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    void
    piecewise_constant_distribution<_RealType>::param_type::
    _M_initialize()
    {
      if (_M_int.size() < 2
   || (_M_int.size() == 2
       && _M_int[0] == _RealType(0)
       && _M_int[1] == _RealType(1)))
 {
   _M_int.clear();
   _M_den.clear();
   return;
 }

      const double __sum = std::accumulate(_M_den.begin(),
        _M_den.end(), 0.0);

      __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
       __sum);

      _M_cp.reserve(_M_den.size());
      std::partial_sum(_M_den.begin(), _M_den.end(),
         std::back_inserter(_M_cp));


      _M_cp[_M_cp.size() - 1] = 1.0;

      for (size_t __k = 0; __k < _M_den.size(); ++__k)
 _M_den[__k] /= _M_int[__k + 1] - _M_int[__k];
    }

  template<typename _RealType>
    template<typename _InputIteratorB, typename _InputIteratorW>
      piecewise_constant_distribution<_RealType>::param_type::
      param_type(_InputIteratorB __bbegin,
   _InputIteratorB __bend,
   _InputIteratorW __wbegin)
      : _M_int(), _M_den(), _M_cp()
      {
 if (__bbegin != __bend)
   {
     for (;;)
       {
  _M_int.push_back(*__bbegin);
  ++__bbegin;
  if (__bbegin == __bend)
    break;

  _M_den.push_back(*__wbegin);
  ++__wbegin;
       }
   }

 _M_initialize();
      }

  template<typename _RealType>
    template<typename _Func>
      piecewise_constant_distribution<_RealType>::param_type::
      param_type(initializer_list<_RealType> __bl, _Func __fw)
      : _M_int(), _M_den(), _M_cp()
      {
 _M_int.reserve(__bl.size());
 for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
   _M_int.push_back(*__biter);

 _M_den.reserve(_M_int.size() - 1);
 for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
   _M_den.push_back(__fw(0.5 * (_M_int[__k + 1] + _M_int[__k])));

 _M_initialize();
      }

  template<typename _RealType>
    template<typename _Func>
      piecewise_constant_distribution<_RealType>::param_type::
      param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
      : _M_int(), _M_den(), _M_cp()
      {
 const size_t __n = __nw == 0 ? 1 : __nw;
 const _RealType __delta = (__xmax - __xmin) / __n;

 _M_int.reserve(__n + 1);
 for (size_t __k = 0; __k <= __nw; ++__k)
   _M_int.push_back(__xmin + __k * __delta);

 _M_den.reserve(__n);
 for (size_t __k = 0; __k < __nw; ++__k)
   _M_den.push_back(__fw(_M_int[__k] + 0.5 * __delta));

 _M_initialize();
      }

  template<typename _RealType>
    template<typename _UniformRandomNumberGenerator>
      typename piecewise_constant_distribution<_RealType>::result_type
      piecewise_constant_distribution<_RealType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 const double __p = __aurng();
 if (__param._M_cp.empty())
   return __p;

 auto __pos = std::lower_bound(__param._M_cp.begin(),
          __param._M_cp.end(), __p);
 const size_t __i = __pos - __param._M_cp.begin();

 const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;

 return __param._M_int[__i] + (__p - __pref) / __param._M_den[__i];
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      piecewise_constant_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {

 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 if (__param._M_cp.empty())
   {
     while (__f != __t)
       *__f++ = __aurng();
     return;
   }

 while (__f != __t)
   {
     const double __p = __aurng();

     auto __pos = std::lower_bound(__param._M_cp.begin(),
       __param._M_cp.end(), __p);
     const size_t __i = __pos - __param._M_cp.begin();

     const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;

     *__f++ = (__param._M_int[__i]
        + (__p - __pref) / __param._M_den[__i]);
   }
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const piecewise_constant_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      std::vector<_RealType> __int = __x.intervals();
      __os << __int.size() - 1;

      for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
 __os << __space << *__xit;

      std::vector<double> __den = __x.densities();
      for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
 __os << __space << *__dit;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        piecewise_constant_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      size_t __n;
      if (__is >> __n)
 {
   std::vector<_RealType> __int_vec;
   if (__detail::__extract_params(__is, __int_vec, __n + 1))
     {
       std::vector<double> __den_vec;
       if (__detail::__extract_params(__is, __den_vec, __n))
  {
    __x.param({ __int_vec.begin(), __int_vec.end(),
         __den_vec.begin() });
  }
     }
 }

      __is.flags(__flags);
      return __is;
    }


  template<typename _RealType>
    void
    piecewise_linear_distribution<_RealType>::param_type::
    _M_initialize()
    {
      if (_M_int.size() < 2
   || (_M_int.size() == 2
       && _M_int[0] == _RealType(0)
       && _M_int[1] == _RealType(1)
       && _M_den[0] == _M_den[1]))
 {
   _M_int.clear();
   _M_den.clear();
   return;
 }

      double __sum = 0.0;
      _M_cp.reserve(_M_int.size() - 1);
      _M_m.reserve(_M_int.size() - 1);
      for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
 {
   const _RealType __delta = _M_int[__k + 1] - _M_int[__k];
   __sum += 0.5 * (_M_den[__k + 1] + _M_den[__k]) * __delta;
   _M_cp.push_back(__sum);
   _M_m.push_back((_M_den[__k + 1] - _M_den[__k]) / __delta);
 }


      __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
       __sum);

      __detail::__normalize(_M_cp.begin(), _M_cp.end(), _M_cp.begin(), __sum);

      __detail::__normalize(_M_m.begin(), _M_m.end(), _M_m.begin(), __sum);


      _M_cp[_M_cp.size() - 1] = 1.0;
     }

  template<typename _RealType>
    template<typename _InputIteratorB, typename _InputIteratorW>
      piecewise_linear_distribution<_RealType>::param_type::
      param_type(_InputIteratorB __bbegin,
   _InputIteratorB __bend,
   _InputIteratorW __wbegin)
      : _M_int(), _M_den(), _M_cp(), _M_m()
      {
 for (; __bbegin != __bend; ++__bbegin, ++__wbegin)
   {
     _M_int.push_back(*__bbegin);
     _M_den.push_back(*__wbegin);
   }

 _M_initialize();
      }

  template<typename _RealType>
    template<typename _Func>
      piecewise_linear_distribution<_RealType>::param_type::
      param_type(initializer_list<_RealType> __bl, _Func __fw)
      : _M_int(), _M_den(), _M_cp(), _M_m()
      {
 _M_int.reserve(__bl.size());
 _M_den.reserve(__bl.size());
 for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
   {
     _M_int.push_back(*__biter);
     _M_den.push_back(__fw(*__biter));
   }

 _M_initialize();
      }

  template<typename _RealType>
    template<typename _Func>
      piecewise_linear_distribution<_RealType>::param_type::
      param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
      : _M_int(), _M_den(), _M_cp(), _M_m()
      {
 const size_t __n = __nw == 0 ? 1 : __nw;
 const _RealType __delta = (__xmax - __xmin) / __n;

 _M_int.reserve(__n + 1);
 _M_den.reserve(__n + 1);
 for (size_t __k = 0; __k <= __nw; ++__k)
   {
     _M_int.push_back(__xmin + __k * __delta);
     _M_den.push_back(__fw(_M_int[__k] + __delta));
   }

 _M_initialize();
      }

  template<typename _RealType>
    template<typename _UniformRandomNumberGenerator>
      typename piecewise_linear_distribution<_RealType>::result_type
      piecewise_linear_distribution<_RealType>::
      operator()(_UniformRandomNumberGenerator& __urng,
   const param_type& __param)
      {
 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
   __aurng(__urng);

 const double __p = __aurng();
 if (__param._M_cp.empty())
   return __p;

 auto __pos = std::lower_bound(__param._M_cp.begin(),
          __param._M_cp.end(), __p);
 const size_t __i = __pos - __param._M_cp.begin();

 const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;

 const double __a = 0.5 * __param._M_m[__i];
 const double __b = __param._M_den[__i];
 const double __cm = __p - __pref;

 _RealType __x = __param._M_int[__i];
 if (__a == 0)
   __x += __cm / __b;
 else
   {
     const double __d = __b * __b + 4.0 * __a * __cm;
     __x += 0.5 * (std::sqrt(__d) - __b) / __a;
          }

        return __x;
      }

  template<typename _RealType>
    template<typename _ForwardIterator,
      typename _UniformRandomNumberGenerator>
      void
      piecewise_linear_distribution<_RealType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomNumberGenerator& __urng,
        const param_type& __param)
      {


 while (__f != __t)
   *__f++ = this->operator()(__urng, __param);
      }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const piecewise_linear_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();
      const _CharT __fill = __os.fill();
      const std::streamsize __precision = __os.precision();
      const _CharT __space = __os.widen(' ');
      __os.flags(__ios_base::scientific | __ios_base::left);
      __os.fill(__space);
      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      std::vector<_RealType> __int = __x.intervals();
      __os << __int.size() - 1;

      for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
 __os << __space << *__xit;

      std::vector<double> __den = __x.densities();
      for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
 __os << __space << *__dit;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template<typename _RealType, typename _CharT, typename _Traits>
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is,
        piecewise_linear_distribution<_RealType>& __x)
    {
      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();
      __is.flags(__ios_base::dec | __ios_base::skipws);

      size_t __n;
      if (__is >> __n)
 {
   vector<_RealType> __int_vec;
   if (__detail::__extract_params(__is, __int_vec, __n + 1))
     {
       vector<double> __den_vec;
       if (__detail::__extract_params(__is, __den_vec, __n + 1))
  {
    __x.param({ __int_vec.begin(), __int_vec.end(),
         __den_vec.begin() });
  }
     }
 }
      __is.flags(__flags);
      return __is;
    }


  template<typename _IntType>
    seed_seq::seed_seq(std::initializer_list<_IntType> __il)
    {
      for (auto __iter = __il.begin(); __iter != __il.end(); ++__iter)
 _M_v.push_back(__detail::__mod<result_type,
         __detail::_Shift<result_type, 32>::__value>(*__iter));
    }

  template<typename _InputIterator>
    seed_seq::seed_seq(_InputIterator __begin, _InputIterator __end)
    {
      for (_InputIterator __iter = __begin; __iter != __end; ++__iter)
 _M_v.push_back(__detail::__mod<result_type,
         __detail::_Shift<result_type, 32>::__value>(*__iter));
    }

  template<typename _RandomAccessIterator>
    void
    seed_seq::generate(_RandomAccessIterator __begin,
         _RandomAccessIterator __end)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
        _Type;

      if (__begin == __end)
 return;

      std::fill(__begin, __end, _Type(0x8b8b8b8bu));

      const size_t __n = __end - __begin;
      const size_t __s = _M_v.size();
      const size_t __t = (__n >= 623) ? 11
         : (__n >= 68) ? 7
         : (__n >= 39) ? 5
         : (__n >= 7) ? 3
         : (__n - 1) / 2;
      const size_t __p = (__n - __t) / 2;
      const size_t __q = __p + __t;
      const size_t __m = std::max(size_t(__s + 1), __n);

      for (size_t __k = 0; __k < __m; ++__k)
 {
   _Type __arg = (__begin[__k % __n]
    ^ __begin[(__k + __p) % __n]
    ^ __begin[(__k - 1) % __n]);
   _Type __r1 = __arg ^ (__arg >> 27);
   __r1 = __detail::__mod<_Type,
      __detail::_Shift<_Type, 32>::__value>(1664525u * __r1);
   _Type __r2 = __r1;
   if (__k == 0)
     __r2 += __s;
   else if (__k <= __s)
     __r2 += __k % __n + _M_v[__k - 1];
   else
     __r2 += __k % __n;
   __r2 = __detail::__mod<_Type,
            __detail::_Shift<_Type, 32>::__value>(__r2);
   __begin[(__k + __p) % __n] += __r1;
   __begin[(__k + __q) % __n] += __r2;
   __begin[__k % __n] = __r2;
 }

      for (size_t __k = __m; __k < __m + __n; ++__k)
 {
   _Type __arg = (__begin[__k % __n]
    + __begin[(__k + __p) % __n]
    + __begin[(__k - 1) % __n]);
   _Type __r3 = __arg ^ (__arg >> 27);
   __r3 = __detail::__mod<_Type,
     __detail::_Shift<_Type, 32>::__value>(1566083941u * __r3);
   _Type __r4 = __r3 - __k % __n;
   __r4 = __detail::__mod<_Type,
            __detail::_Shift<_Type, 32>::__value>(__r4);
   __begin[(__k + __p) % __n] ^= __r3;
   __begin[(__k + __q) % __n] ^= __r4;
   __begin[__k % __n] = __r4;
 }
    }

  template<typename _RealType, size_t __bits,
    typename _UniformRandomNumberGenerator>
    _RealType
    generate_canonical(_UniformRandomNumberGenerator& __urng)
    {
      static_assert(std::is_floating_point<_RealType>::value,
      "template argument must be a floating point type");

      const size_t __b
 = std::min(static_cast<size_t>(std::numeric_limits<_RealType>::digits),
                   __bits);
      const long double __r = static_cast<long double>(__urng.max())
       - static_cast<long double>(__urng.min()) + 1.0L;
      const size_t __log2r = std::log(__r) / std::log(2.0L);
      const size_t __m = std::max<size_t>(1UL,
       (__b + __log2r - 1UL) / __log2r);
      _RealType __ret;
      _RealType __sum = _RealType(0);
      _RealType __tmp = _RealType(1);
      for (size_t __k = __m; __k != 0; --__k)
 {
   __sum += _RealType(__urng() - __urng.min()) * __tmp;
   __tmp *= __r;
 }
      __ret = __sum / __tmp;
      if (__builtin_expect(__ret >= _RealType(1), 0))
 {

   __ret = std::nextafter(_RealType(1), _RealType(0));




 }
      return __ret;
    }


}
# 52 "/usr/include/c++/10/random" 2 3
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/config.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/config.hpp" 3 4
       
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid.hpp" 2 3 4






       
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid.hpp" 3 4
namespace boost {
namespace uuids {

struct uuid
{
public:
    typedef uint8_t value_type;
    typedef uint8_t& reference;
    typedef uint8_t const& const_reference;
    typedef uint8_t* iterator;
    typedef uint8_t const* const_iterator;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;





    static constexpr size_type static_size() noexcept { return 16; }

public:
    iterator begin() noexcept { return data; }
    const_iterator begin() const noexcept { return data; }
    iterator end() noexcept { return data+size(); }
    const_iterator end() const noexcept { return data+size(); }

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

    bool is_nil() const noexcept;

    enum variant_type
    {
        variant_ncs,
        variant_rfc_4122,
        variant_microsoft,
        variant_future
    };
    variant_type variant() const noexcept
    {


        unsigned char octet7 = data[8];
        if ( (octet7 & 0x80) == 0x00 ) {
            return variant_ncs;
        } else if ( (octet7 & 0xC0) == 0x80 ) {
            return variant_rfc_4122;
        } else if ( (octet7 & 0xE0) == 0xC0 ) {
            return variant_microsoft;
        } else {

            return variant_future;
        }
    }

    enum version_type
    {
        version_unknown = -1,
        version_time_based = 1,
        version_dce_security = 2,
        version_name_based_md5 = 3,
        version_random_number_based = 4,
        version_name_based_sha1 = 5
    };
    version_type version() const noexcept
    {


        uint8_t octet9 = data[6];
        if ( (octet9 & 0xF0) == 0x10 ) {
            return version_time_based;
        } else if ( (octet9 & 0xF0) == 0x20 ) {
            return version_dce_security;
        } else if ( (octet9 & 0xF0) == 0x30 ) {
            return version_name_based_md5;
        } else if ( (octet9 & 0xF0) == 0x40 ) {
            return version_random_number_based;
        } else if ( (octet9 & 0xF0) == 0x50 ) {
            return version_name_based_sha1;
        } else {
            return version_unknown;
        }
    }


    void swap(uuid& rhs) noexcept;

public:

    uint8_t data[16];
};

bool operator== (uuid const& lhs, uuid const& rhs) noexcept;
bool operator< (uuid const& lhs, uuid const& rhs) noexcept;

inline bool operator!=(uuid const& lhs, uuid const& rhs) noexcept
{
    return !(lhs == rhs);
}

inline bool operator>(uuid const& lhs, uuid const& rhs) noexcept
{
    return rhs < lhs;
}
inline bool operator<=(uuid const& lhs, uuid const& rhs) noexcept
{
    return !(rhs < lhs);
}

inline bool operator>=(uuid const& lhs, uuid const& rhs) noexcept
{
    return !(lhs < rhs);
}

inline void swap(uuid& lhs, uuid& rhs) noexcept
{
    lhs.swap(rhs);
}


inline std::size_t hash_value(uuid const& u) noexcept
{
    std::size_t seed = 0;
    for(uuid::const_iterator i=u.begin(), e=u.end(); i != e; ++i)
    {
        seed ^= static_cast<std::size_t>(*i) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    }

    return seed;
}

}}



namespace boost {

template <>
struct is_pod<uuids::uuid> : true_type {};

}



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/uuid_x86.ipp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/uuid_x86.ipp" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 1 3 4
# 31 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 1 3 4
# 31 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/mmintrin.h" 1 3 4
# 44 "/usr/lib/gcc/x86_64-redhat-linux/10/include/mmintrin.h" 3 4
typedef int __m64 __attribute__ ((__vector_size__ (8), __may_alias__));


typedef int __m64_u __attribute__ ((__vector_size__ (8), __may_alias__, __aligned__ (1)));


typedef int __v2si __attribute__ ((__vector_size__ (8)));
typedef short __v4hi __attribute__ ((__vector_size__ (8)));
typedef char __v8qi __attribute__ ((__vector_size__ (8)));
typedef long long __v1di __attribute__ ((__vector_size__ (8)));
typedef float __v2sf __attribute__ ((__vector_size__ (8)));


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_empty (void)
{
  __builtin_ia32_emms ();
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_empty (void)
{
  _mm_empty ();
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si64 (int __i)
{
  return (__m64) __builtin_ia32_vec_init_v2si (__i, 0);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int (int __i)
{
  return _mm_cvtsi32_si64 (__i);
}





extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_from_int64 (long long __i)
{
  return (__m64) __i;
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_m64 (long long __i)
{
  return (__m64) __i;
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si64 (long long __i)
{
  return (__m64) __i;
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi64x (long long __i)
{
  return (__m64) __i;
}



extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si32 (__m64 __i)
{
  return __builtin_ia32_vec_ext_v2si ((__v2si)__i, 0);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int (__m64 __i)
{
  return _mm_cvtsi64_si32 (__i);
}





extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_to_int64 (__m64 __i)
{
  return (long long)__i;
}

extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtm64_si64 (__m64 __i)
{
  return (long long)__i;
}


extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si64x (__m64 __i)
{
  return (long long)__i;
}





extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_packsswb ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packsswb (__m64 __m1, __m64 __m2)
{
  return _mm_packs_pi16 (__m1, __m2);
}




extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pi32 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_packssdw ((__v2si)__m1, (__v2si)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packssdw (__m64 __m1, __m64 __m2)
{
  return _mm_packs_pi32 (__m1, __m2);
}




extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_pu16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_packuswb ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_packuswb (__m64 __m1, __m64 __m2)
{
  return _mm_packs_pu16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_punpckhbw ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhbw (__m64 __m1, __m64 __m2)
{
  return _mm_unpackhi_pi8 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_punpckhwd ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhwd (__m64 __m1, __m64 __m2)
{
  return _mm_unpackhi_pi16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pi32 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_punpckhdq ((__v2si)__m1, (__v2si)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckhdq (__m64 __m1, __m64 __m2)
{
  return _mm_unpackhi_pi32 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_punpcklbw ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklbw (__m64 __m1, __m64 __m2)
{
  return _mm_unpacklo_pi8 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_punpcklwd ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpcklwd (__m64 __m1, __m64 __m2)
{
  return _mm_unpacklo_pi16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pi32 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_punpckldq ((__v2si)__m1, (__v2si)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_punpckldq (__m64 __m1, __m64 __m2)
{
  return _mm_unpacklo_pi32 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddb (__m64 __m1, __m64 __m2)
{
  return _mm_add_pi8 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddw (__m64 __m1, __m64 __m2)
{
  return _mm_add_pi16 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pi32 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddd ((__v2si)__m1, (__v2si)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddd (__m64 __m1, __m64 __m2)
{
  return _mm_add_pi32 (__m1, __m2);
}
# 328 "/usr/lib/gcc/x86_64-redhat-linux/10/include/mmintrin.h" 3 4
extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_si64 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddq ((__v1di)__m1, (__v1di)__m2);
}







extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddsb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsb (__m64 __m1, __m64 __m2)
{
  return _mm_adds_pi8 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddsw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddsw (__m64 __m1, __m64 __m2)
{
  return _mm_adds_pi16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddusb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusb (__m64 __m1, __m64 __m2)
{
  return _mm_adds_pu8 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_pu16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_paddusw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_paddusw (__m64 __m1, __m64 __m2)
{
  return _mm_adds_pu16 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubb (__m64 __m1, __m64 __m2)
{
  return _mm_sub_pi8 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubw (__m64 __m1, __m64 __m2)
{
  return _mm_sub_pi16 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pi32 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubd ((__v2si)__m1, (__v2si)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubd (__m64 __m1, __m64 __m2)
{
  return _mm_sub_pi32 (__m1, __m2);
}
# 444 "/usr/lib/gcc/x86_64-redhat-linux/10/include/mmintrin.h" 3 4
extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_si64 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubq ((__v1di)__m1, (__v1di)__m2);
}







extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubsb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsb (__m64 __m1, __m64 __m2)
{
  return _mm_subs_pi8 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubsw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubsw (__m64 __m1, __m64 __m2)
{
  return _mm_subs_pi16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubusb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusb (__m64 __m1, __m64 __m2)
{
  return _mm_subs_pu8 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_pu16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_psubusw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psubusw (__m64 __m1, __m64 __m2)
{
  return _mm_subs_pu16 (__m1, __m2);
}




extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pmaddwd ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaddwd (__m64 __m1, __m64 __m2)
{
  return _mm_madd_pi16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pmulhw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhw (__m64 __m1, __m64 __m2)
{
  return _mm_mulhi_pi16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pmullw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmullw (__m64 __m1, __m64 __m2)
{
  return _mm_mullo_pi16 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi16 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_psllw ((__v4hi)__m, (__v4hi)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllw (__m64 __m, __m64 __count)
{
  return _mm_sll_pi16 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi16 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_psllwi ((__v4hi)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllwi (__m64 __m, int __count)
{
  return _mm_slli_pi16 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_pi32 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_pslld ((__v2si)__m, (__v2si)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslld (__m64 __m, __m64 __count)
{
  return _mm_sll_pi32 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_pi32 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_pslldi ((__v2si)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pslldi (__m64 __m, int __count)
{
  return _mm_slli_pi32 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_si64 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_psllq ((__v1di)__m, (__v1di)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllq (__m64 __m, __m64 __count)
{
  return _mm_sll_si64 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_si64 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_psllqi ((__v1di)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psllqi (__m64 __m, int __count)
{
  return _mm_slli_si64 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi16 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_psraw ((__v4hi)__m, (__v4hi)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psraw (__m64 __m, __m64 __count)
{
  return _mm_sra_pi16 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi16 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_psrawi ((__v4hi)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrawi (__m64 __m, int __count)
{
  return _mm_srai_pi16 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_pi32 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_psrad ((__v2si)__m, (__v2si)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrad (__m64 __m, __m64 __count)
{
  return _mm_sra_pi32 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_pi32 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_psradi ((__v2si)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psradi (__m64 __m, int __count)
{
  return _mm_srai_pi32 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi16 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_psrlw ((__v4hi)__m, (__v4hi)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlw (__m64 __m, __m64 __count)
{
  return _mm_srl_pi16 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi16 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_psrlwi ((__v4hi)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlwi (__m64 __m, int __count)
{
  return _mm_srli_pi16 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_pi32 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_psrld ((__v2si)__m, (__v2si)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrld (__m64 __m, __m64 __count)
{
  return _mm_srl_pi32 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_pi32 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_psrldi ((__v2si)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrldi (__m64 __m, int __count)
{
  return _mm_srli_pi32 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_si64 (__m64 __m, __m64 __count)
{
  return (__m64) __builtin_ia32_psrlq ((__v1di)__m, (__v1di)__count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlq (__m64 __m, __m64 __count)
{
  return _mm_srl_si64 (__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_si64 (__m64 __m, int __count)
{
  return (__m64) __builtin_ia32_psrlqi ((__v1di)__m, __count);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psrlqi (__m64 __m, int __count)
{
  return _mm_srli_si64 (__m, __count);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si64 (__m64 __m1, __m64 __m2)
{
  return __builtin_ia32_pand (__m1, __m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pand (__m64 __m1, __m64 __m2)
{
  return _mm_and_si64 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si64 (__m64 __m1, __m64 __m2)
{
  return __builtin_ia32_pandn (__m1, __m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pandn (__m64 __m1, __m64 __m2)
{
  return _mm_andnot_si64 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si64 (__m64 __m1, __m64 __m2)
{
  return __builtin_ia32_por (__m1, __m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_por (__m64 __m1, __m64 __m2)
{
  return _mm_or_si64 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si64 (__m64 __m1, __m64 __m2)
{
  return __builtin_ia32_pxor (__m1, __m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pxor (__m64 __m1, __m64 __m2)
{
  return _mm_xor_si64 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pcmpeqb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqb (__m64 __m1, __m64 __m2)
{
  return _mm_cmpeq_pi8 (__m1, __m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi8 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pcmpgtb ((__v8qi)__m1, (__v8qi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtb (__m64 __m1, __m64 __m2)
{
  return _mm_cmpgt_pi8 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pcmpeqw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqw (__m64 __m1, __m64 __m2)
{
  return _mm_cmpeq_pi16 (__m1, __m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi16 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pcmpgtw ((__v4hi)__m1, (__v4hi)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtw (__m64 __m1, __m64 __m2)
{
  return _mm_cmpgt_pi16 (__m1, __m2);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pi32 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pcmpeqd ((__v2si)__m1, (__v2si)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpeqd (__m64 __m1, __m64 __m2)
{
  return _mm_cmpeq_pi32 (__m1, __m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pi32 (__m64 __m1, __m64 __m2)
{
  return (__m64) __builtin_ia32_pcmpgtd ((__v2si)__m1, (__v2si)__m2);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pcmpgtd (__m64 __m1, __m64 __m2)
{
  return _mm_cmpgt_pi32 (__m1, __m2);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si64 (void)
{
  return (__m64)0LL;
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi32 (int __i1, int __i0)
{
  return (__m64) __builtin_ia32_vec_init_v2si (__i0, __i1);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pi16 (short __w3, short __w2, short __w1, short __w0)
{
  return (__m64) __builtin_ia32_vec_init_v4hi (__w0, __w1, __w2, __w3);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_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);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi32 (int __i0, int __i1)
{
  return _mm_set_pi32 (__i1, __i0);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pi16 (short __w0, short __w1, short __w2, short __w3)
{
  return _mm_set_pi16 (__w3, __w2, __w1, __w0);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_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);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi32 (int __i)
{
  return _mm_set_pi32 (__i, __i);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi16 (short __w)
{
  return _mm_set_pi16 (__w, __w, __w, __w);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pi8 (char __b)
{
  return _mm_set_pi8 (__b, __b, __b, __b, __b, __b, __b, __b);
}
# 32 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 2 3 4


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/mm_malloc.h" 1 3 4
# 27 "/usr/lib/gcc/x86_64-redhat-linux/10/include/mm_malloc.h" 3 4
# 1 "/usr/include/c++/10/stdlib.h" 1 3 4
# 28 "/usr/lib/gcc/x86_64-redhat-linux/10/include/mm_malloc.h" 2 3 4






extern "C" int posix_memalign (void **, size_t, size_t) throw ();


static __inline void *
_mm_malloc (size_t __size, size_t __alignment)
{
  void *__ptr;
  if (__alignment == 1)
    return malloc (__size);
  if (__alignment == 2 || (sizeof (void *) == 8 && __alignment == 4))
    __alignment = sizeof (void *);
  if (posix_memalign (&__ptr, __alignment, __size) == 0)
    return __ptr;
  else
    return __null;
}

static __inline void
_mm_free (void *__ptr)
{
  free (__ptr);
}
# 35 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 2 3 4


enum _mm_hint
{

  _MM_HINT_ET0 = 7,
  _MM_HINT_ET1 = 6,
  _MM_HINT_T0 = 3,
  _MM_HINT_T1 = 2,
  _MM_HINT_T2 = 1,
  _MM_HINT_NTA = 0
};




extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_prefetch (const void *__P, enum _mm_hint __I)
{
  __builtin_prefetch (__P, (__I & 0x4) >> 2, __I & 0x3);
}
# 69 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));


typedef float __m128_u __attribute__ ((__vector_size__ (16), __may_alias__, __aligned__ (1)));


typedef float __v4sf __attribute__ ((__vector_size__ (16)));
# 109 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_ps (void)
{
  __m128 __Y = __Y;
  return __Y;
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_ps (void)
{
  return __extension__ (__m128){ 0.0f, 0.0f, 0.0f, 0.0f };
}





extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_addss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_subss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_mulss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_divss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ss (__m128 __A)
{
  return (__m128) __builtin_ia32_sqrtss ((__v4sf)__A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ss (__m128 __A)
{
  return (__m128) __builtin_ia32_rcpss ((__v4sf)__A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ss (__m128 __A)
{
  return (__m128) __builtin_ia32_rsqrtss ((__v4sf)__A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_minss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_maxss ((__v4sf)__A, (__v4sf)__B);
}



extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_ps (__m128 __A, __m128 __B)
{
  return (__m128) ((__v4sf)__A + (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_ps (__m128 __A, __m128 __B)
{
  return (__m128) ((__v4sf)__A - (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_ps (__m128 __A, __m128 __B)
{
  return (__m128) ((__v4sf)__A * (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_ps (__m128 __A, __m128 __B)
{
  return (__m128) ((__v4sf)__A / (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_ps (__m128 __A)
{
  return (__m128) __builtin_ia32_sqrtps ((__v4sf)__A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rcp_ps (__m128 __A)
{
  return (__m128) __builtin_ia32_rcpps ((__v4sf)__A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_rsqrt_ps (__m128 __A)
{
  return (__m128) __builtin_ia32_rsqrtps ((__v4sf)__A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_minps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_maxps ((__v4sf)__A, (__v4sf)__B);
}



extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_ps (__m128 __A, __m128 __B)
{
  return __builtin_ia32_andps (__A, __B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_ps (__m128 __A, __m128 __B)
{
  return __builtin_ia32_andnps (__A, __B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_ps (__m128 __A, __m128 __B)
{
  return __builtin_ia32_orps (__A, __B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_ps (__m128 __A, __m128 __B)
{
  return __builtin_ia32_xorps (__A, __B);
}





extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpeqss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpltss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpless ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_movss ((__v4sf) __A,
     (__v4sf)
     __builtin_ia32_cmpltss ((__v4sf) __B,
        (__v4sf)
        __A));
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_movss ((__v4sf) __A,
     (__v4sf)
     __builtin_ia32_cmpless ((__v4sf) __B,
        (__v4sf)
        __A));
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpneqss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpnltss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpnless ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_movss ((__v4sf) __A,
     (__v4sf)
     __builtin_ia32_cmpnltss ((__v4sf) __B,
         (__v4sf)
         __A));
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_movss ((__v4sf) __A,
     (__v4sf)
     __builtin_ia32_cmpnless ((__v4sf) __B,
         (__v4sf)
         __A));
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpordss ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpunordss ((__v4sf)__A, (__v4sf)__B);
}





extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpeqps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpltps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpleps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpgtps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpgeps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpneqps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpnltps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpnleps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpngtps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpngeps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpordps ((__v4sf)__A, (__v4sf)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_cmpunordps ((__v4sf)__A, (__v4sf)__B);
}




extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_comieq ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_comilt ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_comile ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_comigt ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_comige ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_comineq ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_ucomieq ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_ucomilt ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_ucomile ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_ucomigt ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_ucomige ((__v4sf)__A, (__v4sf)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_ss (__m128 __A, __m128 __B)
{
  return __builtin_ia32_ucomineq ((__v4sf)__A, (__v4sf)__B);
}



extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si32 (__m128 __A)
{
  return __builtin_ia32_cvtss2si ((__v4sf) __A);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ss2si (__m128 __A)
{
  return _mm_cvtss_si32 (__A);
}






extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64 (__m128 __A)
{
  return __builtin_ia32_cvtss2si64 ((__v4sf) __A);
}


extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_si64x (__m128 __A)
{
  return __builtin_ia32_cvtss2si64 ((__v4sf) __A);
}




extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi32 (__m128 __A)
{
  return (__m64) __builtin_ia32_cvtps2pi ((__v4sf) __A);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_ps2pi (__m128 __A)
{
  return _mm_cvtps_pi32 (__A);
}


extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si32 (__m128 __A)
{
  return __builtin_ia32_cvttss2si ((__v4sf) __A);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ss2si (__m128 __A)
{
  return _mm_cvttss_si32 (__A);
}





extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64 (__m128 __A)
{
  return __builtin_ia32_cvttss2si64 ((__v4sf) __A);
}


extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttss_si64x (__m128 __A)
{
  return __builtin_ia32_cvttss2si64 ((__v4sf) __A);
}




extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_pi32 (__m128 __A)
{
  return (__m64) __builtin_ia32_cvttps2pi ((__v4sf) __A);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtt_ps2pi (__m128 __A)
{
  return _mm_cvttps_pi32 (__A);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_ss (__m128 __A, int __B)
{
  return (__m128) __builtin_ia32_cvtsi2ss ((__v4sf) __A, __B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_si2ss (__m128 __A, int __B)
{
  return _mm_cvtsi32_ss (__A, __B);
}





extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_ss (__m128 __A, long long __B)
{
  return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_ss (__m128 __A, long long __B)
{
  return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
}




extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_ps (__m128 __A, __m64 __B)
{
  return (__m128) __builtin_ia32_cvtpi2ps ((__v4sf) __A, (__v2si)__B);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvt_pi2ps (__m128 __A, __m64 __B)
{
  return _mm_cvtpi32_ps (__A, __B);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi16_ps (__m64 __A)
{
  __v4hi __sign;
  __v2si __hisi, __losi;
  __v4sf __zero, __ra, __rb;




  __sign = __builtin_ia32_pcmpgtw ((__v4hi)0LL, (__v4hi)__A);


  __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, __sign);
  __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, __sign);


  __zero = (__v4sf) _mm_setzero_ps ();
  __ra = __builtin_ia32_cvtpi2ps (__zero, __losi);
  __rb = __builtin_ia32_cvtpi2ps (__ra, __hisi);

  return (__m128) __builtin_ia32_movlhps (__ra, __rb);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu16_ps (__m64 __A)
{
  __v2si __hisi, __losi;
  __v4sf __zero, __ra, __rb;


  __losi = (__v2si) __builtin_ia32_punpcklwd ((__v4hi)__A, (__v4hi)0LL);
  __hisi = (__v2si) __builtin_ia32_punpckhwd ((__v4hi)__A, (__v4hi)0LL);


  __zero = (__v4sf) _mm_setzero_ps ();
  __ra = __builtin_ia32_cvtpi2ps (__zero, __losi);
  __rb = __builtin_ia32_cvtpi2ps (__ra, __hisi);

  return (__m128) __builtin_ia32_movlhps (__ra, __rb);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi8_ps (__m64 __A)
{
  __v8qi __sign;




  __sign = __builtin_ia32_pcmpgtb ((__v8qi)0LL, (__v8qi)__A);


  __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, __sign);

  return _mm_cvtpi16_ps(__A);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpu8_ps(__m64 __A)
{
  __A = (__m64) __builtin_ia32_punpcklbw ((__v8qi)__A, (__v8qi)0LL);
  return _mm_cvtpu16_ps(__A);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32x2_ps(__m64 __A, __m64 __B)
{
  __v4sf __zero = (__v4sf) _mm_setzero_ps ();
  __v4sf __sfa = __builtin_ia32_cvtpi2ps (__zero, (__v2si)__A);
  __v4sf __sfb = __builtin_ia32_cvtpi2ps (__sfa, (__v2si)__B);
  return (__m128) __builtin_ia32_movlhps (__sfa, __sfb);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi16(__m128 __A)
{
  __v4sf __hisf = (__v4sf)__A;
  __v4sf __losf = __builtin_ia32_movhlps (__hisf, __hisf);
  __v2si __hisi = __builtin_ia32_cvtps2pi (__hisf);
  __v2si __losi = __builtin_ia32_cvtps2pi (__losf);
  return (__m64) __builtin_ia32_packssdw (__hisi, __losi);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pi8(__m128 __A)
{
  __v4hi __tmp = (__v4hi) _mm_cvtps_pi16 (__A);
  return (__m64) __builtin_ia32_packsswb (__tmp, (__v4hi)0LL);
}



extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_ps (__m128 __A, __m128 __B, int const __mask)
{
  return (__m128) __builtin_ia32_shufps ((__v4sf)__A, (__v4sf)__B, __mask);
}







extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_unpckhps ((__v4sf)__A, (__v4sf)__B);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_unpcklps ((__v4sf)__A, (__v4sf)__B);
}



extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pi (__m128 __A, __m64 const *__P)
{
  return (__m128) __builtin_ia32_loadhps ((__v4sf)__A, (const __v2sf *)__P);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pi (__m64 *__P, __m128 __A)
{
  __builtin_ia32_storehps ((__v2sf *)__P, (__v4sf)__A);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movehl_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_movhlps ((__v4sf)__A, (__v4sf)__B);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movelh_ps (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_ia32_movlhps ((__v4sf)__A, (__v4sf)__B);
}



extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pi (__m128 __A, __m64 const *__P)
{
  return (__m128) __builtin_ia32_loadlps ((__v4sf)__A, (const __v2sf *)__P);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pi (__m64 *__P, __m128 __A)
{
  __builtin_ia32_storelps ((__v2sf *)__P, (__v4sf)__A);
}


extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_ps (__m128 __A)
{
  return __builtin_ia32_movmskps ((__v4sf)__A);
}


extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_getcsr (void)
{
  return __builtin_ia32_stmxcsr ();
}


extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_STATE (void)
{
  return _mm_getcsr() & 0x003f;
}

extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_EXCEPTION_MASK (void)
{
  return _mm_getcsr() & 0x1f80;
}

extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_ROUNDING_MODE (void)
{
  return _mm_getcsr() & 0x6000;
}

extern __inline unsigned int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_GET_FLUSH_ZERO_MODE (void)
{
  return _mm_getcsr() & 0x8000;
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setcsr (unsigned int __I)
{
  __builtin_ia32_ldmxcsr (__I);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_STATE(unsigned int __mask)
{
  _mm_setcsr((_mm_getcsr() & ~0x003f) | __mask);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_EXCEPTION_MASK (unsigned int __mask)
{
  _mm_setcsr((_mm_getcsr() & ~0x1f80) | __mask);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_ROUNDING_MODE (unsigned int __mode)
{
  _mm_setcsr((_mm_getcsr() & ~0x6000) | __mode);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_MM_SET_FLUSH_ZERO_MODE (unsigned int __mode)
{
  _mm_setcsr((_mm_getcsr() & ~0x8000) | __mode);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ss (float __F)
{
  return __extension__ (__m128)(__v4sf){ __F, 0.0f, 0.0f, 0.0f };
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_ps (float __F)
{
  return __extension__ (__m128)(__v4sf){ __F, __F, __F, __F };
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps1 (float __F)
{
  return _mm_set1_ps (__F);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ss (float const *__P)
{
  return _mm_set_ss (*__P);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_ps (float const *__P)
{
  return _mm_set1_ps (*__P);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps1 (float const *__P)
{
  return _mm_load1_ps (__P);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_ps (float const *__P)
{
  return *(__m128 *)__P;
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_ps (float const *__P)
{
  return *(__m128_u *)__P;
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_ps (float const *__P)
{
  __v4sf __tmp = *(__v4sf *)__P;
  return (__m128) __builtin_ia32_shufps (__tmp, __tmp, (((0) << 6) | ((1) << 4) | ((2) << 2) | (3)));
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_ps (const float __Z, const float __Y, const float __X, const float __W)
{
  return __extension__ (__m128)(__v4sf){ __W, __X, __Y, __Z };
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_ps (float __Z, float __Y, float __X, float __W)
{
  return __extension__ (__m128)(__v4sf){ __Z, __Y, __X, __W };
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ss (float *__P, __m128 __A)
{
  *__P = ((__v4sf)__A)[0];
}

extern __inline float __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_f32 (__m128 __A)
{
  return ((__v4sf)__A)[0];
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps (float *__P, __m128 __A)
{
  *(__m128 *)__P = __A;
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_ps (float *__P, __m128 __A)
{
  *(__m128_u *)__P = __A;
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_ps (float *__P, __m128 __A)
{
  __v4sf __va = (__v4sf)__A;
  __v4sf __tmp = __builtin_ia32_shufps (__va, __va, (((0) << 6) | ((0) << 4) | ((0) << 2) | (0)));
  _mm_storeu_ps (__P, __tmp);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_ps1 (float *__P, __m128 __A)
{
  _mm_store1_ps (__P, __A);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_ps (float *__P, __m128 __A)
{
  __v4sf __va = (__v4sf)__A;
  __v4sf __tmp = __builtin_ia32_shufps (__va, __va, (((0) << 6) | ((1) << 4) | ((2) << 2) | (3)));
  _mm_store_ps (__P, __tmp);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_ss (__m128 __A, __m128 __B)
{
  return (__m128) __builtin_shuffle ((__v4sf)__A, (__v4sf)__B,
                                     __extension__
                                     (__attribute__((__vector_size__ (16))) int)
                                     {4,1,2,3});
}



extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_extract_pi16 (__m64 const __A, int const __N)
{
  return __builtin_ia32_vec_ext_v4hi ((__v4hi)__A, __N);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pextrw (__m64 const __A, int const __N)
{
  return _mm_extract_pi16 (__A, __N);
}
# 1043 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_insert_pi16 (__m64 const __A, int const __D, int const __N)
{
  return (__m64) __builtin_ia32_vec_set_v4hi ((__v4hi)__A, __D, __N);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pinsrw (__m64 const __A, int const __D, int const __N)
{
  return _mm_insert_pi16 (__A, __D, __N);
}
# 1063 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pi16 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_pmaxsw ((__v4hi)__A, (__v4hi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxsw (__m64 __A, __m64 __B)
{
  return _mm_max_pi16 (__A, __B);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pu8 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_pmaxub ((__v8qi)__A, (__v8qi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmaxub (__m64 __A, __m64 __B)
{
  return _mm_max_pu8 (__A, __B);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pi16 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_pminsw ((__v4hi)__A, (__v4hi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminsw (__m64 __A, __m64 __B)
{
  return _mm_min_pi16 (__A, __B);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pu8 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_pminub ((__v8qi)__A, (__v8qi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pminub (__m64 __A, __m64 __B)
{
  return _mm_min_pu8 (__A, __B);
}


extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pi8 (__m64 __A)
{
  return __builtin_ia32_pmovmskb ((__v8qi)__A);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmovmskb (__m64 __A)
{
  return _mm_movemask_pi8 (__A);
}



extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_pu16 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_pmulhuw ((__v4hi)__A, (__v4hi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pmulhuw (__m64 __A, __m64 __B)
{
  return _mm_mulhi_pu16 (__A, __B);
}




extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_pi16 (__m64 __A, int const __N)
{
  return (__m64) __builtin_ia32_pshufw ((__v4hi)__A, __N);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pshufw (__m64 __A, int const __N)
{
  return _mm_shuffle_pi16 (__A, __N);
}
# 1165 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmove_si64 (__m64 __A, __m64 __N, char *__P)
{



  typedef long long __v2di __attribute__ ((__vector_size__ (16)));
  typedef char __v16qi __attribute__ ((__vector_size__ (16)));

  __v2di __A128 = __extension__ (__v2di) { ((__v1di) __A)[0], 0 };
  __v2di __N128 = __extension__ (__v2di) { ((__v1di) __N)[0], 0 };


  long unsigned int offset = ((long unsigned int) __P) & 0xf;
  if (offset)
    {


      if (offset > 8)
 offset = 8;
      __P = (char *) (((long unsigned int) __P) - offset);


      switch (offset)
 {
 case 1:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 8);
   break;
 case 2:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 2 * 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 2 * 8);
   break;
 case 3:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 3 * 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 3 * 8);
   break;
 case 4:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 4 * 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 4 * 8);
   break;
 case 5:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 5 * 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 5 * 8);
   break;
 case 6:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 6 * 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 6 * 8);
   break;
 case 7:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 7 * 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 7 * 8);
   break;
 case 8:
   __A128 = __builtin_ia32_pslldqi128 (__A128, 8 * 8);
   __N128 = __builtin_ia32_pslldqi128 (__N128, 8 * 8);
   break;
 default:
   break;
 }
    }
  __builtin_ia32_maskmovdqu ((__v16qi)__A128, (__v16qi)__N128, __P);



}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_maskmovq (__m64 __A, __m64 __N, char *__P)
{
  _mm_maskmove_si64 (__A, __N, __P);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu8 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_pavgb ((__v8qi)__A, (__v8qi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgb (__m64 __A, __m64 __B)
{
  return _mm_avg_pu8 (__A, __B);
}


extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_pu16 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_pavgw ((__v4hi)__A, (__v4hi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_pavgw (__m64 __A, __m64 __B)
{
  return _mm_avg_pu16 (__A, __B);
}




extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_pu8 (__m64 __A, __m64 __B)
{
  return (__m64) __builtin_ia32_psadbw ((__v8qi)__A, (__v8qi)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_m_psadbw (__m64 __A, __m64 __B)
{
  return _mm_sad_pu8 (__A, __B);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pi (__m64 *__P, __m64 __A)
{
  __builtin_ia32_movntq ((unsigned long long *)__P, (unsigned long long)__A);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_ps (float *__P, __m128 __A)
{
  __builtin_ia32_movntps (__P, (__v4sf)__A);
}



extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sfence (void)
{
  __builtin_ia32_sfence ();
}
# 1316 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 1 3 4
# 1317 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 2 3 4
# 1328 "/usr/lib/gcc/x86_64-redhat-linux/10/include/xmmintrin.h" 3 4
extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_pause (void)
{
  __builtin_ia32_pause ();
}
# 32 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 2 3 4
# 40 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 3 4
typedef double __v2df __attribute__ ((__vector_size__ (16)));
typedef long long __v2di __attribute__ ((__vector_size__ (16)));
typedef unsigned long long __v2du __attribute__ ((__vector_size__ (16)));
typedef int __v4si __attribute__ ((__vector_size__ (16)));
typedef unsigned int __v4su __attribute__ ((__vector_size__ (16)));
typedef short __v8hi __attribute__ ((__vector_size__ (16)));
typedef unsigned short __v8hu __attribute__ ((__vector_size__ (16)));
typedef char __v16qi __attribute__ ((__vector_size__ (16)));
typedef signed char __v16qs __attribute__ ((__vector_size__ (16)));
typedef unsigned char __v16qu __attribute__ ((__vector_size__ (16)));



typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
typedef double __m128d __attribute__ ((__vector_size__ (16), __may_alias__));


typedef long long __m128i_u __attribute__ ((__vector_size__ (16), __may_alias__, __aligned__ (1)));
typedef double __m128d_u __attribute__ ((__vector_size__ (16), __may_alias__, __aligned__ (1)));






extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_sd (double __F)
{
  return __extension__ (__m128d){ __F, 0.0 };
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_pd (double __F)
{
  return __extension__ (__m128d){ __F, __F };
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd1 (double __F)
{
  return _mm_set1_pd (__F);
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_pd (double __W, double __X)
{
  return __extension__ (__m128d){ __X, __W };
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_pd (double __W, double __X)
{
  return __extension__ (__m128d){ __W, __X };
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_pd (void)
{
  __m128d __Y = __Y;
  return __Y;
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_pd (void)
{
  return __extension__ (__m128d){ 0.0, 0.0 };
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_sd (__m128d __A, __m128d __B)
{
  return __extension__ (__m128d) __builtin_shuffle ((__v2df)__A, (__v2df)__B, (__v2di){2, 1});
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd (double const *__P)
{
  return *(__m128d *)__P;
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_pd (double const *__P)
{
  return *(__m128d_u *)__P;
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load1_pd (double const *__P)
{
  return _mm_set1_pd (*__P);
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_sd (double const *__P)
{
  return _mm_set_sd (*__P);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_pd1 (double const *__P)
{
  return _mm_load1_pd (__P);
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadr_pd (double const *__P)
{
  __m128d __tmp = _mm_load_pd (__P);
  return __builtin_ia32_shufpd (__tmp, __tmp, (((0) << 1) | (1)));
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd (double *__P, __m128d __A)
{
  *(__m128d *)__P = __A;
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_pd (double *__P, __m128d __A)
{
  *(__m128d_u *)__P = __A;
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_sd (double *__P, __m128d __A)
{
  *__P = ((__v2df)__A)[0];
}

extern __inline double __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_f64 (__m128d __A)
{
  return ((__v2df)__A)[0];
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_pd (double *__P, __m128d __A)
{
  _mm_store_sd (__P, __A);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeh_pd (double *__P, __m128d __A)
{
  *__P = ((__v2df)__A)[1];
}



extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store1_pd (double *__P, __m128d __A)
{
  _mm_store_pd (__P, __builtin_ia32_shufpd (__A, __A, (((0) << 1) | (0))));
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_pd1 (double *__P, __m128d __A)
{
  _mm_store1_pd (__P, __A);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storer_pd (double *__P, __m128d __A)
{
  _mm_store_pd (__P, __builtin_ia32_shufpd (__A, __A, (((0) << 1) | (1))));
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si32 (__m128i __A)
{
  return __builtin_ia32_vec_ext_v4si ((__v4si)__A, 0);
}



extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64 (__m128i __A)
{
  return ((__v2di)__A)[0];
}


extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi128_si64x (__m128i __A)
{
  return ((__v2di)__A)[0];
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_pd (__m128d __A, __m128d __B)
{
  return (__m128d) ((__v2df)__A + (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_addsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_pd (__m128d __A, __m128d __B)
{
  return (__m128d) ((__v2df)__A - (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_subsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_pd (__m128d __A, __m128d __B)
{
  return (__m128d) ((__v2df)__A * (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_mulsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_pd (__m128d __A, __m128d __B)
{
  return (__m128d) ((__v2df)__A / (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_div_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_divsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_pd (__m128d __A)
{
  return (__m128d)__builtin_ia32_sqrtpd ((__v2df)__A);
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sqrt_sd (__m128d __A, __m128d __B)
{
  __v2df __tmp = __builtin_ia32_movsd ((__v2df)__A, (__v2df)__B);
  return (__m128d)__builtin_ia32_sqrtsd ((__v2df)__tmp);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_minpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_minsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_maxpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_maxsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_andpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_andnpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_orpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_xorpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpeqpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpltpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmplepd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpgtpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpgepd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpneqpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpnltpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpnlepd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpngtpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpngepd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpordpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpunordpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpeqsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpltsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmple_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmplesd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_sd (__m128d __A, __m128d __B)
{
  return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
      (__v2df)
      __builtin_ia32_cmpltsd ((__v2df) __B,
         (__v2df)
         __A));
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpge_sd (__m128d __A, __m128d __B)
{
  return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
      (__v2df)
      __builtin_ia32_cmplesd ((__v2df) __B,
         (__v2df)
         __A));
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpneq_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpneqsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnlt_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpnltsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnle_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpnlesd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpngt_sd (__m128d __A, __m128d __B)
{
  return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
      (__v2df)
      __builtin_ia32_cmpnltsd ((__v2df) __B,
          (__v2df)
          __A));
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpnge_sd (__m128d __A, __m128d __B)
{
  return (__m128d) __builtin_ia32_movsd ((__v2df) __A,
      (__v2df)
      __builtin_ia32_cmpnlesd ((__v2df) __B,
          (__v2df)
          __A));
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpord_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpordsd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpunord_sd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_cmpunordsd ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comieq_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_comisdeq ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comilt_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_comisdlt ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comile_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_comisdle ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comigt_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_comisdgt ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comige_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_comisdge ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_comineq_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_comisdneq ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomieq_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_ucomisdeq ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomilt_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_ucomisdlt ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomile_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_ucomisdle ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomigt_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_ucomisdgt ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomige_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_ucomisdge ((__v2df)__A, (__v2df)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_ucomineq_sd (__m128d __A, __m128d __B)
{
  return __builtin_ia32_ucomisdneq ((__v2df)__A, (__v2df)__B);
}



extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64x (long long __q1, long long __q0)
{
  return __extension__ (__m128i)(__v2di){ __q0, __q1 };
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi64 (__m64 __q1, __m64 __q0)
{
  return _mm_set_epi64x ((long long)__q1, (long long)__q0);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi32 (int __q3, int __q2, int __q1, int __q0)
{
  return __extension__ (__m128i)(__v4si){ __q0, __q1, __q2, __q3 };
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi16 (short __q7, short __q6, short __q5, short __q4,
        short __q3, short __q2, short __q1, short __q0)
{
  return __extension__ (__m128i)(__v8hi){
    __q0, __q1, __q2, __q3, __q4, __q5, __q6, __q7 };
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set_epi8 (char __q15, char __q14, char __q13, char __q12,
       char __q11, char __q10, char __q09, char __q08,
       char __q07, char __q06, char __q05, char __q04,
       char __q03, char __q02, char __q01, char __q00)
{
  return __extension__ (__m128i)(__v16qi){
    __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
    __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15
  };
}



extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64x (long long __A)
{
  return _mm_set_epi64x (__A, __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi64 (__m64 __A)
{
  return _mm_set_epi64 (__A, __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi32 (int __A)
{
  return _mm_set_epi32 (__A, __A, __A, __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi16 (short __A)
{
  return _mm_set_epi16 (__A, __A, __A, __A, __A, __A, __A, __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_set1_epi8 (char __A)
{
  return _mm_set_epi8 (__A, __A, __A, __A, __A, __A, __A, __A,
         __A, __A, __A, __A, __A, __A, __A, __A);
}




extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi64 (__m64 __q0, __m64 __q1)
{
  return _mm_set_epi64 (__q1, __q0);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi32 (int __q0, int __q1, int __q2, int __q3)
{
  return _mm_set_epi32 (__q3, __q2, __q1, __q0);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi16 (short __q0, short __q1, short __q2, short __q3,
         short __q4, short __q5, short __q6, short __q7)
{
  return _mm_set_epi16 (__q7, __q6, __q5, __q4, __q3, __q2, __q1, __q0);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setr_epi8 (char __q00, char __q01, char __q02, char __q03,
        char __q04, char __q05, char __q06, char __q07,
        char __q08, char __q09, char __q10, char __q11,
        char __q12, char __q13, char __q14, char __q15)
{
  return _mm_set_epi8 (__q15, __q14, __q13, __q12, __q11, __q10, __q09, __q08,
         __q07, __q06, __q05, __q04, __q03, __q02, __q01, __q00);
}



extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_load_si128 (__m128i const *__P)
{
  return *__P;
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_si128 (__m128i_u const *__P)
{
  return *__P;
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_epi64 (__m128i_u const *__P)
{
  return _mm_set_epi64 ((__m64)0LL, *(__m64_u *)__P);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_si64 (void const *__P)
{
  return _mm_loadl_epi64 ((__m128i_u *)__P);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_store_si128 (__m128i *__P, __m128i __B)
{
  *__P = __B;
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_si128 (__m128i_u *__P, __m128i __B)
{
  *__P = __B;
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storel_epi64 (__m128i_u *__P, __m128i __B)
{
  *(__m64_u *)__P = (__m64) ((__v2di)__B)[0];
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_storeu_si64 (void *__P, __m128i __B)
{
  _mm_storel_epi64 ((__m128i_u *)__P, __B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movepi64_pi64 (__m128i __B)
{
  return (__m64) ((__v2di)__B)[0];
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movpi64_epi64 (__m64 __A)
{
  return _mm_set_epi64 ((__m64)0LL, __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_move_epi64 (__m128i __A)
{
  return (__m128i)__builtin_ia32_movq128 ((__v2di) __A);
}


extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_undefined_si128 (void)
{
  __m128i __Y = __Y;
  return __Y;
}


extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_setzero_si128 (void)
{
  return __extension__ (__m128i)(__v4si){ 0, 0, 0, 0 };
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_pd (__m128i __A)
{
  return (__m128d)__builtin_ia32_cvtdq2pd ((__v4si) __A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtepi32_ps (__m128i __A)
{
  return (__m128)__builtin_ia32_cvtdq2ps ((__v4si) __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_epi32 (__m128d __A)
{
  return (__m128i)__builtin_ia32_cvtpd2dq ((__v2df) __A);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_pi32 (__m128d __A)
{
  return (__m64)__builtin_ia32_cvtpd2pi ((__v2df) __A);
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpd_ps (__m128d __A)
{
  return (__m128)__builtin_ia32_cvtpd2ps ((__v2df) __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_epi32 (__m128d __A)
{
  return (__m128i)__builtin_ia32_cvttpd2dq ((__v2df) __A);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttpd_pi32 (__m128d __A)
{
  return (__m64)__builtin_ia32_cvttpd2pi ((__v2df) __A);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtpi32_pd (__m64 __A)
{
  return (__m128d)__builtin_ia32_cvtpi2pd ((__v2si) __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_epi32 (__m128 __A)
{
  return (__m128i)__builtin_ia32_cvtps2dq ((__v4sf) __A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttps_epi32 (__m128 __A)
{
  return (__m128i)__builtin_ia32_cvttps2dq ((__v4sf) __A);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtps_pd (__m128 __A)
{
  return (__m128d)__builtin_ia32_cvtps2pd ((__v4sf) __A);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si32 (__m128d __A)
{
  return __builtin_ia32_cvtsd2si ((__v2df) __A);
}



extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64 (__m128d __A)
{
  return __builtin_ia32_cvtsd2si64 ((__v2df) __A);
}


extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_si64x (__m128d __A)
{
  return __builtin_ia32_cvtsd2si64 ((__v2df) __A);
}


extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si32 (__m128d __A)
{
  return __builtin_ia32_cvttsd2si ((__v2df) __A);
}



extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64 (__m128d __A)
{
  return __builtin_ia32_cvttsd2si64 ((__v2df) __A);
}


extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvttsd_si64x (__m128d __A)
{
  return __builtin_ia32_cvttsd2si64 ((__v2df) __A);
}


extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsd_ss (__m128 __A, __m128d __B)
{
  return (__m128)__builtin_ia32_cvtsd2ss ((__v4sf) __A, (__v2df) __B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_sd (__m128d __A, int __B)
{
  return (__m128d)__builtin_ia32_cvtsi2sd ((__v2df) __A, __B);
}



extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_sd (__m128d __A, long long __B)
{
  return (__m128d)__builtin_ia32_cvtsi642sd ((__v2df) __A, __B);
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_sd (__m128d __A, long long __B)
{
  return (__m128d)__builtin_ia32_cvtsi642sd ((__v2df) __A, __B);
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtss_sd (__m128d __A, __m128 __B)
{
  return (__m128d)__builtin_ia32_cvtss2sd ((__v2df) __A, (__v4sf)__B);
}


extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_pd(__m128d __A, __m128d __B, const int __mask)
{
  return (__m128d)__builtin_ia32_shufpd ((__v2df)__A, (__v2df)__B, __mask);
}






extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_unpckhpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_pd (__m128d __A, __m128d __B)
{
  return (__m128d)__builtin_ia32_unpcklpd ((__v2df)__A, (__v2df)__B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadh_pd (__m128d __A, double const *__B)
{
  return (__m128d)__builtin_ia32_loadhpd ((__v2df)__A, __B);
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadl_pd (__m128d __A, double const *__B)
{
  return (__m128d)__builtin_ia32_loadlpd ((__v2df)__A, __B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_pd (__m128d __A)
{
  return __builtin_ia32_movmskpd ((__v2df)__A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_packsswb128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packs_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_packssdw128 ((__v4si)__A, (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_packus_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_packuswb128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpckhbw128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpckhwd128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpckhdq128 ((__v4si)__A, (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpackhi_epi64 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpckhqdq128 ((__v2di)__A, (__v2di)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpcklbw128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpcklwd128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpckldq128 ((__v4si)__A, (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_unpacklo_epi64 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_punpcklqdq128 ((__v2di)__A, (__v2di)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v16qu)__A + (__v16qu)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v8hu)__A + (__v8hu)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v4su)__A + (__v4su)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_add_epi64 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v2du)__A + (__v2du)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_paddsb128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_paddsw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_paddusb128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_adds_epu16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_paddusw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v16qu)__A - (__v16qu)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v8hu)__A - (__v8hu)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v4su)__A - (__v4su)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sub_epi64 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v2du)__A - (__v2du)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psubsb128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psubsw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psubusb128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_subs_epu16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psubusw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_madd_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pmaddwd128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pmulhw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mullo_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v8hu)__A * (__v8hu)__B);
}

extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_su32 (__m64 __A, __m64 __B)
{
  return (__m64)__builtin_ia32_pmuludq ((__v2si)__A, (__v2si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mul_epu32 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pmuludq128 ((__v4si)__A, (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi16 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_psllwi128 ((__v8hi)__A, __B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi32 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_pslldi128 ((__v4si)__A, __B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_epi64 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_psllqi128 ((__v2di)__A, __B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi16 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_psrawi128 ((__v8hi)__A, __B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srai_epi32 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_psradi128 ((__v4si)__A, __B);
}


extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_bsrli_si128 (__m128i __A, const int __N)
{
  return (__m128i)__builtin_ia32_psrldqi128 (__A, __N * 8);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_bslli_si128 (__m128i __A, const int __N)
{
  return (__m128i)__builtin_ia32_pslldqi128 (__A, __N * 8);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_si128 (__m128i __A, const int __N)
{
  return (__m128i)__builtin_ia32_psrldqi128 (__A, __N * 8);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_slli_si128 (__m128i __A, const int __N)
{
  return (__m128i)__builtin_ia32_pslldqi128 (__A, __N * 8);
}
# 1218 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 3 4
extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi16 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_psrlwi128 ((__v8hi)__A, __B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi32 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_psrldi128 ((__v4si)__A, __B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srli_epi64 (__m128i __A, int __B)
{
  return (__m128i)__builtin_ia32_psrlqi128 ((__v2di)__A, __B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psllw128((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pslld128((__v4si)__A, (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sll_epi64 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psllq128((__v2di)__A, (__v2di)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psraw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sra_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psrad128 ((__v4si)__A, (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psrlw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psrld128 ((__v4si)__A, (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_srl_epi64 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psrlq128 ((__v2di)__A, (__v2di)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_and_si128 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v2du)__A & (__v2du)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_andnot_si128 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pandn128 ((__v2di)__A, (__v2di)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_or_si128 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v2du)__A | (__v2du)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_xor_si128 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v2du)__A ^ (__v2du)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v16qi)__A == (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v8hi)__A == (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v4si)__A == (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v16qs)__A < (__v16qs)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v8hi)__A < (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmplt_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v4si)__A < (__v4si)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi8 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v16qs)__A > (__v16qs)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v8hi)__A > (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpgt_epi32 (__m128i __A, __m128i __B)
{
  return (__m128i) ((__v4si)__A > (__v4si)__B);
}


extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_extract_epi16 (__m128i const __A, int const __N)
{
  return (unsigned short) __builtin_ia32_vec_ext_v8hi ((__v8hi)__A, __N);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_insert_epi16 (__m128i const __A, int const __D, int const __N)
{
  return (__m128i) __builtin_ia32_vec_set_v8hi ((__v8hi)__A, __D, __N);
}
# 1382 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 3 4
extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pmaxsw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_max_epu8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pmaxub128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epi16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pminsw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_min_epu8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pminub128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_epi8 (__m128i __A)
{
  return __builtin_ia32_pmovmskb128 ((__v16qi)__A);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mulhi_epu16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pmulhuw128 ((__v8hi)__A, (__v8hi)__B);
}


extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shufflehi_epi16 (__m128i __A, const int __mask)
{
  return (__m128i)__builtin_ia32_pshufhw ((__v8hi)__A, __mask);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shufflelo_epi16 (__m128i __A, const int __mask)
{
  return (__m128i)__builtin_ia32_pshuflw ((__v8hi)__A, __mask);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_shuffle_epi32 (__m128i __A, const int __mask)
{
  return (__m128i)__builtin_ia32_pshufd ((__v4si)__A, __mask);
}
# 1445 "/usr/lib/gcc/x86_64-redhat-linux/10/include/emmintrin.h" 3 4
extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_maskmoveu_si128 (__m128i __A, __m128i __B, char *__C)
{
  __builtin_ia32_maskmovdqu ((__v16qi)__A, (__v16qi)__B, __C);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pavgb128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_avg_epu16 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_pavgw128 ((__v8hi)__A, (__v8hi)__B);
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_sad_epu8 (__m128i __A, __m128i __B)
{
  return (__m128i)__builtin_ia32_psadbw128 ((__v16qi)__A, (__v16qi)__B);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si32 (int *__A, int __B)
{
  __builtin_ia32_movnti (__A, __B);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si64 (long long int *__A, long long int __B)
{
  __builtin_ia32_movnti64 (__A, __B);
}


extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_si128 (__m128i *__A, __m128i __B)
{
  __builtin_ia32_movntdq ((__v2di *)__A, (__v2di)__B);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_stream_pd (double *__A, __m128d __B)
{
  __builtin_ia32_movntpd (__A, (__v2df)__B);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_clflush (void const *__A)
{
  __builtin_ia32_clflush (__A);
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_lfence (void)
{
  __builtin_ia32_lfence ();
}

extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_mfence (void)
{
  __builtin_ia32_mfence ();
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi32_si128 (int __A)
{
  return _mm_set_epi32 (0, 0, 0, __A);
}



extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64_si128 (long long __A)
{
  return _mm_set_epi64x (0, __A);
}


extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cvtsi64x_si128 (long long __A)
{
  return _mm_set_epi64x (0, __A);
}




extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_ps(__m128d __A)
{
  return (__m128) __A;
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castpd_si128(__m128d __A)
{
  return (__m128i) __A;
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_pd(__m128 __A)
{
  return (__m128d) __A;
}

extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castps_si128(__m128 __A)
{
  return (__m128i) __A;
}

extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_ps(__m128i __A)
{
  return (__m128) __A;
}

extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_castsi128_pd(__m128i __A)
{
  return (__m128d) __A;
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/uuid_x86.ipp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/uuid_x86.ipp" 3 4
namespace boost {
namespace uuids {
namespace detail {

inline __attribute__ ((__always_inline__)) __m128i load_unaligned_si128(const uint8_t* p) noexcept
{



    return _mm_loadu_si128(reinterpret_cast< const __m128i* >(p));
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/uuid_x86.ipp" 3 4
}

}

inline bool uuid::is_nil() const noexcept
{
    __m128i mm = uuids::detail::load_unaligned_si128(data);



    mm = _mm_cmpeq_epi32(mm, _mm_setzero_si128());
    return _mm_movemask_epi8(mm) == 0xFFFF;

}

inline void uuid::swap(uuid& rhs) noexcept
{
    __m128i mm_this = uuids::detail::load_unaligned_si128(data);
    __m128i mm_rhs = uuids::detail::load_unaligned_si128(rhs.data);
    _mm_storeu_si128(reinterpret_cast< __m128i* >(rhs.data), mm_this);
    _mm_storeu_si128(reinterpret_cast< __m128i* >(data), mm_rhs);
}

inline bool operator== (uuid const& lhs, uuid const& rhs) noexcept
{
    __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data);
    __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data);





    __m128i mm_cmp = _mm_cmpeq_epi32(mm_left, mm_right);
    return _mm_movemask_epi8(mm_cmp) == 0xFFFF;

}

inline bool operator< (uuid const& lhs, uuid const& rhs) noexcept
{
    __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data);
    __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data);
# 117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/uuid_x86.ipp" 3 4
    const __m128i mm_signs_mask = _mm_xor_si128(mm_left, mm_right);

    __m128i mm_cmp = _mm_cmpgt_epi8(mm_right, mm_left), mm_rcmp = _mm_cmpgt_epi8(mm_left, mm_right);

    mm_cmp = _mm_xor_si128(mm_signs_mask, mm_cmp);
    mm_rcmp = _mm_xor_si128(mm_signs_mask, mm_rcmp);

    uint32_t cmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_cmp)), rcmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_rcmp));

    cmp = (cmp - 1u) ^ cmp;
    rcmp = (rcmp - 1u) ^ rcmp;

    return cmp < rcmp;
}

}
}
# 204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid.hpp" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_generators.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_generators.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/nil_generator.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/nil_generator.hpp" 3 4
namespace boost {
namespace uuids {


struct nil_generator {
    typedef uuid result_type;

    uuid operator()() const {

        uuid u = {{0}};
        return u;
    }
};

inline uuid nil_uuid() {
    return nil_generator()();
}

}}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_generators.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/string_generator.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/string_generator.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/string_generator.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/string_generator.hpp" 3 4
namespace boost {
namespace uuids {
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/string_generator.hpp" 3 4
struct string_generator {
    typedef uuid result_type;

    template <typename ch, typename char_traits, typename alloc>
    uuid operator()(std::basic_string<ch, char_traits, alloc> const& s) const {
        return operator()(s.begin(), s.end());
    }

    uuid operator()(char const*const s) const {
        return operator()(s, s+std::strlen(s));
    }

    uuid operator()(wchar_t const*const s) const {
        return operator()(s, s+std::wcslen(s));
    }

    template <typename CharIterator>
    uuid operator()(CharIterator begin, CharIterator end) const
    {
        typedef typename std::iterator_traits<CharIterator>::value_type char_type;


        char_type c = get_next_char(begin, end);
        bool has_open_brace = is_open_brace(c);
        char_type open_brace_char = c;
        if (has_open_brace) {
            c = get_next_char(begin, end);
        }

        bool has_dashes = false;

        uuid u;
        int i=0;
        for (uuid::iterator it_byte=u.begin(); it_byte!=u.end(); ++it_byte, ++i) {
            if (it_byte != u.begin()) {
                c = get_next_char(begin, end);
            }

            if (i == 4) {
                has_dashes = is_dash(c);
                if (has_dashes) {
                    c = get_next_char(begin, end);
                }
            }


            else if (i == 6 || i == 8 || i == 10) {
                if (has_dashes == true) {
                    if (is_dash(c)) {
                        c = get_next_char(begin, end);
                    } else {
                        throw_invalid();
                    }
                }
            }


            *it_byte = get_value(c);

            c = get_next_char(begin, end);
            *it_byte <<= 4;
            *it_byte |= get_value(c);
        }


        if (has_open_brace) {
            c = get_next_char(begin, end);
            check_close_brace(c, open_brace_char);
        }


        if (begin != end) {
            throw_invalid();
        }

        return u;
    }

private:
    template <typename CharIterator>
    typename std::iterator_traits<CharIterator>::value_type
    get_next_char(CharIterator& begin, CharIterator end) const {
        if (begin == end) {
            throw_invalid();
        }
        return *begin++;
    }

    unsigned char get_value(char c) const {
        static char const digits_begin[] = "0123456789abcdefABCDEF";
        static size_t digits_len = (sizeof(digits_begin) / sizeof(char)) - 1;
        static char const*const digits_end = digits_begin + digits_len;

        static unsigned char const values[] =
            { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,10,11,12,13,14,15 };

        size_t pos = std::find(digits_begin, digits_end, c) - digits_begin;
        if (pos >= digits_len) {
            throw_invalid();
        }
        return values[pos];
    }

    unsigned char get_value(wchar_t c) const {
        static wchar_t const digits_begin[] = L"0123456789abcdefABCDEF";
        static size_t digits_len = (sizeof(digits_begin) / sizeof(wchar_t)) - 1;
        static wchar_t const*const digits_end = digits_begin + digits_len;

        static unsigned char const values[] =
            { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,10,11,12,13,14,15 };

        size_t pos = std::find(digits_begin, digits_end, c) - digits_begin;
        if (pos >= digits_len) {
            throw_invalid();
        }
        return values[pos];
    }

    bool is_dash(char c) const {
        return c == '-';
    }

    bool is_dash(wchar_t c) const {
        return c == L'-';
    }


    bool is_open_brace(char c) const {
        return (c == '{');
    }

    bool is_open_brace(wchar_t c) const {
        return (c == L'{');
    }

    void check_close_brace(char c, char open_brace) const {
        if (open_brace == '{' && c == '}') {

        } else {
            throw_invalid();
        }
    }

    void check_close_brace(wchar_t c, wchar_t open_brace) const {
        if (open_brace == L'{' && c == L'}') {

        } else {
            throw_invalid();
        }
    }

    void throw_invalid() const {
        ::boost::exception_detail::throw_exception_(std::runtime_error("invalid uuid string"),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/string_generator.hpp",191);
    }
};

}}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_generators.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/name_generator.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/name_generator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/name_generator_sha1.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/name_generator_sha1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/basic_name_generator.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/basic_name_generator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/basic_name_generator.hpp" 2 3 4


# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/basic_name_generator.hpp" 2 3 4



       
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/basic_name_generator.hpp" 3 4
namespace boost {
namespace uuids {




template<class HashAlgo>
class basic_name_generator
{
  public:
    typedef uuid result_type;
    typedef typename HashAlgo::digest_type digest_type;

    explicit basic_name_generator(uuid const& namespace_uuid_)
        : namespace_uuid(namespace_uuid_)
    {}

    uuid operator()(const char* name) const {
        HashAlgo hash;
        hash.process_bytes(namespace_uuid.begin(), namespace_uuid.size());
        process_characters(hash, name, std::strlen(name));
        return hash_to_uuid(hash);
    }

    uuid operator()(const wchar_t* name) const {
        HashAlgo hash;
        hash.process_bytes(namespace_uuid.begin(), namespace_uuid.size());
        process_characters(hash, name, std::wcslen(name));
        return hash_to_uuid(hash);
    }

    template <typename ch, typename char_traits, typename alloc>
    uuid operator()(std::basic_string<ch, char_traits, alloc> const& name) const {
        HashAlgo hash;
        hash.process_bytes(namespace_uuid.begin(), namespace_uuid.size());
        process_characters(hash, name.c_str(), name.length());
        return hash_to_uuid(hash);
    }

    uuid operator()(void const* buffer, std::size_t byte_count) const {
        HashAlgo hash;
        hash.process_bytes(namespace_uuid.begin(), namespace_uuid.size());
        hash.process_bytes(buffer, byte_count);
        return hash_to_uuid(hash);
    };

private:





    template <typename char_type>
    void process_characters(HashAlgo& hash, char_type const*const characters, std::size_t count) const {
        static_assert(sizeof(uint32_t) >= sizeof(char_type), "sizeof(uint32_t) >= sizeof(char_type)");

        for (std::size_t i=0; i<count; i++) {
            std::size_t c = characters[i];
            hash.process_byte(static_cast<unsigned char>((c >> 0) & 0xFF));
            hash.process_byte(static_cast<unsigned char>((c >> 8) & 0xFF));
            hash.process_byte(static_cast<unsigned char>((c >> 16) & 0xFF));
            hash.process_byte(static_cast<unsigned char>((c >> 24) & 0xFF));
        }
    }

    void process_characters(HashAlgo& hash, char const*const characters, std::size_t count) const {
        hash.process_bytes(characters, count);
    }

    uuid hash_to_uuid(HashAlgo& hash) const
    {
        digest_type digest;
        hash.get_digest(digest);

        static_assert(sizeof(digest_type) >= 16, "sizeof(digest_type) >= 16");

        uuid u;
        for (int i=0; i<4; ++i) {
            *(u.begin() + i*4+0) = static_cast<uint8_t>((digest[i] >> 24) & 0xFF);
            *(u.begin() + i*4+1) = static_cast<uint8_t>((digest[i] >> 16) & 0xFF);
            *(u.begin() + i*4+2) = static_cast<uint8_t>((digest[i] >> 8) & 0xFF);
            *(u.begin() + i*4+3) = static_cast<uint8_t>((digest[i] >> 0) & 0xFF);
        }


        *(u.begin()+8) &= 0xBF;
        *(u.begin()+8) |= 0x80;


        unsigned char hashver = hash.get_version();
        *(u.begin()+6) &= 0x0F;
        *(u.begin()+6) |= (hashver << 4);

        return u;
    }

private:
    uuid namespace_uuid;
};

namespace ns {

inline __attribute__ ((__always_inline__)) uuid dns() {
    uuid result = {{
        0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1 ,
        0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 }};
    return result;
}

inline __attribute__ ((__always_inline__)) uuid url() {
    uuid result = {{
        0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1 ,
        0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 }};
    return result;
}

inline __attribute__ ((__always_inline__)) uuid oid() {
    uuid result = {{
        0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1 ,
        0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 }};
    return result;
}

inline __attribute__ ((__always_inline__)) uuid x500dn() {
    uuid result = {{
        0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1 ,
        0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8 }};
    return result;
}

}
}
}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/name_generator_sha1.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/sha1.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/sha1.hpp" 3 4
namespace boost {
namespace uuids {
namespace detail {

static_assert(sizeof(unsigned char)*8 == 8, "sizeof(unsigned char)*8 == 8");
static_assert(sizeof(unsigned int)*8 == 32, "sizeof(unsigned int)*8 == 32");

inline unsigned int left_rotate(unsigned int x, std::size_t n)
{
    return (x<<n) ^ (x>> (32-n));
}

class sha1
{
public:
    typedef unsigned int(digest_type)[5];
public:
    sha1();

    void reset();

    void process_byte(unsigned char byte);
    void process_block(void const* bytes_begin, void const* bytes_end);
    void process_bytes(void const* buffer, std::size_t byte_count);

    void get_digest(digest_type& digest);
    unsigned char get_version() const;

private:
    void process_block();
    void process_byte_impl(unsigned char byte);

private:
    unsigned int h_[5];

    unsigned char block_[64];

    std::size_t block_byte_index_;
    std::size_t bit_count_low;
    std::size_t bit_count_high;
};

inline sha1::sha1()
{
    reset();
}

inline void sha1::reset()
{
    h_[0] = 0x67452301;
    h_[1] = 0xEFCDAB89;
    h_[2] = 0x98BADCFE;
    h_[3] = 0x10325476;
    h_[4] = 0xC3D2E1F0;

    block_byte_index_ = 0;
    bit_count_low = 0;
    bit_count_high = 0;
}

inline void sha1::process_byte(unsigned char byte)
{
    process_byte_impl(byte);




    if (bit_count_low < 0xFFFFFFF8) {
        bit_count_low += 8;
    } else {
        bit_count_low = 0;

        if (bit_count_high <= 0xFFFFFFFE) {
            ++bit_count_high;
        } else {
            ::boost::exception_detail::throw_exception_(std::runtime_error("sha1 too many bytes"),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/sha1.hpp",106);
        }
    }
}

inline void sha1::process_byte_impl(unsigned char byte)
{
    block_[block_byte_index_++] = byte;

    if (block_byte_index_ == 64) {
        block_byte_index_ = 0;
        process_block();
    }
}

inline void sha1::process_block(void const* bytes_begin, void const* bytes_end)
{
    unsigned char const* begin = static_cast<unsigned char const*>(bytes_begin);
    unsigned char const* end = static_cast<unsigned char const*>(bytes_end);
    for(; begin != end; ++begin) {
        process_byte(*begin);
    }
}

inline void sha1::process_bytes(void const* buffer, std::size_t byte_count)
{
    unsigned char const* b = static_cast<unsigned char const*>(buffer);
    process_block(b, b+byte_count);
}

inline void sha1::process_block()
{
    unsigned int w[80];
    for (std::size_t i=0; i<16; ++i) {
        w[i] = (block_[i*4 + 0] << 24);
        w[i] |= (block_[i*4 + 1] << 16);
        w[i] |= (block_[i*4 + 2] << 8);
        w[i] |= (block_[i*4 + 3]);
    }
    for (std::size_t i=16; i<80; ++i) {
        w[i] = left_rotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1);
    }

    unsigned int a = h_[0];
    unsigned int b = h_[1];
    unsigned int c = h_[2];
    unsigned int d = h_[3];
    unsigned int e = h_[4];

    for (std::size_t i=0; i<80; ++i) {
        unsigned int f;
        unsigned int k;

        if (i<20) {
            f = (b & c) | (~b & d);
            k = 0x5A827999;
        } else if (i<40) {
            f = b ^ c ^ d;
            k = 0x6ED9EBA1;
        } else if (i<60) {
            f = (b & c) | (b & d) | (c & d);
            k = 0x8F1BBCDC;
        } else {
            f = b ^ c ^ d;
            k = 0xCA62C1D6;
        }

        unsigned temp = left_rotate(a, 5) + f + e + k + w[i];
        e = d;
        d = c;
        c = left_rotate(b, 30);
        b = a;
        a = temp;
    }

    h_[0] += a;
    h_[1] += b;
    h_[2] += c;
    h_[3] += d;
    h_[4] += e;
}

inline unsigned char sha1::get_version() const
{

        return uuid::version_name_based_sha1;
}

inline void sha1::get_digest(digest_type& digest)
{

    process_byte_impl(0x80);




    if (block_byte_index_ > 56) {

        while (block_byte_index_ != 0) {
            process_byte_impl(0);
        }


        while (block_byte_index_ < 56) {
            process_byte_impl(0);
        }
    } else {
        while (block_byte_index_ < 56) {
            process_byte_impl(0);
        }
    }



    process_byte_impl( static_cast<unsigned char>((bit_count_high>>24) & 0xFF) );
    process_byte_impl( static_cast<unsigned char>((bit_count_high>>16) & 0xFF) );
    process_byte_impl( static_cast<unsigned char>((bit_count_high>>8 ) & 0xFF) );
    process_byte_impl( static_cast<unsigned char>((bit_count_high) & 0xFF) );
    process_byte_impl( static_cast<unsigned char>((bit_count_low>>24) & 0xFF) );
    process_byte_impl( static_cast<unsigned char>((bit_count_low>>16) & 0xFF) );
    process_byte_impl( static_cast<unsigned char>((bit_count_low>>8 ) & 0xFF) );
    process_byte_impl( static_cast<unsigned char>((bit_count_low) & 0xFF) );


    digest[0] = h_[0];
    digest[1] = h_[1];
    digest[2] = h_[2];
    digest[3] = h_[3];
    digest[4] = h_[4];
}

}}}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/name_generator_sha1.hpp" 2 3 4

namespace boost {
namespace uuids {



typedef basic_name_generator<detail::sha1> name_generator_sha1;

}
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/name_generator.hpp" 2 3 4


       


namespace boost {
namespace uuids {






typedef name_generator_sha1 name_generator;




typedef name_generator_sha1 name_generator_latest;

}
}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_generators.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/null_deleter.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/null_deleter.hpp" 3 4
       


namespace boost {


struct null_deleter
{

    typedef void result_type;



    template< typename T >
    void operator() (T*) const noexcept {}
};

}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 3 4
       
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 3


namespace boost
{





template < std::size_t Bit >
struct high_bit_mask_t
{
    typedef typename uint_t<(Bit + 1)>::least least;
    typedef typename uint_t<(Bit + 1)>::fast fast;

    static const least high_bit = (least( 1u ) << Bit);
    static const fast high_bit_fast = (fast( 1u ) << Bit);

    static const std::size_t bit_position = Bit;

};
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 3
template < std::size_t Bits >
struct low_bits_mask_t
{
    typedef typename uint_t<Bits>::least least;
    typedef typename uint_t<Bits>::fast fast;

    static const least sig_bits = least(~(least(~(least( 0u ))) << Bits ));
    static const fast sig_bits_fast = fast(sig_bits);

    static const std::size_t bit_count = Bits;

};
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 3
template < > struct low_bits_mask_t< std::numeric_limits<unsigned char>::digits > { typedef std::numeric_limits<unsigned char> limits_type; typedef uint_t<limits_type::digits>::least least; typedef uint_t<limits_type::digits>::fast fast; static const least sig_bits = (~( least(0u) )); static const fast sig_bits_fast = fast(sig_bits); static const std::size_t bit_count = limits_type::digits; };


template < > struct low_bits_mask_t< std::numeric_limits<unsigned short>::digits > { typedef std::numeric_limits<unsigned short> limits_type; typedef uint_t<limits_type::digits>::least least; typedef uint_t<limits_type::digits>::fast fast; static const least sig_bits = (~( least(0u) )); static const fast sig_bits_fast = fast(sig_bits); static const std::size_t bit_count = limits_type::digits; };



template < > struct low_bits_mask_t< std::numeric_limits<unsigned int>::digits > { typedef std::numeric_limits<unsigned int> limits_type; typedef uint_t<limits_type::digits>::least least; typedef uint_t<limits_type::digits>::fast fast; static const least sig_bits = (~( least(0u) )); static const fast sig_bits_fast = fast(sig_bits); static const std::size_t bit_count = limits_type::digits; };



template < > struct low_bits_mask_t< std::numeric_limits<unsigned long>::digits > { typedef std::numeric_limits<unsigned long> limits_type; typedef uint_t<limits_type::digits>::least least; typedef uint_t<limits_type::digits>::fast fast; static const least sig_bits = (~( least(0u) )); static const fast sig_bits_fast = fast(sig_bits); static const std::size_t bit_count = limits_type::digits; };
# 131 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_mask.hpp" 3
}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/config.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/ptr_helper.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/ptr_helper.hpp" 3 4
namespace boost {
namespace random {
namespace detail {


template<class T>
struct ptr_helper
{
  typedef T value_type;
  typedef T& reference_type;
  typedef const T& rvalue_type;
  static reference_type ref(T& r) { return r; }
  static const T& ref(const T& r) { return r; }
};

template<class T>
struct ptr_helper<T&>
{
  typedef T value_type;
  typedef T& reference_type;
  typedef T& rvalue_type;
  static reference_type ref(T& r) { return r; }
  static const T& ref(const T& r) { return r; }
};

template<class T>
struct ptr_helper<T*>
{
  typedef T value_type;
  typedef T& reference_type;
  typedef T* rvalue_type;
  static reference_type ref(T * p) { return *p; }
  static const T& ref(const T * p) { return *p; }
};

}
}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed.hpp" 3 4
namespace boost {
namespace random {
namespace detail {

template<class T>
struct disable_seed : boost::disable_if<boost::is_arithmetic<T> > {};

template<class Engine, class T>
struct disable_constructor : disable_seed<T> {};

template<class Engine>
struct disable_constructor<Engine, Engine> {};
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed.hpp" 3 4
}
}
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/traits.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/traits.hpp" 3 4
namespace boost {
namespace random {
namespace traits {

   template <class T, bool intrinsic>
   struct make_unsigned_imp
   {
      typedef typename boost::make_unsigned<T>::type type;
   };
   template <class T>
   struct make_unsigned_imp<T, false>
   {
      static_assert(std::numeric_limits<T>::is_specialized, "std::numeric_limits<T>::is_specialized");
      static_assert(std::numeric_limits<T>::is_signed == false, "std::numeric_limits<T>::is_signed == false");
      static_assert(std::numeric_limits<T>::is_integer == true, "std::numeric_limits<T>::is_integer == true");
      typedef T type;
   };
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/traits.hpp" 3 4
   template <class T>
   struct make_unsigned

      : public make_unsigned_imp < T, boost::is_integral<T>::value >

   {};

   template <class T, bool intrinsic>
   struct make_unsigned_or_unbounded_imp
   {
      typedef typename boost::make_unsigned<T>::type type;
   };
   template <class T>
   struct make_unsigned_or_unbounded_imp<T, false>
   {
      static_assert(std::numeric_limits<T>::is_specialized, "std::numeric_limits<T>::is_specialized");
      static_assert((std::numeric_limits<T>::is_signed == false) || (std::numeric_limits<T>::is_bounded == false), "(std::numeric_limits<T>::is_signed == false) || (std::numeric_limits<T>::is_bounded == false)");
      static_assert(std::numeric_limits<T>::is_integer == true, "std::numeric_limits<T>::is_integer == true");
      typedef T type;
   };
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/traits.hpp" 3 4
   template <class T>
   struct make_unsigned_or_unbounded

      : public make_unsigned_or_unbounded_imp < T, boost::is_integral<T>::value >

   {};


   template <class T>
   struct is_integral
      : public mpl::bool_<boost::is_integral<T>::value || (std::numeric_limits<T>::is_integer)>
   {};


   template <class T> struct is_signed
      : public mpl::bool_ < boost::is_signed<T>::value || (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed)>
   {};

}
}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/const_mod.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/const_mod.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/const_mod.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/large_arithmetic.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/large_arithmetic.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/large_arithmetic.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/integer_log2.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/integer_log2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/pending/integer_log2.hpp" 1 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_log2.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_log2.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/integer_log2.hpp" 2 3 4







namespace boost {
 namespace detail {

  template <typename T>
  int integer_log2_impl(T x, int n) {

      int result = 0;

      while (x != 1) {

          const T t = static_cast<T>(x >> n);
          if (t) {
              result += n;
              x = t;
          }
          n /= 2;

      }

      return result;
  }







  template <int p, int n>
  struct max_pow2_less {

      enum { c = 2*n < p };

      static const int value = c ? (max_pow2_less< c*p, 2*c*n>::value) : n
                                                      ;

  };

  template <>
  struct max_pow2_less<0, 0> {

      static const int value = 0;
  };






  template <typename T>
  struct width {




      static const int value = (std::numeric_limits<T>::digits);


  };

 }






 template <typename T>
 int integer_log2(T x) {

     (static_cast<void> (0));

     const int n = detail::max_pow2_less<
                     detail::width<T> :: value, 4
                   > :: value;

     return detail::integer_log2_impl(x, n);

 }



}
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/pending/integer_log2.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/integer_log2.hpp" 2 3 4

namespace boost {
namespace random {
namespace detail {
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/integer_log2.hpp" 3 4
template<int Shift>
struct integer_log2_impl
{
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/integer_log2.hpp" 3 4
    template<class T>
    constexpr static int apply2(T t, int accum, int update)
    {
        return integer_log2_impl<Shift / 2>::apply(t >> update, accum + update);
    }

    template<class T>
    constexpr static int apply(T t, int accum)
    {
        return apply2(t, accum, ((t >> Shift) != 0) * Shift);
    }

};

template<>
struct integer_log2_impl<1>
{
    template<class T>
    constexpr static int apply(T t, int accum)
    {
        return int(t >> 1) + accum;
    }
};

template<class T>
constexpr int integer_log2(T t)
{
    return integer_log2_impl<
        ::boost::detail::max_pow2_less<
            ::std::numeric_limits<T>::digits, 4
        >::value
    >::apply(t, 0);
}

}
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/large_arithmetic.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlogical-op"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/large_arithmetic.hpp" 2 3 4

namespace boost {
namespace random {
namespace detail {

struct div_t {
    boost::uintmax_t quotient;
    boost::uintmax_t remainder;
};

inline div_t muldivmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
{
    const int bits =
        ::std::numeric_limits< ::boost::uintmax_t>::digits / 2;
    const ::boost::uintmax_t mask = (::boost::uintmax_t(1) << bits) - 1;
    typedef ::boost::uint_t<bits>::fast digit_t;

    int shift = std::numeric_limits< ::boost::uintmax_t>::digits - 1
        - detail::integer_log2(m);

    a <<= shift;
    m <<= shift;

    digit_t product[4] = { 0, 0, 0, 0 };
    digit_t a_[2] = { digit_t(a & mask), digit_t((a >> bits) & mask) };
    digit_t b_[2] = { digit_t(b & mask), digit_t((b >> bits) & mask) };
    digit_t m_[2] = { digit_t(m & mask), digit_t((m >> bits) & mask) };


    for(int i = 0; i < 2; ++i) {
        digit_t carry = 0;
        for(int j = 0; j < 2; ++j) {
            ::boost::uint64_t temp = ::boost::uintmax_t(a_[i]) * b_[j] +
                carry + product[i + j];
            product[i + j] = digit_t(temp & mask);
            carry = digit_t(temp >> bits);
        }
        if(carry != 0) {
            product[i + 2] += carry;
        }
    }

    digit_t quotient[2];

    if(m == 0) {
        div_t result = {
            ((::boost::uintmax_t(product[3]) << bits) | product[2]),
            ((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
        };
        return result;
    }


    for(int i = 3; i >= 2; --i) {
        ::boost::uintmax_t temp =
            ::boost::uintmax_t(product[i]) << bits | product[i - 1];

        digit_t q = digit_t((product[i] == m_[1]) ? mask : temp / m_[1]);

        ::boost::uintmax_t rem =
            ((temp - ::boost::uintmax_t(q) * m_[1]) << bits) + product[i - 2];

        ::boost::uintmax_t diff = m_[0] * ::boost::uintmax_t(q);

        int error = 0;
        if(diff > rem) {
            if(diff - rem > m) {
                error = 2;
            } else {
                error = 1;
            }
        }
        q -= error;
        rem = rem + error * m - diff;

        quotient[i - 2] = q;
        product[i] = 0;
        product[i-1] = static_cast<digit_t>((rem >> bits) & mask);
        product[i-2] = static_cast<digit_t>(rem & mask);
    }

    div_t result = {
        ((::boost::uintmax_t(quotient[1]) << bits) | quotient[0]),
        ((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
    };
    return result;
}

inline boost::uintmax_t muldiv(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
{ return detail::muldivmod(a, b, m).quotient; }

inline boost::uintmax_t mulmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
{ return detail::muldivmod(a, b, m).remainder; }

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 3 4
#pragma GCC diagnostic pop
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/large_arithmetic.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/const_mod.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlogical-op"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/const_mod.hpp" 2 3 4

namespace boost {
namespace random {

template<class IntType, IntType m>
class const_mod
{
public:
  static IntType apply(IntType x)
  {
    if(((unsigned_m() - 1) & unsigned_m()) == 0)
      return (unsigned_type(x)) & (unsigned_m() - 1);
    else {
      IntType suppress_warnings = (m == 0);
      (static_cast<void> (0));
      return x % (m + suppress_warnings);
    }
  }

  static IntType add(IntType x, IntType c)
  {
    if(((unsigned_m() - 1) & unsigned_m()) == 0)
      return (unsigned_type(x) + unsigned_type(c)) & (unsigned_m() - 1);
    else if(c == 0)
      return x;
    else if(x < m - c)
      return x + c;
    else
      return x - (m - c);
  }

  static IntType mult(IntType a, IntType x)
  {
    if(((unsigned_m() - 1) & unsigned_m()) == 0)
      return unsigned_type(a) * unsigned_type(x) & (unsigned_m() - 1);
    else if(a == 0)
      return 0;
    else if(a == 1)
      return x;
    else if(m <= traits::const_max/a)
      return mult_small(a, x);
    else if(traits::is_signed && (m%a < m/a))
      return mult_schrage(a, x);
    else
      return mult_general(a, x);
  }

  static IntType mult_add(IntType a, IntType x, IntType c)
  {
    if(((unsigned_m() - 1) & unsigned_m()) == 0)
      return (unsigned_type(a) * unsigned_type(x) + unsigned_type(c)) & (unsigned_m() - 1);
    else if(a == 0)
      return c;
    else if(m <= (traits::const_max-c)/a) {
      IntType suppress_warnings = (m == 0);
      (static_cast<void> (0));
      return (a*x+c) % (m + suppress_warnings);
    } else
      return add(mult(a, x), c);
  }

  static IntType pow(IntType a, boost::uintmax_t exponent)
  {
      IntType result = 1;
      while(exponent != 0) {
          if(exponent % 2 == 1) {
              result = mult(result, a);
          }
          a = mult(a, a);
          exponent /= 2;
      }
      return result;
  }

  static IntType invert(IntType x)
  { return x == 0 ? 0 : (m == 0? invert_euclidian0(x) : invert_euclidian(x)); }

private:
  typedef integer_traits<IntType> traits;
  typedef typename make_unsigned<IntType>::type unsigned_type;

  const_mod();

  static IntType mult_small(IntType a, IntType x)
  {
    IntType suppress_warnings = (m == 0);
    (static_cast<void> (0));
    return a*x % (m + suppress_warnings);
  }

  static IntType mult_schrage(IntType a, IntType value)
  {
    const IntType q = m / a;
    const IntType r = m % a;

    (static_cast<void> (0));

    return sub(a*(value%q), r*(value/q));
  }

  static IntType mult_general(IntType a, IntType b)
  {
    IntType suppress_warnings = (m == 0);
    (static_cast<void> (0));
    IntType modulus = m + suppress_warnings;
    (static_cast<void> (0));
    if(::boost::uintmax_t(modulus) <=
        (::std::numeric_limits< ::boost::uintmax_t>::max)() / modulus)
    {
      return static_cast<IntType>(boost::uintmax_t(a) * b % modulus);
    } else {
      return static_cast<IntType>(detail::mulmod(a, b, modulus));
    }
  }

  static IntType sub(IntType a, IntType b)
  {
    if(a < b)
      return m - (b - a);
    else
      return a - b;
  }

  static unsigned_type unsigned_m()
  {
      if(m == 0) {
          return unsigned_type((std::numeric_limits<IntType>::max)()) + 1;
      } else {
          return unsigned_type(m);
      }
  }


  static IntType invert_euclidian(IntType c)
  {

    (static_cast<void> (0));
    IntType l1 = 0;
    IntType l2 = 1;
    IntType n = c;
    IntType p = m;
    for(;;) {
      IntType q = p / n;
      l1 += q * l2;
      p -= q * n;
      if(p == 0)
        return l2;
      IntType q2 = n / p;
      l2 += q2 * l1;
      n -= q2 * p;
      if(n == 0)
        return m - l1;
    }
  }


  static IntType invert_euclidian0(IntType c)
  {

    (static_cast<void> (0));
    if(c == 1) return 1;
    IntType l1 = 0;
    IntType l2 = 1;
    IntType n = c;
    IntType p = m;
    IntType max = (std::numeric_limits<IntType>::max)();
    IntType q = max / n;
    (static_cast<void> (0));
    l1 += q * l2;
    p = max - q * n + 1;
    for(;;) {
      if(p == 0)
        return l2;
      IntType q2 = n / p;
      l2 += q2 * l1;
      n -= q2 * p;
      if(n == 0)
        return m - l1;
      q = p / n;
      l1 += q * l2;
      p -= q * n;
    }
  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 3 4
#pragma GCC diagnostic pop
# 215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/const_mod.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/signed_unsigned_tools.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/signed_unsigned_tools.hpp" 3 4
namespace boost {
namespace random {
namespace detail {






template<class T, bool sgn = std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_bounded>
struct subtract { };

template<class T>
struct subtract<T, false>
{
  typedef T result_type;
  result_type operator()(T x, T y) { return x - y; }
};

template<class T>
struct subtract<T, true>
{
  typedef typename boost::random::traits::make_unsigned_or_unbounded<T>::type result_type;
  result_type operator()(T x, T y)
  {
    if (y >= 0)
      return result_type(x) - result_type(y);
    if (x >= 0)

      return result_type(x) + result_type(-(y+1)) + 1;

    return result_type(x - y);
  }
};





template<class T1, class T2, bool sgn = (std::numeric_limits<T2>::is_signed && (std::numeric_limits<T1>::digits >= std::numeric_limits<T2>::digits))>
struct add { };

template<class T1, class T2>
struct add<T1, T2, false>
{
  typedef T2 result_type;
  result_type operator()(T1 x, T2 y) { return T2(x) + y; }
};

template<class T1, class T2>
struct add<T1, T2, true>
{
  typedef T2 result_type;
  result_type operator()(T1 x, T2 y)
  {
    if (y >= 0)
      return T2(x) + y;

    if (x > T1(-(y+1)))

      return T2(x - T1(-(y+1)) - 1);

    return T2(x) + y;
  }
};

}
}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/generator_bits.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/generator_bits.hpp" 3 4
namespace boost {
namespace random {
namespace detail {



template<class URNG>
struct generator_bits {
    static std::size_t value() {
        return std::numeric_limits<typename URNG::result_type>::digits;
    }
};

}
}
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlogical-op"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 2 3 4

namespace boost {
namespace random {
namespace detail {





template<class T>
struct seed_type
{
    typedef typename boost::mpl::if_<boost::is_integral<T>,
        T,
        boost::uint32_t
    >::type type;
};

template<int N>
struct const_pow_impl
{
    template<class T>
    static T call(T arg, int n, T result)
    {
        return const_pow_impl<N / 2>::call(T(arg * arg), n / 2,
            n%2 == 0? result : T(result * arg));
    }
};

template<>
struct const_pow_impl<0>
{
    template<class T>
    static T call(T, int, T result)
    {
        return result;
    }
};


template<int N, class T>
inline T const_pow(T arg, int n) { return const_pow_impl<N>::call(arg, n, T(1)); }

template<class T>
inline T pow2(int n)
{
    typedef unsigned int_type;
    const int max_bits = std::numeric_limits<int_type>::digits;
    T multiplier = T(int_type(1) << (max_bits - 1)) * 2;
    return (int_type(1) << (n % max_bits)) *
        const_pow<std::numeric_limits<T>::digits / max_bits>(multiplier, n / max_bits);
}

template<class Engine, class Iter>
void generate_from_real(Engine& eng, Iter begin, Iter end)
{
    using std::fmod;
    typedef typename Engine::result_type RealType;
    const int Bits = detail::generator_bits<Engine>::value();
    int remaining_bits = 0;
    boost::uint_least32_t saved_bits = 0;
    RealType multiplier = pow2<RealType>( Bits);
    RealType mult32 = RealType(4294967296.0);
    while(true) {
        RealType val = eng() * multiplier;
        int available_bits = Bits;


        if(Bits < 32 && available_bits < 32 - remaining_bits) {
            saved_bits |= boost::uint_least32_t(val) << remaining_bits;
            remaining_bits += Bits;
        } else {



            if(Bits < 32 || remaining_bits != 0) {
                boost::uint_least32_t divisor =
                    (boost::uint_least32_t(1) << (32 - remaining_bits));
                boost::uint_least32_t extra_bits = boost::uint_least32_t(fmod(val, mult32)) & (divisor - 1);
                val = val / divisor;
                *begin++ = saved_bits | (extra_bits << remaining_bits);
                if(begin == end) return;
                available_bits -= 32 - remaining_bits;
                remaining_bits = 0;
            }

            if(Bits >= 32) {
                for(; available_bits >= 32; available_bits -= 32) {
                    boost::uint_least32_t word = boost::uint_least32_t(fmod(val, mult32));
                    val /= mult32;
                    *begin++ = word;
                    if(begin == end) return;
                }
            }
            remaining_bits = available_bits;
            saved_bits = static_cast<boost::uint_least32_t>(val);
        }
    }
}

template<class Engine, class Iter>
void generate_from_int(Engine& eng, Iter begin, Iter end)
{
    typedef typename Engine::result_type IntType;
    typedef typename boost::random::traits::make_unsigned<IntType>::type unsigned_type;
    int remaining_bits = 0;
    boost::uint_least32_t saved_bits = 0;
    unsigned_type range = boost::random::detail::subtract<IntType>()((eng.max)(), (eng.min)());

    int bits =
        (range == (std::numeric_limits<unsigned_type>::max)()) ?
            std::numeric_limits<unsigned_type>::digits :
            detail::integer_log2(range + 1);

    {
        int discarded_bits = detail::integer_log2(bits);
        unsigned_type excess = (range + 1) >> (bits - discarded_bits);
        if(excess != 0) {
            int extra_bits = detail::integer_log2((excess - 1) ^ excess);
            bits = bits - discarded_bits + extra_bits;
        }
    }

    unsigned_type mask = (static_cast<unsigned_type>(2) << (bits - 1)) - 1;
    unsigned_type limit = ((range + 1) & ~mask) - 1;

    while(true) {
        unsigned_type val;
        do {
            val = boost::random::detail::subtract<IntType>()(eng(), (eng.min)());
        } while(limit != range && val > limit);
        val &= mask;
        int available_bits = bits;
        if(available_bits == 32) {
            *begin++ = static_cast<boost::uint_least32_t>(val) & 0xFFFFFFFFu;
            if(begin == end) return;
        } else if(available_bits % 32 == 0) {
            for(int i = 0; i < available_bits / 32; ++i) {
                boost::uint_least32_t word = boost::uint_least32_t(val) & 0xFFFFFFFFu;
                int suppress_warning = (bits >= 32);
                (static_cast<void> (0));
                val >>= (32 * suppress_warning);
                *begin++ = word;
                if(begin == end) return;
            }
        } else if(bits < 32 && available_bits < 32 - remaining_bits) {
            saved_bits |= boost::uint_least32_t(val) << remaining_bits;
            remaining_bits += bits;
        } else {
            if(bits < 32 || remaining_bits != 0) {
                boost::uint_least32_t extra_bits = boost::uint_least32_t(val) & ((boost::uint_least32_t(1) << (32 - remaining_bits)) - 1);
                val >>= 32 - remaining_bits;
                *begin++ = saved_bits | (extra_bits << remaining_bits);
                if(begin == end) return;
                available_bits -= 32 - remaining_bits;
                remaining_bits = 0;
            }
            if(bits >= 32) {
                for(; available_bits >= 32; available_bits -= 32) {
                    boost::uint_least32_t word = boost::uint_least32_t(val) & 0xFFFFFFFFu;
                    int suppress_warning = (bits >= 32);
                    (static_cast<void> (0));
                    val >>= (32 * suppress_warning);
                    *begin++ = word;
                    if(begin == end) return;
                }
            }
            remaining_bits = available_bits;
            saved_bits = static_cast<boost::uint_least32_t>(val);
        }
    }
}

template<class Engine, class Iter>
void generate_impl(Engine& eng, Iter first, Iter last, boost::mpl::true_)
{
    return detail::generate_from_int(eng, first, last);
}

template<class Engine, class Iter>
void generate_impl(Engine& eng, Iter first, Iter last, boost::mpl::false_)
{
    return detail::generate_from_real(eng, first, last);
}

template<class Engine, class Iter>
void generate(Engine& eng, Iter first, Iter last)
{
    return detail::generate_impl(eng, first, last, boost::random::traits::is_integral<typename Engine::result_type>());
}



template<class IntType, IntType m, class SeedSeq>
IntType seed_one_int(SeedSeq& seq)
{
    static const int log = ::boost::mpl::if_c<(m == 0),
        ::boost::mpl::int_<(::std::numeric_limits<IntType>::digits)>,
        ::boost::static_log2<m> >::type::value;
    static const int k =
        (log + ((~(static_cast<IntType>(2) << (log - 1)) & m)? 32 : 31)) / 32;
    ::boost::uint_least32_t array[log / 32 + 4];
    seq.generate(&array[0], &array[0] + k + 3);
    IntType s = 0;
    for(int j = 0; j < k; ++j) {
        IntType digit = const_mod<IntType, m>::apply(IntType(array[j+3]));
        IntType mult = IntType(1) << 32*j;
        s = const_mod<IntType, m>::mult_add(mult, digit, s);
    }
    return s;
}

template<class IntType, IntType m, class Iter>
IntType get_one_int(Iter& first, Iter last)
{
    static const int log = ::boost::mpl::if_c<(m == 0),
        ::boost::mpl::int_<(::std::numeric_limits<IntType>::digits)>,
        ::boost::static_log2<m> >::type::value;
    static const int k =
        (log + ((~(static_cast<IntType>(2) << (log - 1)) & m)? 32 : 31)) / 32;
    IntType s = 0;
    for(int j = 0; j < k; ++j) {
        if(first == last) {
            boost::throw_exception(::std::invalid_argument("Not enough elements in call to seed."));
        }
        IntType digit = const_mod<IntType, m>::apply(IntType(*first++));
        IntType mult = IntType(1) << 32*j;
        s = const_mod<IntType, m>::mult_add(mult, digit, s);
    }
    return s;
}


template<int w, std::size_t n, class SeedSeq, class UIntType>
void seed_array_int_impl(SeedSeq& seq, UIntType (&x)[n])
{
    boost::uint_least32_t storage[((w+31)/32) * n];
    seq.generate(&storage[0], &storage[0] + ((w+31)/32) * n);
    for(std::size_t j = 0; j < n; j++) {
        UIntType val = 0;
        for(std::size_t k = 0; k < (w+31)/32; ++k) {
            val += static_cast<UIntType>(storage[(w+31)/32*j + k]) << 32*k;
        }
        x[j] = val & ::boost::low_bits_mask_t<w>::sig_bits;
    }
}

template<int w, std::size_t n, class SeedSeq, class IntType>
inline void seed_array_int_impl(SeedSeq& seq, IntType (&x)[n], boost::mpl::true_)
{
    static_assert(boost::is_integral<IntType>::value, "Sorry but this routine has not been ported to non built-in integers as it relies on a reinterpret_cast.");
    typedef typename boost::make_unsigned<IntType>::type unsigned_array[n];
    seed_array_int_impl<w>(seq, reinterpret_cast<unsigned_array&>(x));
}

template<int w, std::size_t n, class SeedSeq, class IntType>
inline void seed_array_int_impl(SeedSeq& seq, IntType (&x)[n], boost::mpl::false_)
{
    seed_array_int_impl<w>(seq, x);
}

template<int w, std::size_t n, class SeedSeq, class IntType>
inline void seed_array_int(SeedSeq& seq, IntType (&x)[n])
{
    seed_array_int_impl<w>(seq, x, boost::random::traits::is_signed<IntType>());
}

template<int w, std::size_t n, class Iter, class UIntType>
void fill_array_int_impl(Iter& first, Iter last, UIntType (&x)[n])
{
    for(std::size_t j = 0; j < n; j++) {
        UIntType val = 0;
        for(std::size_t k = 0; k < (w+31)/32; ++k) {
            if(first == last) {
                boost::throw_exception(std::invalid_argument("Not enough elements in call to seed."));
            }
            val += static_cast<UIntType>(*first++) << 32*k;
        }
        x[j] = val & ::boost::low_bits_mask_t<w>::sig_bits;
    }
}

template<int w, std::size_t n, class Iter, class IntType>
inline void fill_array_int_impl(Iter& first, Iter last, IntType (&x)[n], boost::mpl::true_)
{
    static_assert(boost::is_integral<IntType>::value, "Sorry but this routine has not been ported to non built-in integers as it relies on a reinterpret_cast.");
    typedef typename boost::make_unsigned<IntType>::type unsigned_array[n];
    fill_array_int_impl<w>(first, last, reinterpret_cast<unsigned_array&>(x));
}

template<int w, std::size_t n, class Iter, class IntType>
inline void fill_array_int_impl(Iter& first, Iter last, IntType (&x)[n], boost::mpl::false_)
{
    fill_array_int_impl<w>(first, last, x);
}

template<int w, std::size_t n, class Iter, class IntType>
inline void fill_array_int(Iter& first, Iter last, IntType (&x)[n])
{
    fill_array_int_impl<w>(first, last, x, boost::random::traits::is_signed<IntType>());
}

template<int w, std::size_t n, class RealType>
void seed_array_real_impl(const boost::uint_least32_t* storage, RealType (&x)[n])
{
    boost::uint_least32_t mask = ~((~boost::uint_least32_t(0)) << (w%32));
    RealType two32 = 4294967296.0;
    const RealType divisor = RealType(1)/detail::pow2<RealType>(w);
    unsigned int j;
    for(j = 0; j < n; ++j) {
        RealType val = RealType(0);
        RealType mult = divisor;
        for(int k = 0; k < w/32; ++k) {
            val += *storage++ * mult;
            mult *= two32;
        }
        if(mask != 0) {
            val += (*storage++ & mask) * mult;
        }
        (static_cast<void> (0));
        (static_cast<void> (0));
        x[j] = val;
    }
}

template<int w, std::size_t n, class SeedSeq, class RealType>
void seed_array_real(SeedSeq& seq, RealType (&x)[n])
{
    using std::pow;
    boost::uint_least32_t storage[((w+31)/32) * n];
    seq.generate(&storage[0], &storage[0] + ((w+31)/32) * n);
    seed_array_real_impl<w>(storage, x);
}

template<int w, std::size_t n, class Iter, class RealType>
void fill_array_real(Iter& first, Iter last, RealType (&x)[n])
{
    boost::uint_least32_t mask = ~((~boost::uint_least32_t(0)) << (w%32));
    RealType two32 = 4294967296.0;
    const RealType divisor = RealType(1)/detail::pow2<RealType>(w);
    unsigned int j;
    for(j = 0; j < n; ++j) {
        RealType val = RealType(0);
        RealType mult = divisor;
        for(int k = 0; k < w/32; ++k, ++first) {
            if(first == last) boost::throw_exception(std::invalid_argument("Not enough elements in call to seed."));
            val += *first * mult;
            mult *= two32;
        }
        if(mask != 0) {
            if(first == last) boost::throw_exception(std::invalid_argument("Not enough elements in call to seed."));
            val += (*first & mask) * mult;
            ++first;
        }
        (static_cast<void> (0));
        (static_cast<void> (0));
        x[j] = val;
    }
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 3 4
#pragma GCC diagnostic pop
# 397 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/seed_impl.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/generator_seed_seq.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/generator_seed_seq.hpp" 3 4
namespace boost {
namespace random {
namespace detail {

template<class Generator>
class generator_seed_seq {
public:
    generator_seed_seq(Generator& g) : gen(&g) {}
    template<class It>
    void generate(It first, It last) {
        for(; first != last; ++first) {
            *first = (*gen)();
        }
    }
private:
    Generator* gen;
};

}
}
}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/polynomial.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/polynomial.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/polynomial.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/polynomial.hpp" 2 3 4

namespace boost {
namespace random {
namespace detail {

class polynomial_ops {
public:
    typedef unsigned long digit_t;

    static void add(std::size_t size, const digit_t * lhs,
                       const digit_t * rhs, digit_t * output)
    {
        for(std::size_t i = 0; i < size; ++i) {
            output[i] = lhs[i] ^ rhs[i];
        }
    }

    static void add_shifted_inplace(std::size_t size, const digit_t * lhs,
                                    digit_t * output, std::size_t shift)
    {
        if(shift == 0) {
            add(size, lhs, output, output);
            return;
        }
        std::size_t bits = std::numeric_limits<digit_t>::digits;
        digit_t prev = 0;
        for(std::size_t i = 0; i < size; ++i) {
            digit_t tmp = lhs[i];
            output[i] ^= (tmp << shift) | (prev >> (bits-shift));
            prev = tmp;
        }
        output[size] ^= (prev >> (bits-shift));
    }

    static void multiply_simple(std::size_t size, const digit_t * lhs,
                                   const digit_t * rhs, digit_t * output)
    {
        std::size_t bits = std::numeric_limits<digit_t>::digits;
        for(std::size_t i = 0; i < 2*size; ++i) {
            output[i] = 0;
        }
        for(std::size_t i = 0; i < size; ++i) {
            for(std::size_t j = 0; j < bits; ++j) {
                if((lhs[i] & (digit_t(1) << j)) != 0) {
                    add_shifted_inplace(size, rhs, output + i, j);
                }
            }
        }
    }


    static void multiply_karatsuba(std::size_t size,
                               const digit_t * lhs, const digit_t * rhs,
                               digit_t * output)
    {
        if(size < 64) {
            multiply_simple(size, lhs, rhs, output);
            return;
        }

        std::size_t cutoff = size/2;
        multiply_karatsuba(cutoff, lhs, rhs, output);
        multiply_karatsuba(size - cutoff, lhs + cutoff, rhs + cutoff,
                              output + cutoff*2);
        std::vector<digit_t> local1(size - cutoff);
        std::vector<digit_t> local2(size - cutoff);

        add(cutoff, lhs, lhs + cutoff, &local1[0]);
        if(size & 1) local1[cutoff] = lhs[size - 1];
        add(cutoff, rhs + cutoff, rhs, &local2[0]);
        if(size & 1) local2[cutoff] = rhs[size - 1];
        std::vector<digit_t> local3((size - cutoff) * 2);
        multiply_karatsuba(size - cutoff, &local1[0], &local2[0], &local3[0]);
        add(cutoff * 2, output, &local3[0], &local3[0]);
        add((size - cutoff) * 2, output + cutoff*2, &local3[0], &local3[0]);

        add((size - cutoff) * 2, output + cutoff, &local3[0], output + cutoff);
    }

    static void multiply_add_karatsuba(std::size_t size,
                                       const digit_t * lhs, const digit_t * rhs,
                                       digit_t * output)
    {
        std::vector<digit_t> buf(size * 2);
        multiply_karatsuba(size, lhs, rhs, &buf[0]);
        add(size * 2, &buf[0], output, output);
    }

    static void multiply(const digit_t * lhs, std::size_t lhs_size,
                         const digit_t * rhs, std::size_t rhs_size,
                         digit_t * output)
    {
        std::fill_n(output, lhs_size + rhs_size, digit_t(0));
        multiply_add(lhs, lhs_size, rhs, rhs_size, output);
    }

    static void multiply_add(const digit_t * lhs, std::size_t lhs_size,
                             const digit_t * rhs, std::size_t rhs_size,
                             digit_t * output)
    {


        while(lhs_size != 0) {
            if(lhs_size < rhs_size) {
                std::swap(lhs, rhs);
                std::swap(lhs_size, rhs_size);
            }

            multiply_add_karatsuba(rhs_size, lhs, rhs, output);

            lhs += rhs_size;
            lhs_size -= rhs_size;
            output += rhs_size;
        }
    }

    static void copy_bits(const digit_t * x, std::size_t low, std::size_t high,
                   digit_t * out)
    {
        const std::size_t bits = std::numeric_limits<digit_t>::digits;
        std::size_t offset = low/bits;
        x += offset;
        low -= offset*bits;
        high -= offset*bits;
        std::size_t n = (high-low)/bits;
        if(low == 0) {
            for(std::size_t i = 0; i < n; ++i) {
                out[i] = x[i];
            }
        } else {
            for(std::size_t i = 0; i < n; ++i) {
                out[i] = (x[i] >> low) | (x[i+1] << (bits-low));
            }
        }
        if((high-low)%bits) {
            digit_t low_mask = (digit_t(1) << ((high-low)%bits)) - 1;
            digit_t result = (x[n] >> low);
            if(low != 0 && (n+1)*bits < high) {
                result |= (x[n+1] << (bits-low));
            }
            out[n] = (result & low_mask);
        }
    }

    static void shift_left(digit_t * val, std::size_t size, std::size_t shift)
    {
        const std::size_t bits = std::numeric_limits<digit_t>::digits;
        (static_cast<void> (0));
        (static_cast<void> (0));
        digit_t prev = 0;
        for(std::size_t i = 0; i < size; ++i) {
            digit_t tmp = val[i];
            val[i] = (prev >> (bits - shift)) | (val[i] << shift);
            prev = tmp;
        }
    }

    static digit_t sqr(digit_t val) {
        const std::size_t bits = std::numeric_limits<digit_t>::digits;
        digit_t mask = (digit_t(1) << bits/2) - 1;
        for(std::size_t i = bits; i > 1; i /= 2) {
            val = ((val & ~mask) << i/2) | (val & mask);
            mask = mask & (mask >> i/4);
            mask = mask | (mask << i/2);
        }
        return val;
    }

    static void sqr(digit_t * val, std::size_t size)
    {
        const std::size_t bits = std::numeric_limits<digit_t>::digits;
        digit_t mask = (digit_t(1) << bits/2) - 1;
        for(std::size_t i = 0; i < size; ++i) {
            digit_t x = val[size - i - 1];
            val[(size - i - 1) * 2] = sqr(x & mask);
            val[(size - i - 1) * 2 + 1] = sqr(x >> bits/2);
        }
    }


    struct sparse_mod {
        sparse_mod(const digit_t * divisor, std::size_t divisor_bits)
        {
            const std::size_t bits = std::numeric_limits<digit_t>::digits;
            _remainder_bits = divisor_bits - 1;
            for(std::size_t i = 0; i < divisor_bits; ++i) {
                if(divisor[i/bits] & (digit_t(1) << i%bits)) {
                    _bit_indices.push_back(i);
                }
            }
            (static_cast<void> (0));
            _bit_indices.pop_back();
            if(_bit_indices.empty()) {
                _block_bits = divisor_bits;
                _lower_bits = 0;
            } else {
                _block_bits = divisor_bits - _bit_indices.back() - 1;
                _lower_bits = _bit_indices.back() + 1;
            }

            _partial_quotient.resize((_block_bits + bits - 1)/bits);
        }
        void operator()(digit_t * dividend, std::size_t dividend_bits)
        {
            const std::size_t bits = std::numeric_limits<digit_t>::digits;
            while(dividend_bits > _remainder_bits) {
                std::size_t block_start = (std::max)(dividend_bits - _block_bits, _remainder_bits);
                std::size_t block_size = (dividend_bits - block_start + bits - 1) / bits;
                copy_bits(dividend, block_start, dividend_bits, &_partial_quotient[0]);
                for(std::size_t i = 0; i < _bit_indices.size(); ++i) {
                    std::size_t pos = _bit_indices[i] + block_start - _remainder_bits;
                    add_shifted_inplace(block_size, &_partial_quotient[0], dividend + pos/bits, pos%bits);
                }
                add_shifted_inplace(block_size, &_partial_quotient[0], dividend + block_start/bits, block_start%bits);
                dividend_bits = block_start;
            }
        }
        std::vector<digit_t> _partial_quotient;
        std::size_t _remainder_bits;
        std::size_t _block_bits;
        std::size_t _lower_bits;
        std::vector<std::size_t> _bit_indices;
    };




    static void mod_pow_x(boost::uintmax_t exponent, const digit_t * mod, std::size_t mod_bits, digit_t * out)
    {
        const std::size_t bits = std::numeric_limits<digit_t>::digits;
        const std::size_t n = (mod_bits + bits - 1) / bits;
        const std::size_t highbit = mod_bits - 1;
        if(exponent == 0) {
            out[0] = 1;
            std::fill_n(out + 1, n - 1, digit_t(0));
            return;
        }
        boost::uintmax_t i = std::numeric_limits<boost::uintmax_t>::digits - 1;
        while(((boost::uintmax_t(1) << i) & exponent) == 0) {
            --i;
        }
        out[0] = 2;
        std::fill_n(out + 1, n - 1, digit_t(0));
        sparse_mod m(mod, mod_bits);
        while(i--) {
            sqr(out, n);
            m(out, 2 * mod_bits - 1);
            if((boost::uintmax_t(1) << i) & exponent) {
                shift_left(out, n, 1);
                if(out[highbit / bits] & (digit_t(1) << highbit%bits))
                    add(n, out, mod, out);
            }
        }
    }
};

class polynomial
{
    typedef polynomial_ops::digit_t digit_t;
public:
    polynomial() : _size(0) {}
    class reference {
    public:
        reference(digit_t &value, int idx)
            : _value(value), _idx(idx) {}
        operator bool() const { return (_value & (digit_t(1) << _idx)) != 0; }
        reference& operator=(bool b)
        {
            if(b) {
                _value |= (digit_t(1) << _idx);
            } else {
                _value &= ~(digit_t(1) << _idx);
            }
            return *this;
        }
        reference &operator^=(bool b)
        {
            _value ^= (digit_t(b) << _idx);
            return *this;
        }

        reference &operator=(const reference &other)
        {
            return *this = static_cast<bool>(other);
        }
    private:
        digit_t &_value;
        int _idx;
    };
    reference operator[](std::size_t i)
    {
        static const std::size_t bits = std::numeric_limits<digit_t>::digits;
        ensure_bit(i);
        return reference(_storage[i/bits], i%bits);
    }
    bool operator[](std::size_t i) const
    {
        static const std::size_t bits = std::numeric_limits<digit_t>::digits;
        if(i < size())
            return (_storage[i/bits] & (digit_t(1) << (i%bits))) != 0;
        else
            return false;
    }
    std::size_t size() const
    {
        return _size;
    }
    void resize(std::size_t n)
    {
        static const std::size_t bits = std::numeric_limits<digit_t>::digits;
        _storage.resize((n + bits - 1)/bits);

        if(n%bits) {
            _storage.back() &= ((digit_t(1) << (n%bits)) - 1);
        }
        _size = n;
    }
    friend polynomial operator*(const polynomial &lhs, const polynomial &rhs);
    friend polynomial mod_pow_x(boost::uintmax_t exponent, polynomial mod);
private:
    std::vector<polynomial_ops::digit_t> _storage;
    std::size_t _size;
    void ensure_bit(std::size_t i)
    {
        if(i >= size()) {
            resize(i + 1);
        }
    }
    void normalize()
    {
        while(size() && (*this)[size() - 1] == 0)
            resize(size() - 1);
    }
};

inline polynomial operator*(const polynomial &lhs, const polynomial &rhs)
{
    polynomial result;
    result._storage.resize(lhs._storage.size() + rhs._storage.size());
    polynomial_ops::multiply(&lhs._storage[0], lhs._storage.size(),
                             &rhs._storage[0], rhs._storage.size(),
                             &result._storage[0]);
    result._size = lhs._size + rhs._size;
    return result;
}

inline polynomial mod_pow_x(boost::uintmax_t exponent, polynomial mod)
{
    polynomial result;
    mod.normalize();
    std::size_t mod_size = mod.size();
    result._storage.resize(mod._storage.size() * 2);
    result._size = mod.size() * 2;
    polynomial_ops::mod_pow_x(exponent, &mod._storage[0], mod_size, &result._storage[0]);
    result.resize(mod.size() - 1);
    return result;
}

}
}
}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlogical-op"
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4

namespace boost {
namespace random {
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
template<class UIntType,
         std::size_t w, std::size_t n, std::size_t m, std::size_t r,
         UIntType a, std::size_t u, UIntType d, std::size_t s,
         UIntType b, std::size_t t,
         UIntType c, std::size_t l, UIntType f>
class mersenne_twister_engine
{
public:
    typedef UIntType result_type;
    static const std::size_t word_size = w;
    static const std::size_t state_size = n;
    static const std::size_t shift_size = m;
    static const std::size_t mask_bits = r;
    static const UIntType xor_mask = a;
    static const std::size_t tempering_u = u;
    static const UIntType tempering_d = d;
    static const std::size_t tempering_s = s;
    static const UIntType tempering_b = b;
    static const std::size_t tempering_t = t;
    static const UIntType tempering_c = c;
    static const std::size_t tempering_l = l;
    static const UIntType initialization_multiplier = f;
    static const UIntType default_seed = 5489u;


    static const UIntType parameter_a = a;
    static const std::size_t output_u = u;
    static const std::size_t output_s = s;
    static const UIntType output_b = b;
    static const std::size_t output_t = t;
    static const UIntType output_c = c;
    static const std::size_t output_l = l;


    static const bool has_fixed_range = false;





    mersenne_twister_engine() { seed(); }




    explicit mersenne_twister_engine(const UIntType& value)

    { seed(value); }
    template<class It> mersenne_twister_engine(It& first, It last)
    { seed(first,last); }
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
    template<class SeedSeq> explicit mersenne_twister_engine(SeedSeq& seq, typename ::boost::random::detail::disable_constructor<mersenne_twister_engine, SeedSeq>::type* = 0)

    { seed(seq); }




    void seed() { seed(default_seed); }







    void seed(const UIntType& value)
    {




        const UIntType mask = (max)();
        x[0] = value & mask;
        for (i = 1; i < n; i++) {


            x[i] = (f * (x[i-1] ^ (x[i-1] >> (w-2))) + i) & mask;
        }

        normalize_state();
    }




    template<class SeeqSeq> void seed(SeeqSeq& seq, typename ::boost::random::detail::disable_seed<SeeqSeq>::type* = 0)
    {
        detail::seed_array_int<w>(seq, x);
        i = n;

        normalize_state();
    }


    template<class It>
    void seed(It& first, It last)
    {
        detail::fill_array_int<w>(first, last, x);
        i = n;

        normalize_state();
    }


    static result_type min ()
    { return 0; }

    static result_type max ()
    { return boost::low_bits_mask_t<w>::sig_bits; }


    result_type operator()();


    template<class Iter>
    void generate(Iter first, Iter last)
    { detail::generate_from_int(*this, first, last); }
# 203 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
    void discard(boost::uintmax_t z)
    {



        if(z > 10000000) {
            discard_many(z);
        } else {
            for(boost::uintmax_t j = 0; j < z; ++j) {
                (*this)();
            }
        }
    }



    template<class CharT, class Traits>
    friend std::basic_ostream<CharT,Traits>&
    operator<<(std::basic_ostream<CharT,Traits>& os,
               const mersenne_twister_engine& mt)
    {
        mt.print(os);
        return os;
    }


    template<class CharT, class Traits>
    friend std::basic_istream<CharT,Traits>&
    operator>>(std::basic_istream<CharT,Traits>& is,
               mersenne_twister_engine& mt)
    {
        for(std::size_t j = 0; j < mt.state_size; ++j)
            is >> mt.x[j] >> std::ws;



        mt.i = mt.state_size;
        return is;
    }






    friend bool operator==(const mersenne_twister_engine& x_,
                           const mersenne_twister_engine& y_)
    {
        if(x_.i < y_.i) return x_.equal_imp(y_);
        else return y_.equal_imp(x_);
    }




    friend bool operator!=(const mersenne_twister_engine& x_,
                           const mersenne_twister_engine& y_)
    { return !(x_ == y_); }

private:


    void twist();
# 275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
    bool equal_imp(const mersenne_twister_engine& other) const
    {
        UIntType back[n];
        std::size_t offset = other.i - i;
        for(std::size_t j = 0; j + offset < n; ++j)
            if(x[j] != other.x[j+offset])
                return false;
        rewind(&back[n-1], offset);
        for(std::size_t j = 0; j < offset; ++j)
            if(back[j + n - offset] != other.x[j])
                return false;
        return true;
    }





    template<class CharT, class Traits>
    void print(std::basic_ostream<CharT, Traits>& os) const
    {
        UIntType data[n];
        for(std::size_t j = 0; j < i; ++j) {
            data[j + n - i] = x[j];
        }
        if(i != n) {
            rewind(&data[n - i - 1], n - i);
        }
        os << data[0];
        for(std::size_t j = 1; j < n; ++j) {
            os << ' ' << data[j];
        }
    }





    void rewind(UIntType* last, std::size_t z) const
    {
        const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
        const UIntType lower_mask = ~upper_mask;
        UIntType y0 = x[m-1] ^ x[n-1];
        if(y0 & (static_cast<UIntType>(1) << (w-1))) {
            y0 = ((y0 ^ a) << 1) | 1;
        } else {
            y0 = y0 << 1;
        }
        for(std::size_t sz = 0; sz < z; ++sz) {
            UIntType y1 =
                rewind_find(last, sz, m-1) ^ rewind_find(last, sz, n-1);
            if(y1 & (static_cast<UIntType>(1) << (w-1))) {
                y1 = ((y1 ^ a) << 1) | 1;
            } else {
                y1 = y1 << 1;
            }
            *(last - sz) = (y0 & upper_mask) | (y1 & lower_mask);
            y0 = y1;
        }
    }
# 346 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
    void normalize_state()
    {
        const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
        const UIntType lower_mask = ~upper_mask;
        UIntType y0 = x[m-1] ^ x[n-1];
        if(y0 & (static_cast<UIntType>(1) << (w-1))) {
            y0 = ((y0 ^ a) << 1) | 1;
        } else {
            y0 = y0 << 1;
        }
        x[0] = (x[0] & upper_mask) | (y0 & lower_mask);


        for(std::size_t j = 0; j < n; ++j) {
            if(x[j] != 0) return;
        }
        x[0] = static_cast<UIntType>(1) << (w-1);
    }






    UIntType
    rewind_find(UIntType* last, std::size_t size, std::size_t j) const
    {
        std::size_t index = (j + n - size + n - 1) % n;
        if(index < n - size) {
            return x[index];
        } else {
            return *(last - (n - 1 - index));
        }
    }
# 390 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
    void discard_many(boost::uintmax_t z)
    {
# 402 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
        detail::polynomial phi = get_characteristic_polynomial();


        detail::polynomial g = mod_pow_x(z, phi);


        detail::polynomial h;
        const std::size_t num_bits = w*n - r;
        for(std::size_t j = 0; j < num_bits * 2; ++j) {




            if(i >= n) twist();
            h[2*num_bits - j - 1] = x[i++] & UIntType(1);
        }

        detail::polynomial gh = g * h;
        detail::polynomial result;
        for(std::size_t j = 0; j <= num_bits; ++j) {
            result[j] = gh[2*num_bits - j - 1];
        }
        reconstruct_state(result);
    }
    static detail::polynomial get_characteristic_polynomial()
    {
        const std::size_t num_bits = w*n - r;
        detail::polynomial helper;
        helper[num_bits - 1] = 1;
        mersenne_twister_engine tmp;
        tmp.reconstruct_state(helper);


        for(std::size_t j = 0; j < num_bits; ++j) {
            if(tmp.i >= n) tmp.twist();
            if(j == num_bits - 1)
                (static_cast<void> (0));
            else
                (static_cast<void> (0));
            ++tmp.i;
        }
        detail::polynomial phi;
        phi[num_bits] = 1;
        detail::polynomial next_bits = tmp.as_polynomial(num_bits);
        for(std::size_t j = 0; j < num_bits; ++j) {
            int val = next_bits[j] ^ phi[num_bits-j-1];
            phi[num_bits-j-1] = val;
            if(val) {
                for(std::size_t k = j + 1; k < num_bits; ++k) {
                    phi[num_bits-k-1] ^= next_bits[k-j-1];
                }
            }
        }
        return phi;
    }
    detail::polynomial as_polynomial(std::size_t size) {
        detail::polynomial result;
        for(std::size_t j = 0; j < size; ++j) {
            if(i >= n) twist();
            result[j] = x[i++] & UIntType(1);
        }
        return result;
    }
    void reconstruct_state(const detail::polynomial& p)
    {
        const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
        const UIntType lower_mask = ~upper_mask;
        const std::size_t num_bits = w*n - r;
        for(std::size_t j = num_bits - n + 1; j <= num_bits; ++j)
            x[j % n] = p[j];

        UIntType y0 = 0;
        for(std::size_t j = num_bits + 1; j >= n - 1; --j) {
            UIntType y1 = x[j % n] ^ x[(j + m) % n];
            if(p[j - n + 1])
                y1 = (y1 ^ a) << UIntType(1) | UIntType(1);
            else
                y1 = y1 << UIntType(1);
            x[(j + 1) % n] = (y0 & upper_mask) | (y1 & lower_mask);
            y0 = y1;
        }
        i = 0;
    }







    UIntType x[n];
    std::size_t i;
};
# 505 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::word_size;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::state_size;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::shift_size;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::mask_bits;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::xor_mask;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::tempering_u;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::tempering_d;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::tempering_s;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::tempering_b;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::tempering_t;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::tempering_c;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::tempering_l;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::initialization_multiplier;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::default_seed;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::parameter_a;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::output_u;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::output_s;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::output_b;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::output_t;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const UIntType mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::output_c;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const std::size_t mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::output_l;
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> const bool mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::has_fixed_range;



template<class UIntType,
         std::size_t w, std::size_t n, std::size_t m, std::size_t r,
         UIntType a, std::size_t u, UIntType d, std::size_t s,
         UIntType b, std::size_t t,
         UIntType c, std::size_t l, UIntType f>
void
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::twist()
{
    const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
    const UIntType lower_mask = ~upper_mask;

    const std::size_t unroll_factor = 6;
    const std::size_t unroll_extra1 = (n-m) % unroll_factor;
    const std::size_t unroll_extra2 = (m-1) % unroll_factor;


    {
        for(std::size_t j = 0; j < n-m-unroll_extra1; j++) {
            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
            x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);
        }
    }
    {
        for(std::size_t j = n-m-unroll_extra1; j < n-m; j++) {
            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
            x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);
        }
    }
    {
        for(std::size_t j = n-m; j < n-1-unroll_extra2; j++) {
            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
            x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);
        }
    }
    {
        for(std::size_t j = n-1-unroll_extra2; j < n-1; j++) {
            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
            x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);
        }
    }

    UIntType y = (x[n-1] & upper_mask) | (x[0] & lower_mask);
    x[n-1] = x[m-1] ^ (y >> 1) ^ ((x[0]&1) * a);
    i = 0;
}


template<class UIntType,
         std::size_t w, std::size_t n, std::size_t m, std::size_t r,
         UIntType a, std::size_t u, UIntType d, std::size_t s,
         UIntType b, std::size_t t,
         UIntType c, std::size_t l, UIntType f>
inline typename
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::result_type
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::operator()()
{
    if(i == n)
        twist();

    UIntType z = x[i];
    ++i;
    z ^= ((z >> u) & d);
    z ^= ((z << s) & b);
    z ^= ((z << t) & c);
    z ^= (z >> l);
    return z;
}
# 609 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
typedef mersenne_twister_engine<uint32_t,32,351,175,19,0xccab8ee7,
    11,0xffffffff,7,0x31b6ab00,15,0xffe50000,17,1812433253> mt11213b;
# 623 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 3 4
typedef mersenne_twister_engine<uint32_t,32,624,397,31,0x9908b0df,
    11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253> mt19937;


typedef mersenne_twister_engine<uint64_t,64,312,156,31,
    0xb5026f5aa96619e9UL,29,0x5555555555555555UL,17,
    0x71d67fffeda60000UL,37,0xfff7eee000000000UL,43,
    6364136223846793005UL> mt19937_64;




template<class UIntType,
         int w, int n, int m, int r,
         UIntType a, int u, std::size_t s,
         UIntType b, int t,
         UIntType c, int l, UIntType v>
class mersenne_twister :
    public mersenne_twister_engine<UIntType,
        w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253>
{
    typedef mersenne_twister_engine<UIntType,
        w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253> base_type;
public:
    mersenne_twister() {}
    template<class Gen> explicit mersenne_twister(Gen& gen, typename ::boost::random::detail::disable_constructor<mersenne_twister, Gen>::type* = 0)
    { seed(gen); }
    explicit mersenne_twister(const UIntType& val)
    { seed(val); }
    template<class It>
    mersenne_twister(It& first, It last) : base_type(first, last) {}
    void seed() { base_type::seed(); }
    template<class Gen> void seed(Gen& gen, typename ::boost::random::detail::disable_seed<Gen>::type* = 0)
    {
        detail::generator_seed_seq<Gen> seq(gen);
        base_type::seed(seq);
    }
    void seed(const UIntType& val)
    { base_type::seed(val); }
    template<class It>
    void seed(It& first, It last) { base_type::seed(first, last); }
};



}

using random::mt11213b;
using random::mt19937;
using random::mt19937_64;

}





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 3 4
#pragma GCC diagnostic pop
# 681 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/mersenne_twister.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/config.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/operators.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/operators.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/config.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/operators.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/uniform_int_float.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/uniform_int_float.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/config.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/uniform_int_float.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlogical-op"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/uniform_int_float.hpp" 2 3 4

namespace boost {
namespace random {
namespace detail {

template<class URNG>
class uniform_int_float
{
public:
    typedef URNG base_type;
    typedef typename base_type::result_type base_result;

    typedef typename boost::uint_t<
        (std::numeric_limits<boost::uintmax_t>::digits <
            std::numeric_limits<base_result>::digits)?
        std::numeric_limits<boost::uintmax_t>::digits :
        std::numeric_limits<base_result>::digits
    >::fast result_type;

    uniform_int_float(base_type& rng)
      : _rng(rng) {}

    static result_type min ()
    { return 0; }
    static result_type max ()
    {
        std::size_t digits = std::numeric_limits<result_type>::digits;
        if(detail::generator_bits<URNG>::value() < digits) {
            digits = detail::generator_bits<URNG>::value();
        }
        return (result_type(2) << (digits - 1)) - 1;
    }
    base_type& base() { return _rng; }
    const base_type& base() const { return _rng; }

    result_type operator()()
    {
        base_result range = static_cast<base_result>((max)())+1;
        return static_cast<result_type>(_rng() * range);
    }

private:
    base_type& _rng;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 3 4
#pragma GCC diagnostic pop
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/uniform_int_float.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 2 3 4







namespace boost {
namespace random {
namespace detail {
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 3 4
template<class Engine, class T>
T generate_uniform_int(
    Engine& eng, T min_value, T max_value,
    boost::mpl::true_ )
{
    typedef T result_type;
    typedef typename boost::random::traits::make_unsigned_or_unbounded<T>::type range_type;
    typedef typename Engine::result_type base_result;

    typedef typename boost::random::traits::make_unsigned_or_unbounded<base_result>::type base_unsigned;
    const range_type range = random::detail::subtract<result_type>()(max_value, min_value);
    const base_result bmin = (eng.min)();
    const base_unsigned brange =
      random::detail::subtract<base_result>()((eng.max)(), (eng.min)());

    if(range == 0) {
      return min_value;
    } else if(brange == range) {


      base_unsigned v = random::detail::subtract<base_result>()(eng(), bmin);
      return random::detail::add<base_unsigned, result_type>()(v, min_value);
    } else if(brange < range) {

      for(;;) {





        range_type limit;
        if(range == (std::numeric_limits<range_type>::max)()) {
          limit = range/(range_type(brange)+1);
          if(range % (range_type(brange)+1) == range_type(brange))
            ++limit;
        } else {
          limit = (range+1)/(range_type(brange)+1);
        }



        range_type result = range_type(0);
        range_type mult = range_type(1);




        while(mult <= limit) {
# 117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 3 4
          result += static_cast<range_type>(static_cast<range_type>(random::detail::subtract<base_result>()(eng(), bmin)) * mult);


          if(mult * range_type(brange) == range - mult + 1) {


              return(result);
          }
# 137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 3 4
          mult *= range_type(brange)+range_type(1);
        }
# 165 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 3 4
        range_type result_increment =
            generate_uniform_int(
                eng,
                static_cast<range_type>(0),
                static_cast<range_type>(range/mult),
                boost::mpl::true_());
        if(std::numeric_limits<range_type>::is_bounded && ((std::numeric_limits<range_type>::max)() / mult < result_increment)) {

          continue;
        }
        result_increment *= mult;

        result += result_increment;
        if(result < result_increment) {

          continue;
        }
        if(result > range) {

          continue;
        }
        return random::detail::add<range_type, result_type>()(result, min_value);
      }
    } else {






      typedef base_unsigned mixed_range_type;


      mixed_range_type bucket_size;
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 3 4
      if(brange == (std::numeric_limits<base_unsigned>::max)()) {
        bucket_size = static_cast<mixed_range_type>(brange) / (static_cast<mixed_range_type>(range)+1);
        if(static_cast<mixed_range_type>(brange) % (static_cast<mixed_range_type>(range)+1) == static_cast<mixed_range_type>(range)) {
          ++bucket_size;
        }
      } else {
        bucket_size = static_cast<mixed_range_type>(brange + 1) / (static_cast<mixed_range_type>(range)+1);
      }
      for(;;) {
        mixed_range_type result =
          random::detail::subtract<base_result>()(eng(), bmin);
        result /= bucket_size;


        if(result <= static_cast<mixed_range_type>(range))
          return random::detail::add<mixed_range_type, result_type>()(result, min_value);
      }
    }
}





template<class Engine, class T>
inline T generate_uniform_int(
    Engine& eng, T min_value, T max_value,
    boost::mpl::false_ )
{
    uniform_int_float<Engine> wrapper(eng);
    return generate_uniform_int(wrapper, min_value, max_value, boost::mpl::true_());
}

template<class Engine, class T>
inline T generate_uniform_int(Engine& eng, T min_value, T max_value)
{
    typedef typename Engine::result_type base_result;
    return generate_uniform_int(eng, min_value, max_value,
        boost::random::traits::is_integral<base_result>());
}

}
# 260 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int_distribution.hpp" 3 4
template<class IntType = int>
class uniform_int_distribution
{
public:
    typedef IntType input_type;
    typedef IntType result_type;

    class param_type
    {
    public:

        typedef uniform_int_distribution distribution_type;






        explicit param_type(
            IntType min_arg = 0,
            IntType max_arg = (std::numeric_limits<IntType>::max)())
          : _min(min_arg), _max(max_arg)
        {
            (static_cast<void> (0));
        }


        IntType a() const { return _min; }

        IntType b() const { return _max; }


        template<class CharT, class Traits> friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& os, const param_type& parm)
        {
            os << parm._min << " " << parm._max;
            return os;
        }


        template<class CharT, class Traits> friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& is, param_type& parm)
        {
            IntType min_in, max_in;
            if(is >> min_in >> std::ws >> max_in) {
                if(min_in <= max_in) {
                    parm._min = min_in;
                    parm._max = max_in;
                } else {
                    is.setstate(std::ios_base::failbit);
                }
            }
            return is;
        }


        friend bool operator==(const param_type& lhs, const param_type& rhs)
        { return lhs._min == rhs._min && lhs._max == rhs._max; }


        friend bool operator!=(const param_type& lhs, const param_type& rhs) { return !(lhs == rhs); }

    private:

        IntType _min;
        IntType _max;
    };







    explicit uniform_int_distribution(
        IntType min_arg = 0,
        IntType max_arg = (std::numeric_limits<IntType>::max)())
      : _min(min_arg), _max(max_arg)
    {
        (static_cast<void> (0));
    }

    explicit uniform_int_distribution(const param_type& parm)
      : _min(parm.a()), _max(parm.b()) {}


    IntType min () const { return _min; }

    IntType max () const { return _max; }


    IntType a() const { return _min; }

    IntType b() const { return _max; }


    param_type param() const { return param_type(_min, _max); }

    void param(const param_type& parm)
    {
        _min = parm.a();
        _max = parm.b();
    }





    void reset() { }


    template<class Engine>
    result_type operator()(Engine& eng) const
    { return detail::generate_uniform_int(eng, _min, _max); }





    template<class Engine>
    result_type operator()(Engine& eng, const param_type& parm) const
    { return detail::generate_uniform_int(eng, parm.a(), parm.b()); }


    template<class CharT, class Traits> friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& os, const uniform_int_distribution& ud)
    {
        os << ud.param();
        return os;
    }


    template<class CharT, class Traits> friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& is, uniform_int_distribution& ud)
    {
        param_type parm;
        if(is >> parm) {
            ud.param(parm);
        }
        return is;
    }





    friend bool operator==(const uniform_int_distribution& lhs, const uniform_int_distribution& rhs)
    { return lhs._min == rhs._min && lhs._max == rhs._max; }





    friend bool operator!=(const uniform_int_distribution& lhs, const uniform_int_distribution& rhs) { return !(lhs == rhs); }

private:
    IntType _min;
    IntType _max;
};

}
}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int.hpp" 2 3 4

namespace boost {
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/uniform_int.hpp" 3 4
template<class IntType = int>
class uniform_int : public random::uniform_int_distribution<IntType>
{
    typedef random::uniform_int_distribution<IntType> base_type;
public:

    class param_type : public base_type::param_type
    {
    public:
        typedef uniform_int distribution_type;





        explicit param_type(IntType min_arg = 0, IntType max_arg = 9)
          : base_type::param_type(min_arg, max_arg)
        {}
    };







    explicit uniform_int(IntType min_arg = 0, IntType max_arg = 9)
      : base_type(min_arg, max_arg)
    {}


    explicit uniform_int(const param_type& parm)
      : base_type(parm)
    {}


    param_type param() const { return param_type(this->a(), this->b()); }

    void param(const param_type& parm) { this->base_type::param(parm); }



    template<class Engine>
    IntType operator()(Engine& eng) const
    {
        return static_cast<const base_type&>(*this)(eng);
    }

    template<class Engine>
    IntType operator()(Engine& eng, const param_type& parm) const
    {
        return static_cast<const base_type&>(*this)(eng, parm);
    }

    template<class Engine>
    IntType operator()(Engine& eng, IntType n) const
    {
        (static_cast<void> (0));
        return static_cast<const base_type&>(*this)(eng, param_type(0, n - 1));
    }
};

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/variate_generator.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/variate_generator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/disable_warnings.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlogical-op"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/variate_generator.hpp" 2 3 4

namespace boost {



namespace random {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/variate_generator.hpp" 3 4
template<class Engine, class Distribution>
class variate_generator
{
private:
    typedef boost::random::detail::ptr_helper<Engine> helper_type;
public:
    typedef typename helper_type::value_type engine_value_type;
    typedef Engine engine_type;
    typedef Distribution distribution_type;
    typedef typename Distribution::result_type result_type;
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/variate_generator.hpp" 3 4
    variate_generator(Engine e, Distribution d)
      : _eng(e), _dist(d) { }


    result_type operator()() { return _dist(engine()); }



    template<class T>
    result_type operator()(const T& value) { return _dist(engine(), value); }




    engine_value_type& engine() { return helper_type::ref(_eng); }



    const engine_value_type& engine() const { return helper_type::ref(_eng); }


    distribution_type& distribution() { return _dist; }



    const distribution_type& distribution() const { return _dist; }






    result_type min () const { return (distribution().min)(); }





    result_type max () const { return (distribution().max)(); }

private:
    Engine _eng;
    distribution_type _dist;
};

}

using random::variate_generator;

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/detail/enable_warnings.hpp" 3 4
#pragma GCC diagnostic pop
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/random/variate_generator.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/shared_ptr.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/shared_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/checked_delete.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/bad_weak_ptr.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
namespace boost
{
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
class bad_weak_ptr: public std::exception
{
public:

    virtual char const * what() const throw()
    {
        return "tr1::bad_weak_ptr";
    }
};
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_has_sync.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/sp_typeinfo.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/sp_typeinfo.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/typeinfo.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/typeinfo.hpp" 3 4
namespace boost
{

namespace core
{







typedef std::type_info typeinfo;



inline std::string demangled_name( core::typeinfo const & ti )
{
    return core::demangle( ti.name() );
}

}

}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/sp_typeinfo.hpp" 2 3 4

namespace boost
{

namespace detail
{

typedef boost::core::typeinfo sp_typeinfo;

}

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 2 3 4
# 1 "/usr/include/c++/10/atomic" 1 3 4
# 35 "/usr/include/c++/10/atomic" 3 4
       
# 36 "/usr/include/c++/10/atomic" 3







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

# 56 "/usr/include/c++/10/atomic" 3
  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); }
  };
# 179 "/usr/include/c++/10/atomic" 3
  template<typename _Tp>
    struct atomic
    {
      using value_type = _Tp;

    private:

      static constexpr int _S_min_alignment
 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
 ? 0 : sizeof(_Tp);

      static constexpr int _S_alignment
        = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);

      alignas(_S_alignment) _Tp _M_i ;

      static_assert(__is_trivially_copyable(_Tp),
      "std::atomic requires a trivially copyable type");

      static_assert(sizeof(_Tp) > 0,
      "Incomplete or zero-sized types are not supported");

    public:
      atomic() = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }

      operator _Tp() const noexcept
      { return load(); }

      operator _Tp() const volatile noexcept
      { return load(); }

      _Tp
      operator=(_Tp __i) noexcept
      { store(__i); return __i; }

      _Tp
      operator=(_Tp __i) volatile noexcept
      { store(__i); return __i; }

      bool
      is_lock_free() const noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }


      static constexpr bool is_always_lock_free
 = __atomic_always_lock_free(sizeof(_M_i), 0);


      void
      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
      { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }

      void
      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
      { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }

      _Tp
      load(memory_order __m = memory_order_seq_cst) const noexcept
      {
 alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
 return *__ptr;
      }

      _Tp
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      {
        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
 return *__ptr;
      }

      _Tp
      exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
      {
        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
     __ptr, int(__m));
 return *__ptr;
      }

      _Tp
      exchange(_Tp __i,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      {
        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
 _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
 __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
     __ptr, int(__m));
 return *__ptr;
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
       memory_order __f) noexcept
      {
 return __atomic_compare_exchange(std::__addressof(_M_i),
      std::__addressof(__e),
      std::__addressof(__i),
      true, int(__s), int(__f));
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
       memory_order __f) volatile noexcept
      {
 return __atomic_compare_exchange(std::__addressof(_M_i),
      std::__addressof(__e),
      std::__addressof(__i),
      true, int(__s), int(__f));
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i,
       memory_order __m = memory_order_seq_cst) noexcept
      { return compare_exchange_weak(__e, __i, __m,
                                     __cmpexch_failure_order(__m)); }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i,
       memory_order __m = memory_order_seq_cst) volatile noexcept
      { return compare_exchange_weak(__e, __i, __m,
                                     __cmpexch_failure_order(__m)); }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
         memory_order __f) noexcept
      {
 return __atomic_compare_exchange(std::__addressof(_M_i),
      std::__addressof(__e),
      std::__addressof(__i),
      false, int(__s), int(__f));
      }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
         memory_order __f) volatile noexcept
      {
 return __atomic_compare_exchange(std::__addressof(_M_i),
      std::__addressof(__e),
      std::__addressof(__i),
      false, int(__s), int(__f));
      }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i,
          memory_order __m = memory_order_seq_cst) noexcept
      { return compare_exchange_strong(__e, __i, __m,
                                       __cmpexch_failure_order(__m)); }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i,
       memory_order __m = memory_order_seq_cst) volatile noexcept
      { return compare_exchange_strong(__e, __i, __m,
                                       __cmpexch_failure_order(__m)); }
    };



  template<typename _Tp>
    struct atomic<_Tp*>
    {
      using value_type = _Tp*;
      using difference_type = ptrdiff_t;

      typedef _Tp* __pointer_type;
      typedef __atomic_base<_Tp*> __base_type;
      __base_type _M_b;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }

      operator __pointer_type() const noexcept
      { return __pointer_type(_M_b); }

      operator __pointer_type() const volatile noexcept
      { return __pointer_type(_M_b); }

      __pointer_type
      operator=(__pointer_type __p) noexcept
      { return _M_b.operator=(__p); }

      __pointer_type
      operator=(__pointer_type __p) volatile noexcept
      { return _M_b.operator=(__p); }

      __pointer_type
      operator++(int) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b++;
      }

      __pointer_type
      operator++(int) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b++;
      }

      __pointer_type
      operator--(int) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b--;
      }

      __pointer_type
      operator--(int) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b--;
      }

      __pointer_type
      operator++() noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return ++_M_b;
      }

      __pointer_type
      operator++() volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return ++_M_b;
      }

      __pointer_type
      operator--() noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return --_M_b;
      }

      __pointer_type
      operator--() volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return --_M_b;
      }

      __pointer_type
      operator+=(ptrdiff_t __d) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator+=(__d);
      }

      __pointer_type
      operator+=(ptrdiff_t __d) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator+=(__d);
      }

      __pointer_type
      operator-=(ptrdiff_t __d) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator-=(__d);
      }

      __pointer_type
      operator-=(ptrdiff_t __d) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator-=(__d);
      }

      bool
      is_lock_free() const noexcept
      { return _M_b.is_lock_free(); }

      bool
      is_lock_free() const volatile noexcept
      { return _M_b.is_lock_free(); }


    static constexpr bool is_always_lock_free = 2 == 2;


      void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) noexcept
      { return _M_b.store(__p, __m); }

      void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) volatile noexcept
      { return _M_b.store(__p, __m); }

      __pointer_type
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return _M_b.load(__m); }

      __pointer_type
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      { return _M_b.load(__m); }

      __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) noexcept
      { return _M_b.exchange(__p, __m); }

      __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      { return _M_b.exchange(__p, __m); }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1, memory_order __m2) noexcept
      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1,
       memory_order __m2) volatile noexcept
      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m = memory_order_seq_cst) noexcept
      {
 return compare_exchange_weak(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
      memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return compare_exchange_weak(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1, memory_order __m2) noexcept
      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1,
         memory_order __m2) volatile noexcept
      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m = memory_order_seq_cst) noexcept
      {
 return _M_b.compare_exchange_strong(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }

      bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
      memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 return _M_b.compare_exchange_strong(__p1, __p2, __m,
         __cmpexch_failure_order(__m));
      }

      __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_add(__d, __m);
      }

      __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_add(__d, __m);
      }

      __pointer_type
      fetch_sub(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_sub(__d, __m);
      }

      __pointer_type
      fetch_sub(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_sub(__d, __m);
      }
    };



  template<>
    struct atomic<char> : __atomic_base<char>
    {
      typedef char __integral_type;
      typedef __atomic_base<char> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<signed char> : __atomic_base<signed char>
    {
      typedef signed char __integral_type;
      typedef __atomic_base<signed char> __base_type;

      atomic() noexcept= default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned char> : __atomic_base<unsigned char>
    {
      typedef unsigned char __integral_type;
      typedef __atomic_base<unsigned char> __base_type;

      atomic() noexcept= default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<short> : __atomic_base<short>
    {
      typedef short __integral_type;
      typedef __atomic_base<short> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned short> : __atomic_base<unsigned short>
    {
      typedef unsigned short __integral_type;
      typedef __atomic_base<unsigned short> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<int> : __atomic_base<int>
    {
      typedef int __integral_type;
      typedef __atomic_base<int> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned int> : __atomic_base<unsigned int>
    {
      typedef unsigned int __integral_type;
      typedef __atomic_base<unsigned int> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<long> : __atomic_base<long>
    {
      typedef long __integral_type;
      typedef __atomic_base<long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned long> : __atomic_base<unsigned long>
    {
      typedef unsigned long __integral_type;
      typedef __atomic_base<unsigned long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<long long> : __atomic_base<long long>
    {
      typedef long long __integral_type;
      typedef __atomic_base<long long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
    {
      typedef unsigned long long __integral_type;
      typedef __atomic_base<unsigned long long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<wchar_t> : __atomic_base<wchar_t>
    {
      typedef wchar_t __integral_type;
      typedef __atomic_base<wchar_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };
# 937 "/usr/include/c++/10/atomic" 3
  template<>
    struct atomic<char16_t> : __atomic_base<char16_t>
    {
      typedef char16_t __integral_type;
      typedef __atomic_base<char16_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<char32_t> : __atomic_base<char32_t>
    {
      typedef char32_t __integral_type;
      typedef __atomic_base<char32_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


    static constexpr bool is_always_lock_free = 2 == 2;

    };



  typedef atomic<bool> atomic_bool;


  typedef atomic<char> atomic_char;


  typedef atomic<signed char> atomic_schar;


  typedef atomic<unsigned char> atomic_uchar;


  typedef atomic<short> atomic_short;


  typedef atomic<unsigned short> atomic_ushort;


  typedef atomic<int> atomic_int;


  typedef atomic<unsigned int> atomic_uint;


  typedef atomic<long> atomic_long;


  typedef atomic<unsigned long> atomic_ulong;


  typedef atomic<long long> atomic_llong;


  typedef atomic<unsigned long long> atomic_ullong;


  typedef atomic<wchar_t> atomic_wchar_t;







  typedef atomic<char16_t> atomic_char16_t;


  typedef atomic<char32_t> atomic_char32_t;






  typedef atomic<int8_t> atomic_int8_t;


  typedef atomic<uint8_t> atomic_uint8_t;


  typedef atomic<int16_t> atomic_int16_t;


  typedef atomic<uint16_t> atomic_uint16_t;


  typedef atomic<int32_t> atomic_int32_t;


  typedef atomic<uint32_t> atomic_uint32_t;


  typedef atomic<int64_t> atomic_int64_t;


  typedef atomic<uint64_t> atomic_uint64_t;



  typedef atomic<int_least8_t> atomic_int_least8_t;


  typedef atomic<uint_least8_t> atomic_uint_least8_t;


  typedef atomic<int_least16_t> atomic_int_least16_t;


  typedef atomic<uint_least16_t> atomic_uint_least16_t;


  typedef atomic<int_least32_t> atomic_int_least32_t;


  typedef atomic<uint_least32_t> atomic_uint_least32_t;


  typedef atomic<int_least64_t> atomic_int_least64_t;


  typedef atomic<uint_least64_t> atomic_uint_least64_t;



  typedef atomic<int_fast8_t> atomic_int_fast8_t;


  typedef atomic<uint_fast8_t> atomic_uint_fast8_t;


  typedef atomic<int_fast16_t> atomic_int_fast16_t;


  typedef atomic<uint_fast16_t> atomic_uint_fast16_t;


  typedef atomic<int_fast32_t> atomic_int_fast32_t;


  typedef atomic<uint_fast32_t> atomic_uint_fast32_t;


  typedef atomic<int_fast64_t> atomic_int_fast64_t;


  typedef atomic<uint_fast64_t> atomic_uint_fast64_t;




  typedef atomic<intptr_t> atomic_intptr_t;


  typedef atomic<uintptr_t> atomic_uintptr_t;


  typedef atomic<size_t> atomic_size_t;


  typedef atomic<ptrdiff_t> atomic_ptrdiff_t;



  typedef atomic<intmax_t> atomic_intmax_t;


  typedef atomic<uintmax_t> atomic_uintmax_t;



  inline bool
  atomic_flag_test_and_set_explicit(atomic_flag* __a,
        memory_order __m) noexcept
  { return __a->test_and_set(__m); }

  inline bool
  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
        memory_order __m) noexcept
  { return __a->test_and_set(__m); }

  inline void
  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
  { __a->clear(__m); }

  inline void
  atomic_flag_clear_explicit(volatile atomic_flag* __a,
        memory_order __m) noexcept
  { __a->clear(__m); }

  inline bool
  atomic_flag_test_and_set(atomic_flag* __a) noexcept
  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }

  inline bool
  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }

  inline void
  atomic_flag_clear(atomic_flag* __a) noexcept
  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }

  inline void
  atomic_flag_clear(volatile atomic_flag* __a) noexcept
  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }


  template<typename _Tp>
    using __atomic_val_t = typename atomic<_Tp>::value_type;
  template<typename _Tp>
    using __atomic_diff_t = typename atomic<_Tp>::difference_type;



  template<typename _ITp>
    inline bool
    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
    { return __a->is_lock_free(); }

  template<typename _ITp>
    inline bool
    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
    { return __a->is_lock_free(); }

  template<typename _ITp>
    inline void
    atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { __a->store(__i, memory_order_relaxed); }

  template<typename _ITp>
    inline void
    atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { __a->store(__i, memory_order_relaxed); }

  template<typename _ITp>
    inline void
    atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
     memory_order __m) noexcept
    { __a->store(__i, __m); }

  template<typename _ITp>
    inline void
    atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
     memory_order __m) noexcept
    { __a->store(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
    { return __a->load(__m); }

  template<typename _ITp>
    inline _ITp
    atomic_load_explicit(const volatile atomic<_ITp>* __a,
    memory_order __m) noexcept
    { return __a->load(__m); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->exchange(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange_explicit(volatile atomic<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->exchange(__i, __m); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2,
       memory_order __m1,
       memory_order __m2) noexcept
    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2,
       memory_order __m1,
       memory_order __m2) noexcept
    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
         __atomic_val_t<_ITp>* __i1,
         __atomic_val_t<_ITp> __i2,
         memory_order __m1,
         memory_order __m2) noexcept
    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
         __atomic_val_t<_ITp>* __i1,
         __atomic_val_t<_ITp> __i2,
         memory_order __m1,
         memory_order __m2) noexcept
    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }


  template<typename _ITp>
    inline void
    atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline void
    atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_load(const atomic<_ITp>* __a) noexcept
    { return atomic_load_explicit(__a, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_load(const volatile atomic<_ITp>* __a) noexcept
    { return atomic_load_explicit(__a, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange(volatile atomic<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak(atomic<_ITp>* __a,
     __atomic_val_t<_ITp>* __i1,
     __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
         memory_order_seq_cst,
         memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
     __atomic_val_t<_ITp>* __i1,
     __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
         memory_order_seq_cst,
         memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong(atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
           memory_order_seq_cst,
           memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
           memory_order_seq_cst,
           memory_order_seq_cst);
    }





  template<typename _ITp>
    inline _ITp
    atomic_fetch_add_explicit(atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_add(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add_explicit(volatile atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_add(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub_explicit(atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_sub(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_sub(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_and(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_and(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->fetch_or(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->fetch_or(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_xor(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_xor(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add(atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add(volatile atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub(atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub(volatile atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and(__atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and(volatile __atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or(__atomic_base<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or(volatile __atomic_base<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor(__atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
# 1546 "/usr/include/c++/10/atomic" 3

}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 2 3 4


namespace boost
{

namespace detail
{

inline void atomic_increment( std::atomic_int_least32_t * pw )
{
    pw->fetch_add( 1, std::memory_order_relaxed );
}

inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw )
{
    return pw->fetch_sub( 1, std::memory_order_acq_rel );
}

inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw )
{




    std::int_least32_t r = pw->load( std::memory_order_relaxed );

    for( ;; )
    {
        if( r == 0 )
        {
            return r;
        }

        if( pw->compare_exchange_weak( r, r + 1, std::memory_order_relaxed, std::memory_order_relaxed ) )
        {
            return r;
        }
    }
}

class sp_counted_base
{
private:

    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );

    std::atomic_int_least32_t use_count_;
    std::atomic_int_least32_t weak_count_;

public:

    sp_counted_base(): 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 use_count_.load( std::memory_order_acquire );
    }
};

}

}
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 1 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
namespace boost
{
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 * )
{
    return 0;
}

template<class D> D * get_local_deleter( local_sp_deleter<D> * p );



template<class X> class sp_counted_impl_p: public sp_counted_base
{
private:

    X * px_;

    sp_counted_impl_p( sp_counted_impl_p const & );
    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );

    typedef sp_counted_impl_p<X> this_type;

public:

    explicit sp_counted_impl_p( X * px ): px_( px )
    {



    }

    virtual void dispose()
    {



        boost::checked_delete( px_ );
    }

    virtual void * get_deleter( sp_typeinfo const & )
    {
        return 0;
    }

    virtual void * get_local_deleter( sp_typeinfo const & )
    {
        return 0;
    }

    virtual void * get_untyped_deleter()
    {
        return 0;
    }
# 137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
};
# 146 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
{
private:

    P ptr;
    D del;

    sp_counted_impl_pd( sp_counted_impl_pd const & );
    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );

    typedef sp_counted_impl_pd<P, D> this_type;

public:



    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
    {
    }

    sp_counted_impl_pd( P p ): ptr( p ), del()
    {
    }

    virtual void dispose()
    {
        del( ptr );
    }

    virtual void * get_deleter( sp_typeinfo const & ti )
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
    }

    virtual void * get_local_deleter( sp_typeinfo const & ti )
    {
        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
    }

    virtual void * get_untyped_deleter()
    {
        return &reinterpret_cast<char&>( del );
    }
# 217 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
};

template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
{
private:

    P p_;
    D d_;
    A a_;

    sp_counted_impl_pda( sp_counted_impl_pda const & );
    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );

    typedef sp_counted_impl_pda<P, D, A> this_type;

public:



    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
    {
    }

    sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
    {
    }

    virtual void dispose()
    {
        d_( p_ );
    }

    virtual void destroy()
    {


        typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;







        A2 a2( a_ );

        this->~this_type();

        a2.deallocate( this, 1 );
    }

    virtual void * get_deleter( sp_typeinfo const & ti )
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
    }

    virtual void * get_local_deleter( sp_typeinfo const & ti )
    {
        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
    }

    virtual void * get_untyped_deleter()
    {
        return &reinterpret_cast<char&>( d_ );
    }
};





}

}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
{
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
struct sp_nothrow_tag {};

template< class D > struct sp_inplace_tag
{
};

template< class T > class sp_reference_wrapper
{
public:

    explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) )
    {
    }

    template< class Y > void operator()( Y * p ) const
    {
        (*t_)( p );
    }

private:

    T * t_;
};

template< class D > struct sp_convert_reference
{
    typedef D type;
};

template< class D > struct sp_convert_reference< D& >
{
    typedef sp_reference_wrapper< D > type;
};

class weak_count;

class shared_count
{
private:

    sp_counted_base * pi_;





    friend class weak_count;

public:

    constexpr shared_count(): pi_(0)



    {
    }

    constexpr explicit shared_count( sp_counted_base * pi ): 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;
        }
# 163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
        }
# 200 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
        }
# 232 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
        }
# 289 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
        }
# 346 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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() ) )



    {
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
        r.release();
    }





    template<class Y, class D>
    explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )



    {
        typedef typename sp_convert_reference<D>::type D2;

        D2 d2( r.get_deleter() );
        pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
# 396 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 );
# 421 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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): pi_(r.pi_)



    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }



    shared_count(shared_count && r): pi_(r.pi_)



    {
        r.pi_ = 0;
    }



    explicit shared_count(weak_count const & r);
    shared_count( weak_count const & r, sp_nothrow_tag );

    shared_count & operator= (shared_count const & r)
    {
        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)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool unique() const
    {
        return use_count() == 1;
    }

    bool empty() const
    {
        return pi_ == 0;
    }

    friend inline bool operator==(shared_count const & a, shared_count const & b)
    {
        return a.pi_ == b.pi_;
    }

    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
    }

    void * get_deleter( sp_typeinfo const & ti ) const
    {
        return pi_? pi_->get_deleter( ti ): 0;
    }

    void * get_local_deleter( sp_typeinfo const & ti ) const
    {
        return pi_? pi_->get_local_deleter( ti ): 0;
    }

    void * get_untyped_deleter() const
    {
        return pi_? pi_->get_untyped_deleter(): 0;
    }
};


class weak_count
{
private:

    sp_counted_base * pi_;





    friend class shared_count;

public:

    constexpr weak_count(): pi_(0)



    {
    }

    weak_count(shared_count const & r): pi_(r.pi_)



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }

    weak_count(weak_count const & r): pi_(r.pi_)



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }





    weak_count(weak_count && r): pi_(r.pi_)



    {
        r.pi_ = 0;
    }



    ~weak_count()
    {
        if(pi_ != 0) pi_->weak_release();



    }

    weak_count & operator= (shared_count const & r)
    {
        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)
    {
        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)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool empty() const
    {
        return pi_ == 0;
    }

    friend inline bool operator==(weak_count const & a, weak_count const & b)
    {
        return a.pi_ == b.pi_;
    }

    friend inline bool operator<(weak_count const & a, weak_count const & b)
    {
        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
    }
};

inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )



{
    if( pi_ == 0 || !pi_->add_ref_lock() )
    {
        boost::throw_exception( boost::bad_weak_ptr() );
    }
}

inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )



{
    if( pi_ != 0 && !pi_->add_ref_lock() )
    {
        pi_ = 0;
    }
}

}

}


#pragma GCC diagnostic pop
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_convertible.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_convertible.hpp" 3 4
namespace boost
{

namespace detail
{

template< class Y, class T > struct sp_convertible
{
    typedef char (&yes) [1];
    typedef char (&no) [2];

    static yes f( T* );
    static no f( ... );

    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
};

template< class Y, class T > struct sp_convertible< Y, T[] >
{
    enum _vt { value = false };
};

template< class Y, class T > struct sp_convertible< Y[], T[] >
{
    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};

template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
{
    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};

struct sp_empty
{
};

template< bool > struct sp_enable_if_convertible_impl;

template<> struct sp_enable_if_convertible_impl<true>
{
    typedef sp_empty type;
};

template<> struct sp_enable_if_convertible_impl<false>
{
};

template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};

}

}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 3 4
namespace boost
{

namespace detail
{







    typedef std::nullptr_t sp_nullptr_t;



}

}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_noexcept.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock_pool.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock.hpp" 1 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/yield_k.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdc.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/version_number.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdc.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/detail/test.h" 1 3 4
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdc.h" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdc.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdcpp.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdcpp.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdcpp.h" 2 3 4
# 115 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/stdcpp.h" 3 4







# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/objc.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/objc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/objc.h" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language/objc.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/language.h" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/alpha.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/alpha.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/alpha.h" 2 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/alpha.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/arm.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/arm.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/arm.h" 2 3 4
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/arm.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/blackfin.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/blackfin.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/blackfin.h" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/blackfin.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/convex.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/convex.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/convex.h" 2 3 4
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/convex.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ia64.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ia64.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ia64.h" 2 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ia64.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/m68k.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/m68k.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/m68k.h" 2 3 4
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/m68k.h" 3 4

# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/mips.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/mips.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/mips.h" 2 3 4
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/mips.h" 3 4

# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/parisc.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/parisc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/parisc.h" 2 3 4
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/parisc.h" 3 4

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ppc.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ppc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ppc.h" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/ppc.h" 3 4

# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/pyramid.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/pyramid.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/pyramid.h" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/pyramid.h" 3 4

# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/rs6k.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/rs6k.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/rs6k.h" 2 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/rs6k.h" 3 4

# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sparc.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sparc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sparc.h" 2 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sparc.h" 3 4

# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/superh.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/superh.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/superh.h" 2 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/superh.h" 3 4

# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys370.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys370.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys370.h" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys370.h" 3 4

# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys390.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys390.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys390.h" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/sys390.h" 3 4

# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 1 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 2 3 4
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 1 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 3 4

# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 1 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 3 4

# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 3 4

# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 3 4

# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 2 3 4





# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 3 4

# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/32.h" 2 3 4





# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86/64.h" 3 4

# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/x86.h" 3 4

# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/z.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/z.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/z.h" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture/z.h" 3 4

# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/architecture.h" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/borland.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/borland.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/borland.h" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/borland.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/comeau.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/comeau.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/comeau.h" 2 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/comeau.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/compaq.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/compaq.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/compaq.h" 2 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/compaq.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/diab.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/diab.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/diab.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/diab.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/digitalmars.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/digitalmars.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/digitalmars.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/digitalmars.h" 3 4

# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/dignus.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/dignus.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/dignus.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/dignus.h" 3 4

# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/edg.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/edg.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/edg.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/edg.h" 3 4

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ekopath.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ekopath.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ekopath.h" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ekopath.h" 3 4

# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc_xml.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc_xml.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc_xml.h" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc_xml.h" 3 4

# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc.h" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc.h" 2 3 4
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/detail/comp_detected.h" 1 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/gcc.h" 2 3 4








# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/greenhills.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/greenhills.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/greenhills.h" 2 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/greenhills.h" 3 4

# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/hp_acc.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/hp_acc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/hp_acc.h" 2 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/hp_acc.h" 3 4

# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/iar.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/iar.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/iar.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/iar.h" 3 4

# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ibm.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ibm.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ibm.h" 2 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/ibm.h" 3 4

# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/intel.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/intel.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/intel.h" 2 3 4
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/intel.h" 3 4

# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/kai.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/kai.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/kai.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/kai.h" 3 4

# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/llvm.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/llvm.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/llvm.h" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/llvm.h" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/llvm.h" 3 4

# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metaware.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metaware.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metaware.h" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metaware.h" 3 4

# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metrowerks.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metrowerks.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metrowerks.h" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/metrowerks.h" 3 4

# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/microtec.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/microtec.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/microtec.h" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/microtec.h" 3 4

# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/mpw.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/mpw.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/mpw.h" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/mpw.h" 3 4

# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/palm.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/palm.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/palm.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/palm.h" 3 4

# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/pgi.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/pgi.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/pgi.h" 2 3 4
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/pgi.h" 3 4

# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sgi_mipspro.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sgi_mipspro.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sgi_mipspro.h" 2 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sgi_mipspro.h" 3 4

# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sunpro.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sunpro.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sunpro.h" 2 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/sunpro.h" 3 4

# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/tendra.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/tendra.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/tendra.h" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/tendra.h" 3 4

# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/visualc.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/visualc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/clang.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/visualc.h" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/visualc.h" 2 3 4
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/visualc.h" 3 4

# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/watcom.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/watcom.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/watcom.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler/watcom.h" 3 4

# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/compiler.h" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/_prefix.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/_prefix.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/detail/_cassert.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/detail/_cassert.h" 3 4
# 1 "/usr/include/c++/10/cassert" 1 3 4
# 41 "/usr/include/c++/10/cassert" 3 4
       
# 42 "/usr/include/c++/10/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 45 "/usr/include/c++/10/cassert" 2 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/detail/_cassert.h" 2 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/_prefix.h" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/cloudabi.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/cloudabi.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/cloudabi.h" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/cloudabi.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 2 3 4




# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 2 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/uc.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/uc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/uc.h" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/uc.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/vms.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/vms.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/vms.h" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/vms.h" 3 4

# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/zos.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/zos.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/zos.h" 2 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/zos.h" 3 4

# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c.h" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/_prefix.h" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/_prefix.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/detail/_exception.h" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/_prefix.h" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/cxx.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/cxx.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/cxx.h" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/cxx.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/dinkumware.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/dinkumware.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/dinkumware.h" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/dinkumware.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/libcomo.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/libcomo.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/libcomo.h" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/libcomo.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/modena.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/modena.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/modena.h" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/modena.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/msl.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/msl.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/msl.h" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/msl.h" 3 4

# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/roguewave.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/roguewave.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/roguewave.h" 2 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/roguewave.h" 3 4

# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/sgi.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/sgi.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/sgi.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/sgi.h" 3 4

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stdcpp3.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stdcpp3.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stdcpp3.h" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stdcpp3.h" 3 4

# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stlport.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stlport.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stlport.h" 2 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/stlport.h" 3 4

# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/vacpp.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/vacpp.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/vacpp.h" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std/vacpp.h" 3 4

# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/std.h" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library.h" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/aix.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/aix.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/aix.h" 2 3 4
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/aix.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/amigaos.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/amigaos.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/amigaos.h" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/amigaos.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/android.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/android.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/android.h" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/android.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/beos.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/beos.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/beos.h" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/beos.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 2 3 4
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 1 3 4
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4

# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 1 3 4
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4

# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4

# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 1 3 4
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4

# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4

# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4

# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 1 3 4
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4

# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4

# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4

# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 1 3 4
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4

# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4

# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4

# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 1 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4

# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4





# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 2 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4

# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4





# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 2 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 1 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4

# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4





# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 2 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4

# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 1 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4

# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4





# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4

# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4

# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 1 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4

# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4





# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4

# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4

# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4

# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 1 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4

# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4

# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/cygwin.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/cygwin.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/cygwin.h" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/cygwin.h" 3 4

# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/haiku.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/haiku.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/haiku.h" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/haiku.h" 3 4

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/hpux.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/hpux.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/hpux.h" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/hpux.h" 3 4

# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/irix.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/irix.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/irix.h" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/irix.h" 3 4

# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 3 4

# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/linux.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/linux.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/linux.h" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/linux.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/detail/os_detected.h" 1 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/linux.h" 2 3 4








# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 1 3 4
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 3 4

# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/os400.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/os400.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/os400.h" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/os400.h" 3 4

# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/qnxnto.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/qnxnto.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/qnxnto.h" 2 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/qnxnto.h" 3 4

# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/solaris.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/solaris.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/solaris.h" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/solaris.h" 3 4

# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/unix.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/unix.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/unix.h" 2 3 4
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/unix.h" 3 4


# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/vms.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/vms.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/vms.h" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/vms.h" 3 4

# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os.h" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 1 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 1 3 4
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/macos.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 1 3 4
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/bsdi.h" 3 4

# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/dragonfly.h" 3 4

# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/free.h" 3 4

# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 1 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/net.h" 3 4

# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd.h" 2 3 4





# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/android.h" 1 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/android.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 2 3 4
# 195 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other/endian.h" 3 4










# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/other.h" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/cloudabi.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/cloudabi.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/cloudabi.h" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/cloudabi.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw.h" 2 3 4
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw32.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw32.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw32.h" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw32.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw64.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw64.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw64.h" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/mingw64.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 2 3 4
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 3 4

# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_desktop.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_desktop.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_desktop.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_desktop.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_desktop.h" 2 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_desktop.h" 3 4

# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 3 4

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_server.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_server.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_server.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_server.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_server.h" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_server.h" 3 4

# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 3 4

# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_system.h" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_system.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_system.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_system.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_uwp.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_system.h" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_system.h" 3 4

# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_runtime.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_runtime.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/make.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_phone.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_store.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/windows_runtime.h" 3 4

# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/ios.h" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/ios.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/ios.h" 3 4

# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/ios.h" 2 3 4
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform/ios.h" 3 4


# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd.h" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86/versions.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86.h" 2 3 4
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86.h" 3 4

# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86_amd.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86_amd.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86_amd/versions.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86_amd.h" 2 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/x86_amd.h" 3 4

# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/arm.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/arm.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/arm/versions.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/arm.h" 2 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/arm.h" 3 4

# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd.h" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/ppc.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/ppc.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/ppc/versions.h" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/ppc.h" 2 3 4
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd/ppc.h" 3 4

# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd.h" 2 3 4
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware/simd.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/hardware.h" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/version.h" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/yield_k.hpp" 2 3 4
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
namespace boost
{

namespace detail
{

inline void yield( unsigned k )
{
    if( k < 4 )
    {
    }

    else if( k < 16 )
    {
        __asm__ __volatile__( "rep; nop" : : : "memory" );
    }

    else if( k < 32 || k & 1 )
    {
        sched_yield();
    }
    else
    {

        struct timespec rqtp = { 0, 0 };




        rqtp.tv_sec = 0;
        rqtp.tv_nsec = 1000;

        nanosleep( &rqtp, 0 );
    }
}

}

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 2 3 4


namespace boost
{

namespace detail
{

class spinlock
{
public:

    std::atomic_flag v_;

public:

    bool try_lock()
    {
        return !v_.test_and_set( std::memory_order_acquire );
    }

    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }

    void unlock()
    {
        v_ .clear( std::memory_order_release );
    }

public:

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

}
}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4


namespace boost
{

namespace detail
{

template< int M > class spinlock_pool
{
private:

    static spinlock pool_[ 41 ];

public:

    static spinlock & spinlock_for( void const * pv )
    {



        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;

        return pool_[ i ];
    }

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
        {
            sp_.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] =
{
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
    { { 0 } }
};

}
}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


namespace boost
{

template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
class enable_shared_from_raw;

namespace movelib
{

    template< class T, class D > class unique_ptr;

}

namespace detail
{



template< class T > struct sp_element
{
    typedef T type;
};



template< class T > struct sp_element< T[] >
{
    typedef T type;
};



template< class T, std::size_t N > struct sp_element< T[N] >
{
    typedef T type;
};







template< class T > struct sp_dereference
{
    typedef T & type;
};

template<> struct sp_dereference< void >
{
    typedef void type;
};



template<> struct sp_dereference< void const >
{
    typedef void type;
};

template<> struct sp_dereference< void volatile >
{
    typedef void type;
};

template<> struct sp_dereference< void const volatile >
{
    typedef void type;
};





template< class T > struct sp_dereference< T[] >
{
    typedef void type;
};



template< class T, std::size_t N > struct sp_dereference< T[N] >
{
    typedef void type;
};







template< class T > struct sp_member_access
{
    typedef T * type;
};



template< class T > struct sp_member_access< T[] >
{
    typedef void type;
};



template< class T, std::size_t N > struct sp_member_access< T[N] >
{
    typedef void type;
};







template< class T > struct sp_array_access
{
    typedef void type;
};



template< class T > struct sp_array_access< T[] >
{
    typedef T & type;
};



template< class T, std::size_t N > struct sp_array_access< T[N] >
{
    typedef T & type;
};







template< class T > struct sp_extent
{
    enum _vt { value = 0 };
};



template< class T, std::size_t N > struct sp_extent< T[N] >
{
    enum _vt { value = N };
};





template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
# 242 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
inline void sp_enable_shared_from_this( ... )
{
}







template< class T, class R > struct sp_enable_if_auto_ptr
{
};

template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
    typedef R type;
};





template< class Y, class T > inline void sp_assert_convertible() noexcept
{



    typedef char tmp[ sp_convertible< Y, T >::value? 1: -1 ];
    (void)sizeof( tmp );







}



template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
{
    boost::detail::shared_count( p ).swap( pn );
    boost::detail::sp_enable_shared_from_this( ppx, p, p );
}



template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
{
    sp_assert_convertible< Y[], T[] >();
    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
}

template< class T, std::size_t N, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
{
    sp_assert_convertible< Y[N], T[N] >();
    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
}





template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
{
    boost::detail::sp_enable_shared_from_this( ppx, p, p );
}



template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
{
    sp_assert_convertible< Y[], T[] >();
}

template< class T, std::size_t N, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
{
    sp_assert_convertible< Y[N], T[N] >();
}



struct sp_internal_constructor_tag
{
};

}
# 341 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class T> class shared_ptr
{
private:


    typedef shared_ptr<T> this_type;

public:

    typedef typename boost::detail::sp_element< T >::type element_type;

    constexpr shared_ptr() noexcept : px( 0 ), pn()
    {
    }



    constexpr shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
    {
    }



    constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count const & pn_ ) noexcept : px( px_ ), pn( pn_ )
    {
    }



    constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count && pn_ ) noexcept : px( px_ ), pn( std::move( pn_ ) )
    {
    }



    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn()
    {
        boost::detail::sp_pointer_construct( this, p, pn );
    }







    template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
    {
        boost::detail::sp_deleter_construct( this, p );
    }



    template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
    {
    }





    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
    {
        boost::detail::sp_deleter_construct( this, p );
    }



    template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
    {
    }
# 422 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
    {
    }



    template<class Y>
    explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
    {
        boost::detail::sp_assert_convertible< Y, T >();


        px = r.px;
    }

    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
    noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
    {
        if( !pn.empty() )
        {
            px = r.px;
        }
    }

    template<class Y>


    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    noexcept : px( r.px ), pn( r.pn )
    {
        boost::detail::sp_assert_convertible< Y, T >();
    }


    template< class Y >
    shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
    {
    }



    template<class Y>
    explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        Y * tmp = r.get();
        pn = boost::detail::shared_count( r );

        boost::detail::sp_deleter_construct( this, tmp );
    }



    template<class Y>
    shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        Y * tmp = r.get();
        pn = boost::detail::shared_count( r );

        boost::detail::sp_deleter_construct( this, tmp );
    }
# 515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template< class Y, class D >
    shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        typename std::unique_ptr< Y, D >::pointer tmp = r.get();

        if( tmp != 0 )
        {
            pn = boost::detail::shared_count( r );
            boost::detail::sp_deleter_construct( this, tmp );
        }
    }



    template< class Y, class D >
    shared_ptr( boost::movelib::unique_ptr< Y, D > r ): px( r.get() ), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        typename boost::movelib::unique_ptr< Y, D >::pointer tmp = r.get();

        if( tmp != 0 )
        {
            pn = boost::detail::shared_count( r );
            boost::detail::sp_deleter_construct( this, tmp );
        }
    }



    shared_ptr & operator=( shared_ptr const & r ) noexcept
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
    {
        this_type(r).swap(*this);
        return *this;
    }





    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r )
    {
        this_type( r ).swap( *this );
        return *this;
    }



    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> && r )
    {
        this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }
# 597 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y, class D>
    shared_ptr & operator=( std::unique_ptr<Y, D> && r )
    {
        this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
        return *this;
    }



    template<class Y, class D>
    shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r )
    {


        boost::detail::sp_assert_convertible< Y, T >();

        typename boost::movelib::unique_ptr< Y, D >::pointer p = r.get();

        shared_ptr tmp;

        if( p != 0 )
        {
            tmp.px = p;
            tmp.pn = boost::detail::shared_count( r );

            boost::detail::sp_deleter_construct( &tmp, p );
        }

        tmp.swap( *this );

        return *this;
    }





    shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn()
    {
        pn.swap( r.pn );
        r.px = 0;
    }

    template<class Y>


    shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    noexcept : px( r.px ), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        pn.swap( r.pn );
        r.px = 0;
    }

    shared_ptr & operator=( shared_ptr && r ) noexcept
    {
        this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
        return *this;
    }

    template<class Y>
    shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
    {
        this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }


    template<class Y>
    shared_ptr( shared_ptr<Y> && r, element_type * p ) noexcept : px( p ), pn()
    {
        pn.swap( r.pn );
        r.px = 0;
    }





    shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
    {
        this_type().swap(*this);
        return *this;
    }



    void reset() noexcept
    {
        this_type().swap(*this);
    }

    template<class Y> void reset( Y * p )
    {
        (static_cast<void> (0));
        this_type( p ).swap( *this );
    }

    template<class Y, class D> void reset( Y * p, D d )
    {
        this_type( p, d ).swap( *this );
    }

    template<class Y, class D, class A> void reset( Y * p, D d, A a )
    {
        this_type( p, d, a ).swap( *this );
    }

    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) noexcept
    {
        this_type( r, p ).swap( *this );
    }



    template<class Y> void reset( shared_ptr<Y> && r, element_type * p ) noexcept
    {
        this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
    }



    typename boost::detail::sp_dereference< T >::type operator* () const noexcept
    {
        (static_cast<void> (0));
        return *px;
    }

    typename boost::detail::sp_member_access< T >::type operator-> () const noexcept
    {
        (static_cast<void> (0));
        return px;
    }

    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const noexcept
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
    }

    element_type * get() const noexcept
    {
        return px;
    }


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    explicit operator bool () const noexcept
    {
        return px != 0;
    }
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    bool operator! () const noexcept
    {
        return px == 0;
    }
# 753 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

    bool unique() const noexcept
    {
        return pn.unique();
    }

    long use_count() const noexcept
    {
        return pn.use_count();
    }

    void swap( shared_ptr & other ) noexcept
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const noexcept
    {
        return pn.get_deleter( ti );
    }

    void * _internal_get_local_deleter( boost::detail::sp_typeinfo const & ti ) const noexcept
    {
        return pn.get_local_deleter( ti );
    }

    void * _internal_get_untyped_deleter() const noexcept
    {
        return pn.get_untyped_deleter();
    }

    bool _internal_equiv( shared_ptr const & r ) const noexcept
    {
        return px == r.px && pn == r.pn;
    }

    boost::detail::shared_count _internal_count() const noexcept
    {
        return pn;
    }






private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;




    element_type * px;
    boost::detail::shared_count pn;

};

template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.get() != b.get();
}
# 846 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
    return p.get() == 0;
}

template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
    return p.get() == 0;
}

template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
    return p.get() != 0;
}

template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
    return p.get() != 0;
}



template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.owner_before( b );
}

template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept
{
    a.swap(b);
}

template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) static_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = static_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}

template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) const_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = const_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = dynamic_cast< E* >( r.get() );
    return p? shared_ptr<T>( r, p ): shared_ptr<T>();
}

template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = reinterpret_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}



template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) static_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = static_cast< E* >( r.get() );
    return shared_ptr<T>( std::move(r), p );
}

template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) const_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = const_cast< E* >( r.get() );
    return shared_ptr<T>( std::move(r), p );
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = dynamic_cast< E* >( r.get() );
    return p? shared_ptr<T>( std::move(r), p ): shared_ptr<T>();
}

template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = reinterpret_cast< E* >( r.get() );
    return shared_ptr<T>( std::move(r), p );
}





template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
{
    return p.get();
}
# 991 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)

{
    os << p.get();
    return os;
}
# 1006 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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()
    {
    }

    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<void> (0));
        deleter_.reset();
    }
};

}

template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
{
    D * d = boost::detail::basic_get_deleter<D>( p );

    if( d == 0 )
    {
        d = boost::detail::basic_get_local_deleter( d, p );
    }

    if( d == 0 )
    {
        boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);


        if(del_wrapper) d = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
    }

    return d;
}





template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
{
    return false;
}

template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p ) noexcept
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
}

template<class T, class M> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, M ) noexcept
{
    return atomic_load( p );
}

template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
}

template<class T, class M> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
{
    atomic_store( p, r );
}

template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();
    p->swap( r );
    sp.unlock();

    return r;
}

template<class T, class M> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
{
    return atomic_exchange( p, r );
}

template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w ) noexcept
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();

    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );

        sp.unlock();

        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );

        sp.unlock();

        tmp.swap( *v );
        return false;
    }
}

template<class T, class M> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, M, M ) noexcept
{
    return atomic_compare_exchange( p, v, w );
}





template< class T > struct hash;

template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
{
    return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
}

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/local_counted_base.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/local_counted_base.hpp" 3 4
namespace boost
{

namespace detail
{

class local_counted_base
{
private:

    local_counted_base & operator= ( local_counted_base const & );

private:


    enum count_type { min_ = 0, initial_ = 1, max_ = 2147483647 };

    count_type local_use_count_;

public:

    constexpr local_counted_base() noexcept: local_use_count_( initial_ )
    {
    }

    constexpr local_counted_base( local_counted_base const & ) noexcept: local_use_count_( initial_ )
    {
    }

    virtual ~local_counted_base()
    {
    }

    virtual void local_cb_destroy() noexcept = 0;

    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept = 0;

    void add_ref() noexcept
    {
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/local_counted_base.hpp" 3 4
        local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
    }

    void release() noexcept
    {
        local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );

        if( local_use_count_ == 0 )
        {
            local_cb_destroy();
        }
    }

    long local_use_count() const noexcept
    {
        return local_use_count_;
    }
};

class 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 ): pn_( pn )
    {
    }



    explicit local_counted_impl( shared_count && pn ): pn_( std::move(pn) )
    {
    }



    virtual void local_cb_destroy() noexcept
    {
        delete this;
    }

    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept
    {
        return pn_;
    }
};

class local_counted_impl_em: public local_counted_base
{
public:

    shared_count pn_;

    virtual void local_cb_destroy() noexcept
    {
        shared_count().swap( pn_ );
    }

    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept
    {
        return pn_;
    }
};

}

}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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()
    {
        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 )
{
    return &p->deleter();
}

inline void * get_local_deleter( local_sp_deleter<void> * )
{
    return 0;
}

}

}
# 1159 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

namespace boost
{

namespace detail
{

template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
}

template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
}

}

}


#pragma GCC diagnostic pop
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/shared_ptr.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/has_member_function.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/has_member_function.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/property_tags.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/property_tags.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bitxor.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bitxor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/integral_c.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/integral_c_fwd.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/integral_c.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/largest_int.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/numeric_cast.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/tag.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/tag.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/has_tag.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/has_tag.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/tag.hpp" 2 3 4


namespace boost { namespace mpl {

namespace aux {
template< typename T > struct tag_impl
{
    typedef typename T::tag type;
};
}

template< typename T, typename Default = void_ > struct tag

    : if_<
          aux::has_tag<T>
        , aux::tag_impl<T>
        , Default
        >::type
{
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/tag.hpp" 3 4
};

}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/forwarding.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
    };
};

}}}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/msvc_eti_base.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
}}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/msvc_eti_base.hpp" 2 3 4




namespace boost { namespace mpl { namespace aux {
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
template< typename T > struct msvc_eti_base
    : T
{

    msvc_eti_base();

    typedef T type;
};



template<> struct msvc_eti_base<int>
{
    typedef msvc_eti_base type;
    typedef msvc_eti_base first;
    typedef msvc_eti_base second;
    typedef msvc_eti_base tag;
    enum { value = 0 };
};

}}}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/partial_spec_params.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/partial_spec_params.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/sub.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/partial_spec_params.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/repeat.hpp" 1 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/ext_params.hpp" 1 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/preprocessor/add.hpp" 1 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/dec.hpp" 1 3 4
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    >
struct bitxor_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< bitxor_impl<Tag1,Tag1>,Tag1,Tag2 >
        , aux::cast1st_impl< bitxor_impl<Tag2,Tag2>,Tag1,Tag2 >
        >::type
{
};


template<> struct bitxor_impl<na,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};


template< typename Tag > struct bitxor_impl<na,Tag>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct bitxor_impl<Tag,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template< typename T > struct bitxor_tag
{
    typedef typename T::tag type;
};
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 = na
    , typename N2 = na
    , typename N3 =na , typename N4 =na , typename N5 =na
    >
struct bitxor_
    : bitxor_< bitxor_< bitxor_< bitxor_< N1 , N2> , N3> , N4> , N5>
{
   




};



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 1 3 4
# 1274 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3 , typename N4
    >
struct bitxor_< N1 , N2 , N3 , N4 , na>

    : bitxor_< bitxor_< bitxor_< N1 , N2> , N3> , N4>
{
   




};
# 1275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3
    >
struct bitxor_< N1 , N2 , N3 , na , na>

    : bitxor_< bitxor_< N1 , N2> , N3>
{
   




};
# 1280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2
    >
struct bitxor_< N1 , N2 , na , na , na>
# 1285 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    : bitxor_impl<
          typename bitxor_tag<N1>::type
        , typename bitxor_tag<N2>::type
        >::template apply<N1,N2>::type
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
{



   
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
};

template<> struct bitxor_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : bitxor_< T1 , T2 > { }; }; template< typename Tag > struct lambda< bitxor_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef bitxor_< na , na > result_; typedef bitxor_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bitxor_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< bitxor_< na , na > > : int_<-1> { }; }

}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
namespace boost { namespace mpl {
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
template<>
struct bitxor_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
                )
            >
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
    {
    };
};

}}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bitxor.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/property_tags.hpp" 2 3 4


namespace boost { namespace function_types {

namespace detail
{
  typedef long bits_t;

  template<bits_t Value> struct constant
    : boost::integral_constant<bits_t,Value>
  { };

  template<bits_t Bits, bits_t Mask> struct property_tag
  {
    typedef constant<Bits> bits;
    typedef constant<Mask> mask;
  };

  template<typename T> struct bits : T::bits { };
  template<typename T> struct mask : T::mask { };


  template<bits_t Bits, bits_t CCID> struct encode_bits_impl;


  template<bits_t LHS_bits, bits_t LHS_mask,
           bits_t RHS_bits, bits_t RHS_mask>
  struct tag_ice;


  template<class Tag, class RegTag = Tag> struct retag_default_cc;

  template<bits_t Bits, bits_t CCID> struct encode_bits
    : constant<
        ::boost::function_types::detail::encode_bits_impl<Bits,CCID>::value
      >
  { };

  template<class LHS, class RHS> struct compound_tag
  {
    typedef constant<
      ::boost::function_types::detail::tag_ice
        < ::boost::function_types::detail::bits<LHS>::value
        , ::boost::function_types::detail::mask<LHS>::value
        , ::boost::function_types::detail::bits<RHS>::value
        , ::boost::function_types::detail::mask<RHS>::value
        >::combined_bits
    > bits;

    typedef constant<
      ::boost::function_types::detail::tag_ice
        < ::boost::function_types::detail::bits<LHS>::value
        , ::boost::function_types::detail::mask<LHS>::value
        , ::boost::function_types::detail::bits<RHS>::value
        , ::boost::function_types::detail::mask<RHS>::value
        >::combined_mask
    > mask;
  };

  template <class Base, class PropOld, class PropNew>
  struct changed_tag
    : Base
  {
    typedef mpl::bitxor_
        <typename Base::bits, typename PropOld::bits, typename PropNew::bits>
    bits;
  };

  template<class Tag, class QueryTag> struct represents_impl
    : boost::integral_constant<bool,
        ::boost::function_types::detail::tag_ice
          < ::boost::function_types::detail::bits<Tag>::value
          , ::boost::function_types::detail::mask<Tag>::value
          , ::boost::function_types::detail::bits<QueryTag>::value
          , ::boost::function_types::detail::mask<QueryTag>::value
          >::match
      >
  { };

}

typedef detail::property_tag<0,0> null_tag;

template<class Tag1, class Tag2, class Tag3 = null_tag, class Tag4 = null_tag>
struct tag
  : detail::compound_tag< detail::compound_tag<Tag1,Tag2>,
        detail::compound_tag<Tag3,Tag4> >
{ };

template<class Tag1, class Tag2, class Tag3> struct tag<Tag1,Tag2,Tag3,null_tag>
  : detail::compound_tag<detail::compound_tag<Tag1,Tag2>,Tag3>
{ };
template<class Tag1, class Tag2> struct tag<Tag1,Tag2,null_tag,null_tag>
  : detail::compound_tag<Tag1,Tag2>
{ };
template<class Tag1> struct tag<Tag1,null_tag,null_tag,null_tag>
  : Tag1
{ };


template<class Tag, class QueryTag> struct represents
  : detail::represents_impl<Tag, detail::retag_default_cc<QueryTag,Tag> >
{ };


template<class Tag, class QueryTag> struct extract
{
  typedef detail::constant<
    ::boost::function_types::detail::tag_ice
      < ::boost::function_types::detail::bits<Tag>::value
      , ::boost::function_types::detail::mask<Tag>::value
      , ::boost::function_types::detail::bits<QueryTag>::value
      , ::boost::function_types::detail::mask<QueryTag>::value
      >::extracted_bits
  > bits;

  typedef detail::constant<
    ::boost::function_types::detail::mask<QueryTag>::value
  > mask;
};

} }

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_tags/preprocessed.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_tags/preprocessed.hpp" 3 4
namespace boost { namespace function_types {
typedef detail::property_tag<0x00000200,0x00000300> non_variadic;
typedef detail::property_tag<0x00000100,0x00000300> variadic;
typedef detail::property_tag<0,0x00000400> non_const;
typedef detail::property_tag<0x00000400,0x00000400> const_qualified;
typedef detail::property_tag<0,0x00000800> non_volatile;
typedef detail::property_tag<0x00000800,0x00000800> volatile_qualified;
typedef detail::property_tag<0x00008000,0x00ff8000> default_cc;
typedef detail::property_tag<0 , 3072> non_cv;
typedef detail::property_tag<0x00000400 , 3072> const_non_volatile;
typedef detail::property_tag<0x00000800, 3072> volatile_non_const;
typedef detail::property_tag<3072 , 3072> cv_qualified;
namespace detail {
typedef constant<0x00ff0fff> full_mask;
template <bits_t Flags, bits_t CCID> struct encode_bits_impl
{
static const bits_t value = Flags | (0x00008000 * CCID) << 1
                                  ;
};
template <bits_t Flags, bits_t CCID, std::size_t Arity>
struct encode_charr_impl
{
static const std::size_t value = (std::size_t)(1+ Flags | (0x00008000 * CCID) << 1 | Arity << 24 )

  ;
};
template <bits_t Bits> struct decode_bits
{
static const bits_t flags = Bits & 0x00000fff;
static const bits_t cc_id = ( (Bits & 0x00ff0fff) / 0x00008000) >> 1

 ;
static const bits_t tag_bits = (Bits & 0x00ff0fff);
static const std::size_t arity = (std::size_t) (Bits >> 24)

 ;
};
template <bits_t LHS_bits, bits_t LHS_mask, bits_t RHS_bits, bits_t RHS_mask>
struct tag_ice
{
static const bool match = RHS_bits == (LHS_bits & RHS_mask & (RHS_bits | ~0x000000ff))

 ;
static const bits_t combined_bits = (LHS_bits & ~RHS_mask) | RHS_bits

 ;
static const bits_t combined_mask = LHS_mask | RHS_mask

 ;
static const bits_t extracted_bits = LHS_bits & RHS_mask

 ;
};
typedef property_tag<0x00000001,0x000000ff> callable_builtin_tag;
typedef property_tag<0x00000003,0x000000ff> nonmember_callable_builtin_tag;
typedef property_tag<0x00000007,0x000000ff> function_tag;
typedef property_tag<0x00000013,0x000000ff> reference_tag;
typedef property_tag<0x0000000b,0x000000ff> pointer_tag;
typedef property_tag<0x00000061,0x000000ff> member_function_pointer_tag;
typedef property_tag<0x000000a3,0x000000ff> member_object_pointer_tag;
typedef property_tag<0x000002a3,0x00ff0fff> member_object_pointer_base;
typedef property_tag<0x00000020,0x000000ff> member_pointer_tag;
typedef property_tag< 33287 , 16745471 > nv_dcc_func;
typedef property_tag< 33377 , 16745471 > nv_dcc_mfp;
}
} }
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/property_tags.hpp" 2 3 4

namespace boost { namespace function_types {

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/def.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/aliases_def.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 1 3 4
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_tags/cc_tag.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_tags/cc_tag.hpp" 3 4
  struct implicit_cc
  {
    typedef detail::encode_bits<0,1> bits;
    typedef detail::constant<0x00ff8000> mask;
  };
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 2 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/aliases_undef.hpp" 1 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/undef.hpp" 1 3 4
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 144 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/property_tags.hpp" 2 3 4
} }
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/has_member_function.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/limits/vector.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector30.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector30.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector20.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector20.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector10.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector10.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/at.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/at.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/at_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/at.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/tag.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/tag.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/typeof.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/tag.hpp" 2 3 4


namespace boost { namespace mpl { namespace aux {

struct v_iter_tag;


struct vector_tag;




}}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/at.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/long.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/long.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/long_fwd.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/long_fwd.hpp" 3 4
namespace mpl_ {

template< long N > struct long_;

}
namespace boost { namespace mpl { using ::mpl_::long_; } }
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/long.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/long.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/at.hpp" 2 3 4







namespace boost { namespace mpl {



template< typename Vector, long n_ >
struct v_at_impl
{
    typedef long_< (Vector::lower_bound_::value + n_) > index_;
    typedef __typeof__( Vector::item_(index_()) ) type;
};


template< typename Vector, long n_ >
struct v_at
    : aux::wrapped_type< typename v_at_impl<Vector,n_>::type >
{
};

template<>
struct at_impl< aux::vector_tag >
{
    template< typename Vector, typename N > struct apply
        : v_at<
              Vector
            , N::value
            >
    {
    };
};
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/at.hpp" 3 4
}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/front.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/front.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct front_impl;
template< typename Sequence > struct front;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/front.hpp" 2 3 4






namespace boost { namespace mpl {



template<>
struct front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<Vector,0>
    {
    };
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/front.hpp" 3 4
}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/push_front.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/push_front.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_front_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_front_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct push_front_impl;
template< typename Sequence, typename T > struct push_front;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/push_front.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/item.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/item.hpp" 3 4
namespace boost { namespace mpl {



template<
      typename T
    , typename Base
    , int at_front = 0
    >
struct v_item
    : Base
{
    typedef typename Base::upper_bound_ index_;
    typedef typename next<index_>::type upper_bound_;
    typedef typename next<typename Base::size>::type size;
    typedef Base base;
    typedef v_item type;



    static aux::type_wrapper<T> item_(index_);
    using Base::item_;
};

template<
      typename T
    , typename Base
    >
struct v_item<T,Base,1>
    : Base
{
    typedef typename prior<typename Base::lower_bound_>::type index_;
    typedef index_ lower_bound_;
    typedef typename next<typename Base::size>::type size;
    typedef Base base;
    typedef v_item type;

    static aux::type_wrapper<T> item_(index_);
    using Base::item_;
};


template<
      typename Base
    , int at_front
    >
struct v_mask
    : Base
{
    typedef typename prior<typename Base::upper_bound_>::type index_;
    typedef index_ upper_bound_;
    typedef typename prior<typename Base::size>::type size;
    typedef Base base;
    typedef v_mask type;

    static aux::type_wrapper<void_> item_(index_);
    using Base::item_;
};

template<
      typename Base
    >
struct v_mask<Base,1>
    : Base
{
    typedef typename Base::lower_bound_ index_;
    typedef typename next<index_>::type lower_bound_;
    typedef typename prior<typename Base::size>::type size;
    typedef Base base;
    typedef v_mask type;

    static aux::type_wrapper<void_> item_(index_);
    using Base::item_;
};



}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/push_front.hpp" 2 3 4


namespace boost { namespace mpl {

template<>
struct push_front_impl< aux::vector_tag >
{
    template< typename Vector, typename T > struct apply
    {
        typedef v_item<T,Vector,1> type;
    };
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/pop_front.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/pop_front.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pop_front_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pop_front_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct pop_front_impl;
template< typename Sequence > struct pop_front;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/pop_front.hpp" 2 3 4







namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,1> type;
    };
};

}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/push_back.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/push_back.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_back_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_back_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct push_back_impl;
template< typename Sequence, typename T > struct push_back;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/push_back.hpp" 2 3 4







namespace boost { namespace mpl {

template<>
struct push_back_impl< aux::vector_tag >
{
    template< typename Vector, typename T > struct apply
    {
        typedef v_item<T,Vector,0> type;
    };
};

}}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/pop_back.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/pop_back.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pop_back_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pop_back_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct pop_back_impl;
template< typename Sequence > struct pop_back;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/pop_back.hpp" 2 3 4







namespace boost { namespace mpl {

template<>
struct pop_back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,0> type;
    };
};

}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/back.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/back.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/back_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/back_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct back_impl;
template< typename Sequence > struct back;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/back.hpp" 2 3 4






namespace boost { namespace mpl {



template<>
struct back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<
              Vector
            , prior<typename Vector::size>::type::value
            >
    {
    };
};
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/back.hpp" 3 4
}}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/clear.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/clear.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/clear_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/clear_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct clear_impl;
template< typename Sequence > struct clear;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/clear.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/vector0.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/vector0.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iterator_tags.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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; };

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/plus.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/plus.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    >
struct plus_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< plus_impl<Tag1,Tag1>,Tag1,Tag2 >
        , aux::cast1st_impl< plus_impl<Tag2,Tag2>,Tag1,Tag2 >
        >::type
{
};


template<> struct plus_impl<na,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};


template< typename Tag > struct plus_impl<na,Tag>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct plus_impl<Tag,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template< typename T > struct plus_tag
{
    typedef typename T::tag type;
};
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 = na
    , typename N2 = na
    , typename N3 =na , typename N4 =na , typename N5 =na
    >
struct plus
    : plus< plus< plus< plus< N1 , N2> , N3> , N4> , N5>
{
   




};



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 1 3 4
# 1274 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3 , typename N4
    >
struct plus< N1 , N2 , N3 , N4 , na>

    : plus< plus< plus< N1 , N2> , N3> , N4>
{
   




};
# 1275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3
    >
struct plus< N1 , N2 , N3 , na , na>

    : plus< plus< N1 , N2> , N3>
{
   




};
# 1280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2
    >
struct plus< N1 , N2 , na , na , na>
# 1285 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    : plus_impl<
          typename plus_tag<N1>::type
        , typename plus_tag<N2>::type
        >::template apply<N1,N2>::type
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
{



   
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
};

template<> struct plus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : plus< T1 , T2 > { }; }; template< typename Tag > struct lambda< plus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef plus< na , na > result_; typedef plus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< plus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< plus< na , na > > : int_<-1> { }; }

}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
namespace boost { namespace mpl {
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
template<>
struct plus_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
                )
            >
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
    {
    };
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/plus.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/minus.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/minus.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    >
struct minus_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< minus_impl<Tag1,Tag1>,Tag1,Tag2 >
        , aux::cast1st_impl< minus_impl<Tag2,Tag2>,Tag1,Tag2 >
        >::type
{
};


template<> struct minus_impl<na,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};


template< typename Tag > struct minus_impl<na,Tag>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct minus_impl<Tag,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template< typename T > struct minus_tag
{
    typedef typename T::tag type;
};
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 = na
    , typename N2 = na
    , typename N3 =na , typename N4 =na , typename N5 =na
    >
struct minus
    : minus< minus< minus< minus< N1 , N2> , N3> , N4> , N5>
{
   




};



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 1 3 4
# 1274 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3 , typename N4
    >
struct minus< N1 , N2 , N3 , N4 , na>

    : minus< minus< minus< N1 , N2> , N3> , N4>
{
   




};
# 1275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3
    >
struct minus< N1 , N2 , N3 , na , na>

    : minus< minus< N1 , N2> , N3>
{
   




};
# 1280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2
    >
struct minus< N1 , N2 , na , na , na>
# 1285 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    : minus_impl<
          typename minus_tag<N1>::type
        , typename minus_tag<N2>::type
        >::template apply<N1,N2>::type
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
{



   
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
};

template<> struct minus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : minus< T1 , T2 > { }; }; template< typename Tag > struct lambda< minus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef minus< na , na > result_; typedef minus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< minus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< minus< na , na > > : int_<-1> { }; }

}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
namespace boost { namespace mpl {
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
template<>
struct minus_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
                )
            >
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
    {
    };
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/minus.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance_fwd.hpp" 3 4
namespace boost { namespace mpl {



template< typename Tag > struct advance_impl;
template< typename Iterator, typename N > struct advance;

}}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/distance_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/prior.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4





namespace boost { namespace mpl {

template<
      typename Vector
    , long n_
    >
struct v_iter
{
    typedef aux::v_iter_tag tag;
    typedef random_access_iterator_tag category;
    typedef typename v_at<Vector,n_>::type type;

    typedef Vector vector_;
    typedef mpl::long_<n_> pos;
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
};




template<
      typename Vector
    , long n_
    >
struct next< v_iter<Vector,n_> >
{
    typedef v_iter<Vector,(n_ + 1)> type;
};

template<
      typename Vector
    , long n_
    >
struct prior< v_iter<Vector,n_> >
{
    typedef v_iter<Vector,(n_ - 1)> type;
};

template<
      typename Vector
    , long n_
    , typename Distance
    >
struct advance< v_iter<Vector,n_>,Distance>
{
    typedef v_iter<
          Vector
        , (n_ + Distance::value)
        > type;
};

template<
      typename Vector
    , long n_
    , long m_
    >
struct distance< v_iter<Vector,n_>, v_iter<Vector,m_> >
    : mpl::long_<(m_ - n_)>
{
};
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/vector0.hpp" 2 3 4



namespace boost { namespace mpl {

template< typename Dummy = na > struct vector0;

template<> struct vector0<na>
{

    typedef aux::vector_tag tag;
    typedef vector0 type;
    typedef long_<32768> lower_bound_;
    typedef lower_bound_ upper_bound_;
    typedef long_<0> size;

    static aux::type_wrapper<void_> item_(...);
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/vector0.hpp" 3 4
};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/clear.hpp" 2 3 4




namespace boost { namespace mpl {



template<>
struct clear_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef vector0<> type;
    };
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/clear.hpp" 3 4
}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/O1_size.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/O1_size.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/O1_size_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/O1_size.hpp" 2 3 4






namespace boost { namespace mpl {



template<>
struct O1_size_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : Vector::size
    {
    };
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/O1_size.hpp" 3 4
}}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/size.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/size.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct size_impl;
template< typename Sequence > struct size;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/size.hpp" 2 3 4





namespace boost { namespace mpl {



template<>
struct size_impl< aux::vector_tag >
    : O1_size_impl< aux::vector_tag >
{
};
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/size.hpp" 3 4
}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/empty.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/empty.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/empty_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/empty_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct empty_impl;
template< typename Sequence > struct empty;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/empty.hpp" 2 3 4






namespace boost { namespace mpl {



template<>
struct empty_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : is_same<
              typename Vector::lower_bound_
            , typename Vector::upper_bound_
            >
    {
    };
};
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/empty.hpp" 3 4
}}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/begin_end.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/begin_end.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/begin_end_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

}}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/begin_end.hpp" 2 3 4



namespace boost { namespace mpl {

template<>
struct begin_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_iter<Vector,0> type;
    };
};

template<>
struct end_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_iter<Vector,Vector::size::value> type;
    };
};

}}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector10.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector10.hpp" 3 4
namespace boost { namespace mpl {



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum_shifted_params.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0
    >
struct vector1
    : v_item<
          T0
        , vector0< >
        >
{
    typedef vector1 type;
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1
    >
struct vector2
    : v_item<
          T1
        , vector1< T0 >
        >
{
    typedef vector2 type;
};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2
    >
struct vector3
    : v_item<
          T2
        , vector2< T0 , T1 >
        >
{
    typedef vector3 type;
};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3
    >
struct vector4
    : v_item<
          T3
        , vector3< T0 , T1 , T2 >
        >
{
    typedef vector4 type;
};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4
    >
struct vector5
    : v_item<
          T4
        , vector4< T0 , T1 , T2 , T3 >
        >
{
    typedef vector5 type;
};
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
    >
struct vector6
    : v_item<
          T5
        , vector5< T0 , T1 , T2 , T3 , T4 >
        >
{
    typedef vector6 type;
};
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
    >
struct vector7
    : v_item<
          T6
        , vector6< T0 , T1 , T2 , T3 , T4 , T5 >
        >
{
    typedef vector7 type;
};
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
    >
struct vector8
    : v_item<
          T7
        , vector7< T0 , T1 , T2 , T3 , T4 , T5 , T6 >
        >
{
    typedef vector8 type;
};
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
    >
struct vector9
    : v_item<
          T8
        , vector8< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 >
        >
{
    typedef vector9 type;
};
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
    >
struct vector10
    : v_item<
          T9
        , vector9< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 >
        >
{
    typedef vector10 type;
};
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector10.hpp" 2 3 4

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector20.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector20.hpp" 3 4
namespace boost { namespace mpl {



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10
    >
struct vector11
    : v_item<
          T10
        , vector10< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 >
        >
{
    typedef vector11 type;
};
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11
    >
struct vector12
    : v_item<
          T11
        , vector11< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 >
        >
{
    typedef vector12 type;
};
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12
    >
struct vector13
    : v_item<
          T12
        , vector12< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 >
        >
{
    typedef vector13 type;
};
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13
    >
struct vector14
    : v_item<
          T13
        , vector13< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 >
        >
{
    typedef vector14 type;
};
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14
    >
struct vector15
    : v_item<
          T14
        , vector14< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 >
        >
{
    typedef vector15 type;
};
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15
    >
struct vector16
    : v_item<
          T15
        , vector15< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 >
        >
{
    typedef vector16 type;
};
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16
    >
struct vector17
    : v_item<
          T16
        , vector16< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 >
        >
{
    typedef vector17 type;
};
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17
    >
struct vector18
    : v_item<
          T17
        , vector17< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 >
        >
{
    typedef vector18 type;
};
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18
    >
struct vector19
    : v_item<
          T18
        , vector18< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 >
        >
{
    typedef vector19 type;
};
# 143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
    >
struct vector20
    : v_item<
          T19
        , vector19< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 >
        >
{
    typedef vector20 type;
};
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector20.hpp" 2 3 4

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector30.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector30.hpp" 3 4
namespace boost { namespace mpl {



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20
    >
struct vector21
    : v_item<
          T20
        , vector20< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >
        >
{
    typedef vector21 type;
};
# 153 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21
    >
struct vector22
    : v_item<
          T21
        , vector21< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 >
        >
{
    typedef vector22 type;
};
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22
    >
struct vector23
    : v_item<
          T22
        , vector22< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 >
        >
{
    typedef vector23 type;
};
# 163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23
    >
struct vector24
    : v_item<
          T23
        , vector23< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 >
        >
{
    typedef vector24 type;
};
# 168 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24
    >
struct vector25
    : v_item<
          T24
        , vector24< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 >
        >
{
    typedef vector25 type;
};
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25
    >
struct vector26
    : v_item<
          T25
        , vector25< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 >
        >
{
    typedef vector26 type;
};
# 178 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26
    >
struct vector27
    : v_item<
          T26
        , vector26< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 >
        >
{
    typedef vector27 type;
};
# 183 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27
    >
struct vector28
    : v_item<
          T27
        , vector27< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 >
        >
{
    typedef vector28 type;
};
# 188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28
    >
struct vector29
    : v_item<
          T28
        , vector28< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 >
        >
{
    typedef vector29 type;
};
# 193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 1 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29
    >
struct vector30
    : v_item<
          T29
        , vector29< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 >
        >
{
    typedef vector30 type;
};
# 198 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector/vector30.hpp" 2 3 4

}}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector.hpp" 2 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum_params_with_a_default.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum_params_with_a_default.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/enum_params_with_a_default.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
namespace boost { namespace mpl {
# 151 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 = na , typename T1 = na , typename T2 = na , typename T3 = na , typename T4 = na , typename T5 = na , typename T6 = na , typename T7 = na , typename T8 = na , typename T9 = na , typename T10 = na , typename T11 = na , typename T12 = na , typename T13 = na , typename T14 = na , typename T15 = na , typename T16 = na , typename T17 = na , typename T18 = na , typename T19 = na , typename T20 = na , typename T21 = na , typename T22 = na , typename T23 = na , typename T24 = na , typename T25 = na , typename T26 = na , typename T27 = na , typename T28 = na , typename T29 = na
    >
struct vector;
# 164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
     
    >
struct vector< na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector0< >
{



    typedef vector0< >::type type;

};
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0
    >
struct vector< T0 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector1< T0 >
{

    typedef typename vector1< T0 >::type type;



};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1
    >
struct vector< T0 , T1 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector2< T0 , T1 >
{

    typedef typename vector2< T0 , T1 >::type type;



};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2
    >
struct vector< T0 , T1 , T2 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector3< T0 , T1 , T2 >
{

    typedef typename vector3< T0 , T1 , T2 >::type type;



};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3
    >
struct vector< T0 , T1 , T2 , T3 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector4< T0 , T1 , T2 , T3 >
{

    typedef typename vector4< T0 , T1 , T2 , T3 >::type type;



};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4
    >
struct vector< T0 , T1 , T2 , T3 , T4 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector5< T0 , T1 , T2 , T3 , T4 >
{

    typedef typename vector5< T0 , T1 , T2 , T3 , T4 >::type type;



};
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector6< T0 , T1 , T2 , T3 , T4 , T5 >
{

    typedef typename vector6< T0 , T1 , T2 , T3 , T4 , T5 >::type type;



};
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector7< T0 , T1 , T2 , T3 , T4 , T5 , T6 >
{

    typedef typename vector7< T0 , T1 , T2 , T3 , T4 , T5 , T6 >::type type;



};
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector8< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 >
{

    typedef typename vector8< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 >::type type;



};
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector9< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 >
{

    typedef typename vector9< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 >::type type;



};
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector10< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 >
{

    typedef typename vector10< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 >::type type;



};
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector11< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 >
{

    typedef typename vector11< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 >::type type;



};
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector12< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 >
{

    typedef typename vector12< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 >::type type;



};
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector13< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 >
{

    typedef typename vector13< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 >::type type;



};
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector14< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 >
{

    typedef typename vector14< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 >::type type;



};
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector15< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 >
{

    typedef typename vector15< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 >::type type;



};
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector16< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 >
{

    typedef typename vector16< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 >::type type;



};
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector17< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 >
{

    typedef typename vector17< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 >::type type;



};
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , na , na , na , na , na , na , na , na , na , na , na , na >
    : vector18< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 >
{

    typedef typename vector18< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 >::type type;



};
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , na , na , na , na , na , na , na , na , na , na , na >
    : vector19< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 >
{

    typedef typename vector19< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 >::type type;



};
# 143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , na , na , na , na , na , na , na , na , na , na >
    : vector20< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >
{

    typedef typename vector20< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >::type type;



};
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , na , na , na , na , na , na , na , na , na >
    : vector21< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 >
{

    typedef typename vector21< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 >::type type;



};
# 153 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , na , na , na , na , na , na , na , na >
    : vector22< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 >
{

    typedef typename vector22< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 >::type type;



};
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , na , na , na , na , na , na , na >
    : vector23< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 >
{

    typedef typename vector23< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 >::type type;



};
# 163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , na , na , na , na , na , na >
    : vector24< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 >
{

    typedef typename vector24< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 >::type type;



};
# 168 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , na , na , na , na , na >
    : vector25< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 >
{

    typedef typename vector25< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 >::type type;



};
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , na , na , na , na >
    : vector26< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 >
{

    typedef typename vector26< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 >::type type;



};
# 178 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , na , na , na >
    : vector27< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 >
{

    typedef typename vector27< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 >::type type;



};
# 183 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , na , na >
    : vector28< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 >
{

    typedef typename vector28< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 >::type type;



};
# 188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28
    >
struct vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , na >
    : vector29< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 >
{

    typedef typename vector29< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 >::type type;



};
# 193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29
    >
struct vector
    : vector30< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 >
{
    typedef typename vector30< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 >::type type;
};
# 198 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 165 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 2 3 4
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
}}
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/vector.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/has_member_function.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/ddeftype.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/ddeftype.hpp" 3 4
namespace boost
  {
  namespace tti
    {
    namespace detail
      {
      struct deftype
        {
        };
      }
    }
  }
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/has_member_function.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dmem_fun.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dmem_fun.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/is_member_function_pointer.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/is_member_function_pointer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 1 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove_if.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/fold.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/fold.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/begin_end.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/begin_end.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/sequence_tag_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/has_begin.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/traits_lambda_spec.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/begin_end.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/sequence_tag.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/sequence_tag.hpp" 3 4
namespace boost { namespace mpl {
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/fold.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/O1_size.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/O1_size.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/O1_size_impl.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/has_size.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/O1_size_impl.hpp" 2 3 4





namespace boost { namespace mpl {
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
    };
};
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/fold.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/deref.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/deref.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/msvc_type.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/msvc_type.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> { }; }

}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/limits/unrolling.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 2 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
namespace boost { namespace mpl { namespace aux {


template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl;







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl<0,First,Last,State,ForwardOp>
{
    typedef First iter0;
    typedef State state0;

   

    typedef state0 state;
    typedef iter0 iterator;
};
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl<1,First,Last,State,ForwardOp>
{
    typedef First iter0;
    typedef State state0;

    typedef typename apply2< ForwardOp , state0 , typename deref<iter0>::type >::type state1; typedef typename mpl::next<iter0>::type iter1;

    typedef state1 state;
    typedef iter1 iterator;
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl<2,First,Last,State,ForwardOp>
{
    typedef First iter0;
    typedef State state0;

    typedef typename apply2< ForwardOp , state0 , typename deref<iter0>::type >::type state1; typedef typename mpl::next<iter0>::type iter1; typedef typename apply2< ForwardOp , state1 , typename deref<iter1>::type >::type state2; typedef typename mpl::next<iter1>::type iter2;

    typedef state2 state;
    typedef iter2 iterator;
};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl<3,First,Last,State,ForwardOp>
{
    typedef First iter0;
    typedef State state0;

    typedef typename apply2< ForwardOp , state0 , typename deref<iter0>::type >::type state1; typedef typename mpl::next<iter0>::type iter1; typedef typename apply2< ForwardOp , state1 , typename deref<iter1>::type >::type state2; typedef typename mpl::next<iter1>::type iter2; typedef typename apply2< ForwardOp , state2 , typename deref<iter2>::type >::type state3; typedef typename mpl::next<iter2>::type iter3;

    typedef state3 state;
    typedef iter3 iterator;
};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl<4,First,Last,State,ForwardOp>
{
    typedef First iter0;
    typedef State state0;

    typedef typename apply2< ForwardOp , state0 , typename deref<iter0>::type >::type state1; typedef typename mpl::next<iter0>::type iter1; typedef typename apply2< ForwardOp , state1 , typename deref<iter1>::type >::type state2; typedef typename mpl::next<iter1>::type iter2; typedef typename apply2< ForwardOp , state2 , typename deref<iter2>::type >::type state3; typedef typename mpl::next<iter2>::type iter3; typedef typename apply2< ForwardOp , state3 , typename deref<iter3>::type >::type state4; typedef typename mpl::next<iter3>::type iter4;

    typedef state4 state;
    typedef iter4 iterator;
};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 2 3 4


template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl
{
    typedef fold_impl<
          4
        , First
        , Last
        , State
        , ForwardOp
        > chunk_;

    typedef 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 fold_impl<-1,First,Last,State,ForwardOp>
    : fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2<ForwardOp,State,typename deref<First>::type>::type
        , ForwardOp
        >
{
};

template<
      typename Last
    , typename State
    , typename ForwardOp
    >
struct fold_impl<-1,Last,Last,State,ForwardOp>
{
    typedef State state;
    typedef Last iterator;
};
# 296 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
}}}
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/fold.hpp" 2 3 4



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename ForwardOp = na
    >
struct fold
{
    typedef typename aux::fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , ForwardOp
        >::state type;

   
};

template<> struct fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef fold< na , na , na > result_; typedef fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< fold< na , na , na > > : int_<-1> { }; }

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove_if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/reverse_fold.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/reverse_fold.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/reverse_fold.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 3 4
namespace boost { namespace mpl { namespace aux {


template<
      long N
    , typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl;






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 1 3 4
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl<0,First,Last,State,BackwardOp,ForwardOp>
{
    typedef First iter0;
    typedef State fwd_state0;

   





    typedef fwd_state0 bkwd_state0;

   





    typedef bkwd_state0 state;
    typedef iter0 iterator;
};
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 1 3 4
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl<1,First,Last,State,BackwardOp,ForwardOp>
{
    typedef First iter0;
    typedef State fwd_state0;

    typedef typename apply2< ForwardOp , fwd_state0 , typename deref<iter0>::type >::type fwd_state1; typedef typename mpl::next<iter0>::type iter1;





    typedef fwd_state1 bkwd_state1;

    typedef typename apply2< BackwardOp , bkwd_state1 , typename deref<iter0>::type >::type bkwd_state0;





    typedef bkwd_state0 state;
    typedef iter1 iterator;
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 1 3 4
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl<2,First,Last,State,BackwardOp,ForwardOp>
{
    typedef First iter0;
    typedef State fwd_state0;

    typedef typename apply2< ForwardOp , fwd_state0 , typename deref<iter0>::type >::type fwd_state1; typedef typename mpl::next<iter0>::type iter1; typedef typename apply2< ForwardOp , fwd_state1 , typename deref<iter1>::type >::type fwd_state2; typedef typename mpl::next<iter1>::type iter2;





    typedef fwd_state2 bkwd_state2;

    typedef typename apply2< BackwardOp , bkwd_state2 , typename deref<iter1>::type >::type bkwd_state1; typedef typename apply2< BackwardOp , bkwd_state1 , typename deref<iter0>::type >::type bkwd_state0;





    typedef bkwd_state0 state;
    typedef iter2 iterator;
};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 1 3 4
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl<3,First,Last,State,BackwardOp,ForwardOp>
{
    typedef First iter0;
    typedef State fwd_state0;

    typedef typename apply2< ForwardOp , fwd_state0 , typename deref<iter0>::type >::type fwd_state1; typedef typename mpl::next<iter0>::type iter1; typedef typename apply2< ForwardOp , fwd_state1 , typename deref<iter1>::type >::type fwd_state2; typedef typename mpl::next<iter1>::type iter2; typedef typename apply2< ForwardOp , fwd_state2 , typename deref<iter2>::type >::type fwd_state3; typedef typename mpl::next<iter2>::type iter3;





    typedef fwd_state3 bkwd_state3;

    typedef typename apply2< BackwardOp , bkwd_state3 , typename deref<iter2>::type >::type bkwd_state2; typedef typename apply2< BackwardOp , bkwd_state2 , typename deref<iter1>::type >::type bkwd_state1; typedef typename apply2< BackwardOp , bkwd_state1 , typename deref<iter0>::type >::type bkwd_state0;





    typedef bkwd_state0 state;
    typedef iter3 iterator;
};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 1 3 4
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 3 4
template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl<4,First,Last,State,BackwardOp,ForwardOp>
{
    typedef First iter0;
    typedef State fwd_state0;

    typedef typename apply2< ForwardOp , fwd_state0 , typename deref<iter0>::type >::type fwd_state1; typedef typename mpl::next<iter0>::type iter1; typedef typename apply2< ForwardOp , fwd_state1 , typename deref<iter1>::type >::type fwd_state2; typedef typename mpl::next<iter1>::type iter2; typedef typename apply2< ForwardOp , fwd_state2 , typename deref<iter2>::type >::type fwd_state3; typedef typename mpl::next<iter2>::type iter3; typedef typename apply2< ForwardOp , fwd_state3 , typename deref<iter3>::type >::type fwd_state4; typedef typename mpl::next<iter3>::type iter4;





    typedef fwd_state4 bkwd_state4;

    typedef typename apply2< BackwardOp , bkwd_state4 , typename deref<iter3>::type >::type bkwd_state3; typedef typename apply2< BackwardOp , bkwd_state3 , typename deref<iter2>::type >::type bkwd_state2; typedef typename apply2< BackwardOp , bkwd_state2 , typename deref<iter1>::type >::type bkwd_state1; typedef typename apply2< BackwardOp , bkwd_state1 , typename deref<iter0>::type >::type bkwd_state0;





    typedef bkwd_state0 state;
    typedef iter4 iterator;
};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 2 3 4


template<
      long N
    , typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl
{
    typedef First iter0;
    typedef State fwd_state0;

    typedef typename apply2< ForwardOp , fwd_state0 , typename deref<iter0>::type >::type fwd_state1; typedef typename mpl::next<iter0>::type iter1; typedef typename apply2< ForwardOp , fwd_state1 , typename deref<iter1>::type >::type fwd_state2; typedef typename mpl::next<iter1>::type iter2; typedef typename apply2< ForwardOp , fwd_state2 , typename deref<iter2>::type >::type fwd_state3; typedef typename mpl::next<iter2>::type iter3; typedef typename apply2< ForwardOp , fwd_state3 , typename deref<iter3>::type >::type fwd_state4; typedef typename mpl::next<iter3>::type iter4;





    typedef reverse_fold_impl<
          ( (N - 4) < 0 ? 0 : N - 4 )
        , iter4
        , Last
        , fwd_state4
        , BackwardOp
        , ForwardOp
        > nested_chunk;

    typedef typename nested_chunk::state bkwd_state4;

    typedef typename apply2< BackwardOp , bkwd_state4 , typename deref<iter3>::type >::type bkwd_state3; typedef typename apply2< BackwardOp , bkwd_state3 , typename deref<iter2>::type >::type bkwd_state2; typedef typename apply2< BackwardOp , bkwd_state2 , typename deref<iter1>::type >::type bkwd_state1; typedef typename apply2< BackwardOp , bkwd_state1 , typename deref<iter0>::type >::type bkwd_state0;





    typedef bkwd_state0 state;
    typedef typename nested_chunk::iterator iterator;
};


template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl<-1,First,Last,State,BackwardOp,ForwardOp>
{
    typedef reverse_fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2<ForwardOp,State,typename deref<First>::type>::type
        , BackwardOp
        , ForwardOp
        > nested_step;

    typedef typename apply2<
          BackwardOp
        , typename nested_step::state
        , typename deref<First>::type
        >::type state;

    typedef typename nested_step::iterator iterator;
};

template<
      typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_fold_impl<-1,Last,Last,State,BackwardOp,ForwardOp>
{
    typedef State state;
    typedef Last iterator;
};
# 315 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl_body.hpp" 3 4
}}}
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/reverse_fold.hpp" 2 3 4


namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename BackwardOp = na
    , typename ForwardOp = arg<1>
    >
struct reverse_fold
{
    typedef typename aux::reverse_fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , BackwardOp
        , ForwardOp
        >::state type;

   
};

template<> struct reverse_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_fold< na , na , na > result_; typedef reverse_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_fold< na , na , na > > : int_<-1> { }; }

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove_if.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove_if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/back_inserter.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/back_inserter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_back.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_back.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/push_back_impl.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/push_back_impl.hpp" 3 4
namespace boost { namespace mpl {

struct has_push_back_arg {};



template< typename Tag >
struct push_back_impl
{
    template< typename Sequence, typename T > struct apply
    {



        struct REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST40 : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } } mpl_assert_arg40; enum { mpl_assertion_in_line_40 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_back_arg >::value ))>( mpl_assert_arg40::assert_arg() ) ) }



             ;
    };
};

template< typename Tag >
struct has_push_back_impl
{
    template< typename Seq > struct apply

        : aux::has_type< push_back< Seq, has_push_back_arg > >
    {







    };
};

 template<> struct push_back_impl<non_sequence_tag> {};
 template<> struct has_push_back_impl<non_sequence_tag> {};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_back.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct push_back
    : push_back_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,T >
{
   
};


template<
      typename Sequence = na
    >
struct has_push_back
    : has_push_back_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};


template<> struct push_back< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_back< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_back< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_back< na , na > result_; typedef push_back< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_back< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_back< na , na > > : int_<-1> { }; }
template<> struct has_push_back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_back< T1 > { }; }; template< typename Tag > struct lambda< has_push_back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_back< na > result_; typedef has_push_back< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_back< T1 > > : int_<1> { }; template<> struct template_arity< has_push_back< na > > : int_<-1> { }; }

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/back_inserter.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/inserter.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/inserter.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Sequence
    , typename Operation
    >
struct inserter
{
    typedef Sequence state;
    typedef Operation operation;
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/back_inserter.hpp" 2 3 4

namespace boost {
namespace mpl {

template<
      typename Sequence
    >
struct back_inserter
    : inserter< Sequence,push_back<> >
{
};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front_inserter.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front_inserter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_front.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_front.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/push_front_impl.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/push_front_impl.hpp" 3 4
namespace boost { namespace mpl {

struct has_push_front_arg {};




template< typename Tag >
struct push_front_impl
{
    template< typename Sequence, typename T > struct apply
    {



        struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST41 : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } } mpl_assert_arg41; enum { mpl_assertion_in_line_41 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_front_arg >::value ))>( mpl_assert_arg41::assert_arg() ) ) }



             ;
    };
};

template< typename Tag >
struct has_push_front_impl
{
    template< typename Seq > struct apply

        : aux::has_type< push_front< Seq, has_push_front_arg > >
    {







    };
};

 template<> struct push_front_impl<non_sequence_tag> {};
 template<> struct has_push_front_impl<non_sequence_tag> {};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/push_front.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct push_front
    : push_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,T >
{
   
};


template<
      typename Sequence = na
    >
struct has_push_front
    : has_push_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct push_front< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_front< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_front< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_front< na , na > result_; typedef push_front< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_front< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_front< na , na > > : int_<-1> { }; }
template<> struct has_push_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_front< T1 > { }; }; template< typename Tag > struct lambda< has_push_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_front< na > result_; typedef has_push_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_front< T1 > > : int_<1> { }; template<> struct template_arity< has_push_front< na > > : int_<-1> { }; }

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front_inserter.hpp" 2 3 4


namespace boost { namespace mpl {

template<
      typename Sequence
    >
struct front_inserter
    : inserter< Sequence,push_front<> >
{
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/clear.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/clear.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/clear_impl.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/clear_impl.hpp" 3 4
namespace boost { namespace mpl {



template< typename Tag >
struct clear_impl
{
    template< typename Sequence > struct apply;
};

 template<> struct clear_impl<non_sequence_tag> {};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/clear.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct clear
    : clear_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct clear< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : clear< T1 > { }; }; template< typename Tag > struct lambda< clear< na > , Tag , int_<-1> > { typedef false_ is_le; typedef clear< na > result_; typedef clear< na > type; }; namespace aux { template< typename T1 > struct template_arity< clear< T1 > > : int_<1> { }; template<> struct template_arity< clear< na > > : int_<-1> { }; }

}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove_if.hpp" 2 3 4

namespace boost { namespace mpl {

namespace aux {

template< typename Pred, typename InsertOp > struct remove_if_helper
{
    template< typename Sequence, typename U > struct apply
    {
        typedef typename eval_if<
              typename apply1<Pred,U>::type
            , identity<Sequence>
            , apply2<InsertOp,Sequence,U>
            >::type type;
    };
};

template<
      typename Sequence
    , typename Predicate
    , typename Inserter
    >
struct remove_if_impl
    : fold<
          Sequence
        , typename Inserter::state
        , protect< aux::remove_if_helper<
              typename lambda<Predicate>::type
            , typename Inserter::operation
            > >
        >
{
};

template<
      typename Sequence
    , typename Predicate
    , typename Inserter
    >
struct reverse_remove_if_impl
    : reverse_fold<
          Sequence
        , typename Inserter::state
        , protect< aux::remove_if_helper<
              typename lambda<Predicate>::type
            , typename Inserter::operation
            > >
        >
{
};

}

 template< typename P1 = na , typename P2 = na , typename P3 = na > struct remove_if : aux::remove_if_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct remove_if< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::remove_if_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_remove_if_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_remove_if : aux::reverse_remove_if_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_remove_if< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_remove_if_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::remove_if_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct remove_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : remove_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< remove_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef remove_if< na , na , na > result_; typedef remove_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< remove_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< remove_if< na , na , na > > : int_<-1> { }; } template<> struct reverse_remove_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_remove_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_remove_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_remove_if< na , na , na > result_; typedef reverse_remove_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_remove_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_remove_if< na , na , na > > : int_<-1> { }; }

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/same_as.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/same_as.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/lambda_spec.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> >
    {




    };
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/remove.hpp" 2 3 4


namespace boost { namespace mpl {

namespace aux {

template<
      typename Sequence
    , typename T
    , typename Inserter
    >
struct remove_impl
    : remove_if_impl< Sequence, same_as<T>, Inserter >
{
};

template<
      typename Sequence
    , typename T
    , typename Inserter
    >
struct reverse_remove_impl
    : reverse_remove_if_impl< Sequence, same_as<T>, Inserter >
{
};

}

 template< typename P1 = na , typename P2 = na , typename P3 = na > struct remove : aux::remove_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct remove< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::remove_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_remove_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_remove : aux::reverse_remove_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_remove< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_remove_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::remove_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct remove< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : remove< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< remove< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef remove< na , na , na > result_; typedef remove< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< remove< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< remove< na , na , na > > : int_<-1> { }; } template<> struct reverse_remove< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_remove< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_remove< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_remove< na , na , na > result_; typedef reverse_remove< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_remove< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_remove< na , na , na > > : int_<-1> { }; }

}}
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/config/config.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/config/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/config/compiler.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/config/config.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/config/cc_names.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/config/config.hpp" 2 3 4
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 2 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/class_transform.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/class_transform.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/class_transform.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/class_transform.hpp" 2 3 4





namespace boost { namespace function_types { namespace detail {

using mpl::placeholders::_;


template<typename T, typename L>
struct class_transform
{ typedef typename mpl::apply1<L,T>::type type; };






template<typename T> struct class_transform< T, mpl::identity<_> >
{ typedef T type; };

template<typename T> struct class_transform< T, add_reference<_> >
{ typedef T & type; };

template<typename T> struct class_transform< T, add_pointer<_> >
{ typedef T * type; };

template<typename T> struct class_transform< T, remove_cv<_> >
{ typedef typename boost::remove_cv<T>::type type; };

template<typename T> struct class_transform< T, add_reference< remove_cv<_> > >
{ typedef typename boost::remove_cv<T>::type & type; };

template<typename T> struct class_transform< T, add_pointer< remove_cv<_> > >
{ typedef typename boost::remove_cv<T>::type * type; };

template<typename T, typename U> struct class_transform< T, mpl::always<U> >
{ typedef U type; };


} } }
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 2 3 4




namespace boost
{
  namespace function_types
  {

    using mpl::placeholders::_;

    template< typename T, typename ClassTypeTransform = add_reference<_> >
    struct components;

    namespace detail
    {
      template<typename T, typename L> struct components_impl;



    }

    template<typename T, typename ClassTypeTransform>
    struct components

      : detail::components_impl<T, ClassTypeTransform>




    {
      typedef components<T,ClassTypeTransform> type;

     
    };



  namespace detail {

    struct components_mpl_sequence_tag;

    struct components_non_func_base
    {
      typedef mpl::vector0<> types;
      typedef void function_arity;

      typedef detail::constant<0> bits;
      typedef detail::constant<0> mask;

      typedef components_mpl_sequence_tag tag;
    };

    template
    < typename Components
    , typename IfTagged
    , typename ThenTag
    , typename DefaultBase = components_non_func_base
    >
    struct retagged_if
      : mpl::if_
        < detail::represents_impl<Components, IfTagged>
        , detail::changed_tag<Components,IfTagged,ThenTag>
        , DefaultBase
        >::type
    { };





    template<typename T, typename L>
    struct components_impl
      : detail::retagged_if
        < detail::components_impl<T*,L>
        , pointer_tag, function_tag >
    { };
    template<typename T, typename L>
    struct components_impl<T&, L>
      : detail::retagged_if
        < detail::components_impl<T*,L>
        , pointer_tag, reference_tag >
    { };
# 176 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 3 4
    template<typename T, typename L>
    struct components_impl<T*, L>
      : components_non_func_base
    { };


    template<typename T, typename L>
    struct components_impl<T* const, L>
      : components_impl<T*,L>
    { };

    template<typename T, typename L>
    struct components_impl<T* volatile, L>
      : components_impl<T*,L>
    { };

    template<typename T, typename L>
    struct components_impl<T* const volatile, L>
      : components_impl<T*,L>
    { };

    template<typename T, typename L>
    struct components_impl<T const, L>
      : components_impl<T,L>
    { };

    template<typename T, typename L>
    struct components_impl<T volatile, L>
      : components_impl<T,L>
    { };

    template<typename T, typename L>
    struct components_impl<T const volatile, L>
      : components_impl<T,L>
    { };


    template<typename T, class C>
    struct member_obj_ptr_result
    { typedef T & type; };

    template<typename T, class C>
    struct member_obj_ptr_result<T, C const>
    { typedef T const & type; };

    template<typename T, class C>
    struct member_obj_ptr_result<T, C volatile>
    { typedef T volatile & type; };

    template<typename T, class C>
    struct member_obj_ptr_result<T, C const volatile>
    { typedef T const volatile & type; };

    template<typename T, class C>
    struct member_obj_ptr_result<T &, C>
    { typedef T & type; };

    template<typename T, class C>
    struct member_obj_ptr_result<T &, C const>
    { typedef T & type; };

    template<typename T, class C>
    struct member_obj_ptr_result<T &, C volatile>
    { typedef T & type; };

    template<typename T, class C>
    struct member_obj_ptr_result<T &, C const volatile>
    { typedef T & type; };

    template<typename T, class C, typename L>
    struct member_obj_ptr_components
      : member_object_pointer_base
    {
      typedef function_types::components<T C::*, L> type;
      typedef components_mpl_sequence_tag tag;

      typedef mpl::integral_c<std::size_t,1> function_arity;

      typedef mpl::vector2< typename detail::member_obj_ptr_result<T,C>::type,
          typename detail::class_transform<C,L>::type > types;
    };




    template<typename T, class C, typename L>
    struct components_impl<T C::*, L>
      : member_obj_ptr_components<T,C,L>
    { };
# 414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/def.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/aliases_def.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 1 3 4
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 1 3 4
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_0.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_0.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_0.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_0.hpp" 3 4
template< typename R, typename L>
struct components_impl<R ( * ) ( ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) ( ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,0> function_arity;
typedef mpl::vector1< R > types;
};
template< typename R , typename T0, typename L>
struct components_impl<R ( * ) (T0 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R , T0 > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( * ) (T0 , T1 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R , T0 , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R , T0 , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R , T0 , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R , T0 , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R , T0 , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_0.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L>
{
typedef encode_bits<523,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_0.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_0.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_0.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_0.hpp" 3 4
template< typename R, typename L>
struct components_impl<R ( * ) ( ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) ( ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,0> function_arity;
typedef mpl::vector1< R > types;
};
template< typename R , typename T0, typename L>
struct components_impl<R ( * ) (T0 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R , T0 > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( * ) (T0 , T1 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R , T0 , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R , T0 , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R , T0 , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R , T0 , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R , T0 , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_0.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L>
{
typedef encode_bits<267,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 , L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 , L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 , L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L>
{
typedef encode_bits<609,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 185 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 197 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 , L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 , L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 , L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L>
{
typedef encode_bits<353,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 198 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 const, L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 const, L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 const, L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const, L>
{
typedef encode_bits<1633,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 const, L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 const, L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 const, L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const, L>
{
typedef encode_bits<1377,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 volatile, L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 volatile, L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) volatile, L>
{
typedef encode_bits<2657,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 249 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 volatile, L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 volatile, L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile, L>
{
typedef encode_bits<2401,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 262 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 const volatile, L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 const volatile, L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const volatile, L>
{
typedef encode_bits<3681,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 263 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity10_1.hpp" 3 4
template< typename R , typename T0, typename L>
struct components_impl<R ( T0::* ) ( ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) ( ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,1> function_arity;
typedef mpl::vector2< R, typename class_transform<T0 const volatile, L> ::type > types;
};
template< typename R , typename T0 , typename T1, typename L>
struct components_impl<R ( T0::* ) (T1 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,2> function_arity;
typedef mpl::vector3< R, typename class_transform<T0 const volatile, L> ::type , T1 > types;
};
template< typename R , typename T0 , typename T1 , typename T2, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,3> function_arity;
typedef mpl::vector4< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,4> function_arity;
typedef mpl::vector5< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,5> function_arity;
typedef mpl::vector6< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,6> function_arity;
typedef mpl::vector7< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,7> function_arity;
typedef mpl::vector8< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,8> function_arity;
typedef mpl::vector9< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,9> function_arity;
typedef mpl::vector10< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,10> function_arity;
typedef mpl::vector11< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_impl/arity20_1.hpp" 2 3 4
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,11> function_arity;
typedef mpl::vector12< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,12> function_arity;
typedef mpl::vector13< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,13> function_arity;
typedef mpl::vector14< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,14> function_arity;
typedef mpl::vector15< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,15> function_arity;
typedef mpl::vector16< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,16> function_arity;
typedef mpl::vector17< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,17> function_arity;
typedef mpl::vector18< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,18> function_arity;
typedef mpl::vector19< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,19> function_arity;
typedef mpl::vector20< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile, L>
{
typedef encode_bits<3425,1> bits;
typedef constant<0x00ff0fff> mask;
typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile, L> type;
typedef components_mpl_sequence_tag tag;
typedef mpl::integral_c<std::size_t,20> function_arity;
typedef mpl::vector21< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 276 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/aliases_undef.hpp" 1 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/undef.hpp" 1 3 4
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 2 3 4

  } }

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_as_mpl_sequence.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/components_as_mpl_sequence.hpp" 3 4
namespace boost { namespace mpl {

template<> struct size_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S > struct apply
    : mpl::size <typename S::types>
  { };
};
template<> struct empty_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S > struct apply
    : mpl::empty <typename S::types>
  { };
};
template<> struct front_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S > struct apply
    : mpl::front <typename S::types>
  { };
};
template<> struct back_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S > struct apply
    : mpl::back <typename S::types>
  { };
};
template<> struct at_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S, typename N > struct apply
    : mpl::at <typename S::types, N >
  { };
};
template<> struct begin_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S > struct apply
    : mpl::begin <typename S::types>
  { };
};
template<> struct end_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S > struct apply
    : mpl::end <typename S::types>
  { };
};
template<> struct clear_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S >
  struct apply
    : S
  {
    typedef apply type;
    typedef typename mpl::clear< typename S::types >::type types;
  };
};
template<>
struct push_front_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S, typename T >
  struct apply
    : S
  {
    typedef apply type;
    typedef typename mpl::push_front< typename S::types, T >::type types;
  };
};
template<>
struct pop_front_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S >
  struct apply
    : S
  {
    typedef apply type;
    typedef typename mpl::pop_front< typename S::types >::type types;
  };
};
template<>
struct push_back_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S, typename T >
  struct apply
    : S
  {
    typedef apply type;
    typedef typename mpl::push_back< typename S::types, T >::type types;
  };
};
template<>
struct pop_back_impl
< function_types::detail::components_mpl_sequence_tag >
{
  template< typename S >
  struct apply
    : S
  {
    typedef apply type;
    typedef typename mpl::pop_back< typename S::types >::type types;
  };
};

} }
# 421 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/retag_default_cc.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/retag_default_cc.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bitand.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bitand.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    >
struct bitand_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< bitand_impl<Tag1,Tag1>,Tag1,Tag2 >
        , aux::cast1st_impl< bitand_impl<Tag2,Tag2>,Tag1,Tag2 >
        >::type
{
};


template<> struct bitand_impl<na,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};


template< typename Tag > struct bitand_impl<na,Tag>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct bitand_impl<Tag,na>
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template< typename T > struct bitand_tag
{
    typedef typename T::tag type;
};
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 = na
    , typename N2 = na
    , typename N3 =na , typename N4 =na , typename N5 =na
    >
struct bitand_
    : bitand_< bitand_< bitand_< bitand_< N1 , N2> , N3> , N4> , N5>
{
   




};



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 1 3 4
# 1274 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3 , typename N4
    >
struct bitand_< N1 , N2 , N3 , N4 , na>

    : bitand_< bitand_< bitand_< N1 , N2> , N3> , N4>
{
   




};
# 1275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3
    >
struct bitand_< N1 , N2 , N3 , na , na>

    : bitand_< bitand_< N1 , N2> , N3>
{
   




};
# 1280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2
    >
struct bitand_< N1 , N2 , na , na , na>
# 1285 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    : bitand_impl<
          typename bitand_tag<N1>::type
        , typename bitand_tag<N2>::type
        >::template apply<N1,N2>::type
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
{



   
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
};

template<> struct bitand_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : bitand_< T1 , T2 > { }; }; template< typename Tag > struct lambda< bitand_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef bitand_< na , na > result_; typedef bitand_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bitand_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< bitand_< na , na > > : int_<-1> { }; }

}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
namespace boost { namespace mpl {
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
template<>
struct bitand_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
                )
            >
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
    {
    };
};

}}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bitand.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/retag_default_cc.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/retag_default_cc.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_retag_default_cc/preprocessed.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_retag_default_cc/preprocessed.hpp" 3 4
namespace boost { namespace function_types {
namespace detail
{
template<class Tag, class RefTag> struct selector_bits
{
static const bits_t value = ( (::boost::function_types::detail::bits<Tag> ::value & 0x00008000) | (::boost::function_types::detail::bits<RefTag> ::value & 802) )


  ;
};
template<bits_t SelectorBits> struct default_cc_tag;
template<class Tag, class RefTag> struct retag_default_cc
: detail::compound_tag
< Tag, detail::default_cc_tag<
::boost::function_types::detail::selector_bits<Tag,RefTag> ::value > >
{ };
template<bits_t SelectorBits> struct default_cc_tag
{
typedef null_tag::bits bits;
typedef null_tag::mask mask;
};
class test_class;
typedef constant<0x00ff8000> cc_mask_constant;
template< > struct default_cc_tag<33282>
{
typedef void ( *tester)();
typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
typedef cc_mask_constant mask;
};
template< > struct default_cc_tag<33026>
{
typedef void ( *tester)( ... );
typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
typedef cc_mask_constant mask;
};
template< > struct default_cc_tag<33312>
{
typedef void (test_class:: *tester)();
typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
typedef cc_mask_constant mask;
};
template< > struct default_cc_tag<33056>
{
typedef void (test_class:: *tester)( ... );
typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
typedef cc_mask_constant mask;
};
} } }
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/retag_default_cc.hpp" 2 3 4
# 422 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/components.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/is_member_function_pointer.hpp" 2 3 4

namespace boost
{
  namespace function_types
  {
    template< typename T, typename Tag = null_tag >
    struct is_member_function_pointer
      : function_types::represents
        < function_types::components<T>
        , function_types::tag<Tag ,detail::member_function_pointer_tag> >
    {
     
    };
  }
}
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dmem_fun.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dmem_fun.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dcomp_mem_fun.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dcomp_mem_fun.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dftclass.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dftclass.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/parameter_types.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/parameter_types.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank_fwd.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank_fwd.hpp" 3 4
namespace boost {

struct blank;

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/templated_streams.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_empty.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_empty.hpp" 3 4
namespace boost {

namespace detail {







template <typename T>
struct empty_helper_t1 : public T
{
    empty_helper_t1();
    int i[256];
private:

   empty_helper_t1(const empty_helper_t1&);
   empty_helper_t1& operator=(const empty_helper_t1&);
};





struct empty_helper_t2 { int i[256]; };



template <typename T, bool is_a_class = false>
struct empty_helper
{
    static const bool value = false;
};

template <typename T>
struct empty_helper<T, true>
{
    static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2))

         ;
};

template <typename T>
struct is_empty_impl
{
    typedef typename remove_cv<T>::type cvt;
    static const bool value = ( ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value || false)

                                                                                                                         ;
};
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_empty.hpp" 3 4
}

template <class T> struct is_empty : integral_constant<bool, ::boost::detail::is_empty_impl<T>::value> {};

}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_stateless.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_stateless.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_constructor.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 || ((__has_trivial_constructor(T) ) && ! ::boost::is_volatile<T>::value)) && 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> {};



}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/is_stateless.hpp" 2 3 4






namespace boost {

template <typename T>
struct is_stateless
 : public integral_constant<bool,
      (::boost::has_trivial_constructor<T>::value
      && ::boost::has_trivial_copy<T>::value
      && ::boost::has_trivial_destructor<T>::value
      && ::boost::is_class<T>::value
      && ::boost::is_empty<T>::value)>
{};

}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/blank.hpp" 2 3 4

namespace boost {

struct blank
{
};




template <>
struct is_pod< blank >
    : mpl::true_
{
};

template <>
struct is_empty< blank >
    : mpl::true_
{
};

template <>
struct is_stateless< blank >
    : mpl::true_
{
};




inline bool operator==(const blank&, const blank&)
{
    return true;
}

inline bool operator<=(const blank&, const blank&)
{
    return true;
}

inline bool operator>=(const blank&, const blank&)
{
    return true;
}

inline bool operator!=(const blank&, const blank&)
{
    return false;
}

inline bool operator<(const blank&, const blank&)
{
    return false;
}

inline bool operator>(const blank&, const blank&)
{
    return false;
}





template < typename E , typename T >
inline std::basic_ostream< E , T >& operator<<(
      std::basic_ostream< E , T >& out
    , const blank&
    )
{

    return out;
}



}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/parameter_types.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pop_front.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pop_front.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/pop_front_impl.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/pop_front_impl.hpp" 3 4
namespace boost { namespace mpl {



template< typename Tag >
struct pop_front_impl
{
    template< typename Sequence > struct apply







    ;
};

 template<> struct pop_front_impl<non_sequence_tag> {};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pop_front.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct pop_front
    : pop_front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct pop_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pop_front< T1 > { }; }; template< typename Tag > struct lambda< pop_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef pop_front< na > result_; typedef pop_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< pop_front< T1 > > : int_<1> { }; template<> struct template_arity< pop_front< na > > : int_<-1> { }; }

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/parameter_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/is_callable_builtin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/is_callable_builtin.hpp" 3 4
namespace boost
{
  namespace function_types
  {
    template< typename T, typename Tag = null_tag >
    struct is_callable_builtin
      : function_types::represents
        < function_types::components<T>
        , function_types::tag<Tag, detail::callable_builtin_tag>
        >
    {
     
    };
  }
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/parameter_types.hpp" 2 3 4


namespace boost
{
  namespace function_types
  {
    using mpl::placeholders::_;

    template< typename T, typename ClassTypeTransform = add_reference<_> >
    struct parameter_types;

    namespace detail
    {
      template<typename T, typename ClassTypeTransform>
      struct parameter_types_impl
        : mpl::pop_front
          < typename function_types::components<T,ClassTypeTransform>::types
          >::type
      { };
    }

    template<typename T, typename ClassTypeTransform> struct parameter_types
      : mpl::if_
        < function_types::is_callable_builtin<T>
        , detail::parameter_types_impl<T,ClassTypeTransform>, boost::blank
        >::type
    {
     
    };
  }
}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dftclass.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/at.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/at.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/at_impl.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/at_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/less.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/less.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    >
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;
    };
};
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template< typename T > struct less_tag
{
    typedef typename T::tag type;
};
# 241 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
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
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
{
# 278 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
   

};

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> { }; }

}}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 3 4
namespace boost { namespace mpl {
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 3 4
template<>
struct less_impl<integral_c_tag,integral_c_tag>
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N2::value > N1::value ) >
    {





    };
};



}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/less.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/negate.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/negate.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct negate_impl;

template< typename T > struct negate_tag
{
    typedef typename T::tag type;
};

template<
      typename N = na
    >
struct negate

    : negate_impl<
          typename negate_tag<N>::type
        >::template apply<N>::type






{
   
};

template<> struct negate< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : negate< T1 > { }; }; template< typename Tag > struct lambda< negate< na > , Tag , int_<-1> > { typedef false_ is_le; typedef negate< na > result_; typedef negate< na > type; }; namespace aux { template< typename T1 > struct template_arity< negate< T1 > > : int_<1> { }; template<> struct template_arity< negate< na > > : int_<-1> { }; }
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/negate.hpp" 3 4
template<>
struct negate_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, (-N::value) >

    {
    };
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
namespace boost { namespace mpl { namespace aux {


template< long N > struct advance_forward;



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
template<>
struct advance_forward< 0 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;






        typedef iter0 type;
    };
# 110 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
};
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
template<>
struct advance_forward< 1 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4

        typedef iter1 type;
    };
# 110 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
template<>
struct advance_forward< 2 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter1>::type iter2;
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4

        typedef iter2 type;
    };
# 110 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
template<>
struct advance_forward< 3 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter1>::type iter2;
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter2>::type iter3;
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4

        typedef iter3 type;
    };
# 110 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
template<>
struct advance_forward< 4 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter1>::type iter2;
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter2>::type iter3;
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
        typedef typename next<iter3>::type iter4;
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4

        typedef iter4 type;
    };
# 110 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 3 4
};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4


template< long N >
struct advance_forward
{
    template< typename Iterator > struct apply
    {
        typedef typename apply_wrap1<
              advance_forward<4>
            , Iterator
            >::type chunk_result_;

        typedef typename apply_wrap1<
              advance_forward<(
                (N - 4) < 0
                    ? 0
                    : N - 4
                    )>
            , chunk_result_
            >::type type;
    };
};

}}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
namespace boost { namespace mpl { namespace aux {


template< long N > struct advance_backward;



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
template<>
struct advance_backward< 0 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;







        typedef iter0 type;
    };
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
};
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
template<>
struct advance_backward< 1 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4


        typedef iter1 type;
    };
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
template<>
struct advance_backward< 2 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter1>::type iter2;
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4


        typedef iter2 type;
    };
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
template<>
struct advance_backward< 3 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter1>::type iter2;
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter2>::type iter3;
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4


        typedef iter3 type;
    };
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
template<>
struct advance_backward< 4 >
{
    template< typename Iterator > struct apply
    {
        typedef Iterator iter0;




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter0>::type iter1;
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter1>::type iter2;
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter2>::type iter3;
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
        typedef typename prior<iter3>::type iter4;
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4


        typedef iter4 type;
    };
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 3 4
};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4


template< long N >
struct advance_backward
{
    template< typename Iterator > struct apply
    {
        typedef typename apply_wrap1<
              advance_backward<4>
            , Iterator
            >::type chunk_result_;

        typedef typename apply_wrap1<
              advance_backward<(
                (N - 4) < 0
                    ? 0
                    : N - 4
                    )>
            , chunk_result_
            >::type type;
    };
};

}}}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/advance.hpp" 2 3 4




namespace boost { namespace mpl {


template< typename Tag >
struct advance_impl
{
    template< typename Iterator, typename N > struct apply
    {
        typedef typename less< N,long_<0> >::type backward_;
        typedef typename if_< backward_, negate<N>, N >::type offset_;

        typedef typename if_<
              backward_
            , aux::advance_backward< offset_::value >
            , aux::advance_forward< offset_::value >
            >::type f_;

        typedef typename apply_wrap1<f_,Iterator>::type type;
    };
};


template<
      typename Iterator = na
    , typename N = na
    >
struct advance
    : advance_impl< typename tag<Iterator>::type >
        ::template apply<Iterator,N>
{
};

template<
      typename Iterator
    , long N
    >
struct advance_c
    : advance_impl< typename tag<Iterator>::type >
        ::template apply<Iterator,long_<N> >
{
};

template<> struct advance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : advance< T1 , T2 > { }; }; template< typename Tag > struct lambda< advance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef advance< na , na > result_; typedef advance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< advance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< advance< na , na > > : int_<-1> { }; }

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/at_impl.hpp" 2 3 4



namespace boost { namespace mpl {




template< typename Tag >
struct at_impl
{
    template< typename Sequence, typename N > struct apply
    {
        typedef typename advance<
              typename begin<Sequence>::type
            , N
            >::type iter_;

        typedef typename deref<iter_>::type type;
    };
};

 template<> struct at_impl<non_sequence_tag> {};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/at.hpp" 2 3 4






namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename N = na
    >
struct at
    : at_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,N >
{
   
};

template<
      typename Sequence
    , long N
    >
struct at_c
    : at_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,mpl::long_<N> >
{
};

template<> struct at< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : at< T1 , T2 > { }; }; template< typename Tag > struct lambda< at< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef at< na , na > result_; typedef at< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< at< T1 , T2 > > : int_<2> { }; template<> struct template_arity< at< na , na > > : int_<-1> { }; }

}}
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dftclass.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/quote.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dftclass.hpp" 2 3 4

namespace boost
  {
  namespace tti
    {
    namespace detail
      {
      template<class BOOST_TTI_DETAIL_TP_F>
      struct class_type :
          boost::mpl::at
            <
            typename
            boost::function_types::parameter_types
              <
              BOOST_TTI_DETAIL_TP_F,
              boost::mpl::quote1
                <
                boost::mpl::identity
                >
              >::type,
              boost::mpl::int_<0>
            >
        {
        };
      }
    }
  }
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dcomp_mem_fun.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dnullptr.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dcomp_mem_fun.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/gen/namespace_gen.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dcomp_mem_fun.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dmem_fun.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dptmf.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dptmf.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/member_function_pointer.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/member_function_pointer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/size_impl.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/size_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/distance.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/distance.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iter_fold.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iter_fold.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
namespace boost { namespace mpl { namespace aux {


template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl;







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
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;
};
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
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;
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
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;
};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
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;
};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 1 3 4
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
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;
};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 2 3 4


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;
};
# 296 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/fold_impl_body.hpp" 3 4
}}}
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/distance.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iterator_range.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/distance.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> { }; }

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/size_impl.hpp" 2 3 4



namespace boost { namespace mpl {




template< typename Tag >
struct size_impl
{
    template< typename Sequence > struct apply

        : distance<
              typename begin<Sequence>::type
            , typename end<Sequence>::type
            >
    {







    };
};

 template<> struct size_impl<non_sequence_tag> {};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct size
    : aux::msvc_eti_base<
        typename size_impl< typename sequence_tag<Sequence>::type >
            ::template apply< Sequence >::type
      >::type
{
   
};

template<> struct size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : size< T1 > { }; }; template< typename Tag > struct lambda< size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef size< na > result_; typedef size< na > type; }; namespace aux { template< typename T1 > struct template_arity< size< T1 > > : int_<1> { }; template<> struct template_arity< size< na > > : int_<-1> { }; }

}}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/cv_traits.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/cv_traits.hpp" 3 4
namespace boost { namespace function_types { namespace detail {



template<typename T> struct cv_traits
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T &>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T *>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T * const>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T * volatile>
{ typedef non_cv tag; typedef T type; };
template<typename T> struct cv_traits<T * const volatile>
{ typedef non_cv tag; typedef T type; };

template<typename T> struct cv_traits<T const>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const &>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const *>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const * const>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const * volatile>
{ typedef const_non_volatile tag; typedef T type; };
template<typename T> struct cv_traits<T const * const volatile>
{ typedef const_non_volatile tag; typedef T type; };

template<typename T> struct cv_traits<T volatile>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile &>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile *>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile * const>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile * volatile>
{ typedef volatile_non_const tag; typedef T type; };
template<typename T> struct cv_traits<T volatile * const volatile>
{ typedef volatile_non_const tag; typedef T type; };

template<typename T> struct cv_traits<T const volatile>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile &>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile *>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile * const>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile * volatile>
{ typedef cv_qualified tag; typedef T type; };
template<typename T> struct cv_traits<T const volatile * const volatile>
{ typedef cv_qualified tag; typedef T type; };
# 129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/cv_traits.hpp" 3 4
} } }
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize.hpp" 2 3 4


namespace boost { namespace function_types { namespace detail {

template<bits_t Flags, bits_t CCID, std::size_t Size>
struct synthesize_impl_o
{
  template<typename Seq> struct synthesize_impl_i { };
};

template<typename Seq, bits_t Bits>
struct synthesize_impl
  : detail::synthesize_impl_o
    < ::boost::function_types::detail::decode_bits<Bits>::flags
    , ::boost::function_types::detail::decode_bits<Bits>::cc_id
    , ::boost::mpl::size<Seq>::value
    >
    ::template synthesize_impl_i<Seq>
{ };

template<typename Seq, typename Tag>
struct synthesize_func
  : detail::synthesize_impl
    < Seq
    , ::boost::function_types::detail::bits
      < detail::retag_default_cc
        < function_types::tag<nv_dcc_func, Tag> >
      >::value
    >
{ };

template<typename Seq, typename Tag>
struct synthesize_mfp
  : detail::synthesize_impl
    < Seq
    , ::boost::function_types::detail::bits
      < detail::retag_default_cc
        < function_types::tag
          < typename detail::cv_traits< typename mpl::at_c<Seq,1>::type >::tag
          , nv_dcc_mfp, Tag
        > >
      >::value
    >
{ };

template<typename S, typename R = typename mpl::at_c<S,0>::type,
    typename C = typename mpl::at_c<S,1>::type>
struct synthesize_mop
{
  typedef R C::* type;
};



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/def.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/aliases_def.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 1 3 4
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_0.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_0.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_0.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_0.hpp" 3 4
template< typename R >
struct make_type_519_1_0
{
typedef R type ( ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 1 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
public:
typedef typename detail::make_type_519_1_0
< typename mpl::deref< iter_0 > ::type
> ::type type;
};
};
template< typename R , typename T0 >
struct make_type_519_1_1
{
typedef R type (T0 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_519_1_1
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_519_1_2
{
typedef R type (T0 , T1 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_519_1_2
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_519_1_3
{
typedef R type (T0 , T1 , T2 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_519_1_3
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_519_1_4
{
typedef R type (T0 , T1 , T2 , T3 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_519_1_4
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_519_1_5
{
typedef R type (T0 , T1 , T2 , T3 , T4 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_519_1_5
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_519_1_6
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_519_1_6
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_519_1_7
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_519_1_7
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_519_1_8
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_519_1_8
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_519_1_9
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_519_1_9
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_519_1_10
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_519_1_10
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_0.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_519_1_11
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_519_1_11
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_519_1_12
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_519_1_12
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_519_1_13
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_519_1_13
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_519_1_14
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_519_1_14
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_519_1_15
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_519_1_15
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_519_1_16
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_519_1_16
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_519_1_17
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_519_1_17
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_519_1_18
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_519_1_18
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_519_1_19
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_519_1_19
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_519_1_20
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) ;
};
template< >
struct synthesize_impl_o< 519, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_519_1_20
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_0.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_0.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_0.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_0.hpp" 3 4
template< typename R >
struct make_type_263_1_0
{
typedef R type ( ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 1 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
public:
typedef typename detail::make_type_263_1_0
< typename mpl::deref< iter_0 > ::type
> ::type type;
};
};
template< typename R , typename T0 >
struct make_type_263_1_1
{
typedef R type (T0 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_263_1_1
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_263_1_2
{
typedef R type (T0 , T1 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_263_1_2
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_263_1_3
{
typedef R type (T0 , T1 , T2 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_263_1_3
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_263_1_4
{
typedef R type (T0 , T1 , T2 , T3 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_263_1_4
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_263_1_5
{
typedef R type (T0 , T1 , T2 , T3 , T4 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_263_1_5
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_263_1_6
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_263_1_6
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_263_1_7
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_263_1_7
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_263_1_8
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_263_1_8
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_263_1_9
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_263_1_9
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_263_1_10
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_263_1_10
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_0.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_263_1_11
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_263_1_11
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_263_1_12
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_263_1_12
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_263_1_13
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_263_1_13
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_263_1_14
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_263_1_14
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_263_1_15
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_263_1_15
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_263_1_16
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_263_1_16
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_263_1_17
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_263_1_17
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_263_1_18
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_263_1_18
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_263_1_19
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_263_1_19
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_263_1_20
{
typedef R type (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) ;
};
template< >
struct synthesize_impl_o< 263, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_263_1_20
< typename mpl::deref< iter_0 > ::type
, typename mpl::deref< iter_1 > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_609_1_1
{
typedef R ( T0::* type ) ( ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_609_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_609_1_2
{
typedef R ( T0::* type ) (T1 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_609_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_609_1_3
{
typedef R ( T0::* type ) (T1 , T2 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_609_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_609_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_609_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_609_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_609_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_609_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_609_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_609_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_609_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_609_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_609_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_609_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_609_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_609_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_609_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_609_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_609_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_609_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_609_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_609_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_609_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_609_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_609_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_609_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_609_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_609_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_609_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_609_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_609_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_609_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_609_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_609_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_609_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_609_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) ;
};
template< >
struct synthesize_impl_o< 609, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_609_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 185 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 197 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_353_1_1
{
typedef R ( T0::* type ) ( ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_353_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_353_1_2
{
typedef R ( T0::* type ) (T1 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_353_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_353_1_3
{
typedef R ( T0::* type ) (T1 , T2 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_353_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_353_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_353_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_353_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_353_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_353_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_353_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_353_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_353_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_353_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_353_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_353_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_353_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_353_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_353_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_353_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_353_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_353_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_353_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_353_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_353_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_353_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_353_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_353_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_353_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_353_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_353_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_353_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_353_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_353_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_353_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_353_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_353_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_353_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) ;
};
template< >
struct synthesize_impl_o< 353, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_353_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 198 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_1633_1_1
{
typedef R ( T0::* type ) ( ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_1633_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_1633_1_2
{
typedef R ( T0::* type ) (T1 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_1633_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_1633_1_3
{
typedef R ( T0::* type ) (T1 , T2 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_1633_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_1633_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_1633_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_1633_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_1633_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_1633_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_1633_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_1633_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_1633_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_1633_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_1633_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_1633_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_1633_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_1633_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_1633_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_1633_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_1633_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_1633_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_1633_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_1633_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_1633_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_1633_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_1633_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_1633_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_1633_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_1633_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_1633_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_1633_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_1633_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_1633_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_1633_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_1633_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_1633_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_1633_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const ;
};
template< >
struct synthesize_impl_o< 1633, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_1633_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_1377_1_1
{
typedef R ( T0::* type ) ( ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_1377_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_1377_1_2
{
typedef R ( T0::* type ) (T1 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_1377_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_1377_1_3
{
typedef R ( T0::* type ) (T1 , T2 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_1377_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_1377_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_1377_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_1377_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_1377_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_1377_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_1377_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_1377_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_1377_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_1377_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_1377_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_1377_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_1377_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_1377_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_1377_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_1377_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_1377_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_1377_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_1377_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_1377_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_1377_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_1377_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_1377_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_1377_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_1377_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_1377_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_1377_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_1377_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_1377_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_1377_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_1377_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_1377_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_1377_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_1377_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const ;
};
template< >
struct synthesize_impl_o< 1377, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_1377_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_2657_1_1
{
typedef R ( T0::* type ) ( ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_2657_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_2657_1_2
{
typedef R ( T0::* type ) (T1 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_2657_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_2657_1_3
{
typedef R ( T0::* type ) (T1 , T2 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_2657_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_2657_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_2657_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_2657_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_2657_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_2657_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_2657_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_2657_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_2657_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_2657_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_2657_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_2657_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_2657_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_2657_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_2657_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_2657_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_2657_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_2657_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_2657_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_2657_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_2657_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_2657_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_2657_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_2657_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_2657_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_2657_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_2657_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_2657_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_2657_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_2657_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_2657_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_2657_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_2657_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_2657_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) volatile ;
};
template< >
struct synthesize_impl_o< 2657, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_2657_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 249 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_2401_1_1
{
typedef R ( T0::* type ) ( ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_2401_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_2401_1_2
{
typedef R ( T0::* type ) (T1 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_2401_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_2401_1_3
{
typedef R ( T0::* type ) (T1 , T2 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_2401_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_2401_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_2401_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_2401_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_2401_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_2401_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_2401_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_2401_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_2401_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_2401_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_2401_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_2401_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_2401_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_2401_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_2401_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_2401_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_2401_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_2401_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_2401_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_2401_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_2401_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_2401_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_2401_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_2401_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_2401_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_2401_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_2401_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_2401_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_2401_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_2401_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_2401_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_2401_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_2401_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_2401_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile ;
};
template< >
struct synthesize_impl_o< 2401, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_2401_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 262 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_3681_1_1
{
typedef R ( T0::* type ) ( ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_3681_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_3681_1_2
{
typedef R ( T0::* type ) (T1 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_3681_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_3681_1_3
{
typedef R ( T0::* type ) (T1 , T2 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_3681_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_3681_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_3681_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_3681_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_3681_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_3681_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_3681_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_3681_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_3681_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_3681_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_3681_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_3681_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_3681_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_3681_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_3681_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_3681_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_3681_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_3681_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_3681_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_3681_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_3681_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_3681_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_3681_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_3681_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_3681_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_3681_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_3681_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_3681_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_3681_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_3681_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_3681_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_3681_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_3681_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_3681_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const volatile ;
};
template< >
struct synthesize_impl_o< 3681, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_3681_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 263 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity10_1.hpp" 3 4
template< typename R , typename T0 >
struct make_type_3425_1_1
{
typedef R ( T0::* type ) ( ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 2 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
public:
typedef typename detail::make_type_3425_1_1
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 >
struct make_type_3425_1_2
{
typedef R ( T0::* type ) (T1 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 3 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
public:
typedef typename detail::make_type_3425_1_2
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 >
struct make_type_3425_1_3
{
typedef R ( T0::* type ) (T1 , T2 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 4 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
public:
typedef typename detail::make_type_3425_1_3
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
struct make_type_3425_1_4
{
typedef R ( T0::* type ) (T1 , T2 , T3 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 5 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
public:
typedef typename detail::make_type_3425_1_4
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
struct make_type_3425_1_5
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 6 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
public:
typedef typename detail::make_type_3425_1_5
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
struct make_type_3425_1_6
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 7 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
public:
typedef typename detail::make_type_3425_1_6
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
struct make_type_3425_1_7
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 8 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
public:
typedef typename detail::make_type_3425_1_7
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
struct make_type_3425_1_8
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 9 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
public:
typedef typename detail::make_type_3425_1_8
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
struct make_type_3425_1_9
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 10 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
public:
typedef typename detail::make_type_3425_1_9
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
struct make_type_3425_1_10
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 11 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
public:
typedef typename detail::make_type_3425_1_10
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
> ::type type;
};
};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize_impl/arity20_1.hpp" 2 3 4


template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
struct make_type_3425_1_11
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 12 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
public:
typedef typename detail::make_type_3425_1_11
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
struct make_type_3425_1_12
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 13 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
public:
typedef typename detail::make_type_3425_1_12
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
struct make_type_3425_1_13
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 14 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
public:
typedef typename detail::make_type_3425_1_13
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
struct make_type_3425_1_14
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 15 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
public:
typedef typename detail::make_type_3425_1_14
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
struct make_type_3425_1_15
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 16 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
public:
typedef typename detail::make_type_3425_1_15
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
struct make_type_3425_1_16
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 17 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
public:
typedef typename detail::make_type_3425_1_16
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
struct make_type_3425_1_17
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 18 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
public:
typedef typename detail::make_type_3425_1_17
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
struct make_type_3425_1_18
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 19 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
public:
typedef typename detail::make_type_3425_1_18
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
struct make_type_3425_1_19
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 20 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
public:
typedef typename detail::make_type_3425_1_19
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
> ::type type;
};
};
template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
struct make_type_3425_1_20
{
typedef R ( T0::* type ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile ;
};
template< >
struct synthesize_impl_o< 3425, 1, 21 >
{
template<typename S> struct synthesize_impl_i
{
private:
typedef typename mpl::begin<S> ::type iter_0;
typedef typename mpl::next< iter_0 > ::type iter_1;
typedef typename mpl::next< iter_1 > ::type iter_2;
typedef typename mpl::next< iter_2 > ::type iter_3;
typedef typename mpl::next< iter_3 > ::type iter_4;
typedef typename mpl::next< iter_4 > ::type iter_5;
typedef typename mpl::next< iter_5 > ::type iter_6;
typedef typename mpl::next< iter_6 > ::type iter_7;
typedef typename mpl::next< iter_7 > ::type iter_8;
typedef typename mpl::next< iter_8 > ::type iter_9;
typedef typename mpl::next< iter_9 > ::type iter_10;
typedef typename mpl::next< iter_10 > ::type iter_11;
typedef typename mpl::next< iter_11 > ::type iter_12;
typedef typename mpl::next< iter_12 > ::type iter_13;
typedef typename mpl::next< iter_13 > ::type iter_14;
typedef typename mpl::next< iter_14 > ::type iter_15;
typedef typename mpl::next< iter_15 > ::type iter_16;
typedef typename mpl::next< iter_16 > ::type iter_17;
typedef typename mpl::next< iter_17 > ::type iter_18;
typedef typename mpl::next< iter_18 > ::type iter_19;
typedef typename mpl::next< iter_19 > ::type iter_20;
public:
typedef typename detail::make_type_3425_1_20
< typename mpl::deref< iter_0 > ::type
, typename detail::cv_traits<
typename mpl::deref< iter_1 > ::type > ::type
, typename mpl::deref< iter_2 > ::type
, typename mpl::deref< iter_3 > ::type
, typename mpl::deref< iter_4 > ::type
, typename mpl::deref< iter_5 > ::type
, typename mpl::deref< iter_6 > ::type
, typename mpl::deref< iter_7 > ::type
, typename mpl::deref< iter_8 > ::type
, typename mpl::deref< iter_9 > ::type
, typename mpl::deref< iter_10 > ::type
, typename mpl::deref< iter_11 > ::type
, typename mpl::deref< iter_12 > ::type
, typename mpl::deref< iter_13 > ::type
, typename mpl::deref< iter_14 > ::type
, typename mpl::deref< iter_15 > ::type
, typename mpl::deref< iter_16 > ::type
, typename mpl::deref< iter_17 > ::type
, typename mpl::deref< iter_18 > ::type
, typename mpl::deref< iter_19 > ::type
, typename mpl::deref< iter_20 > ::type
> ::type type;
};
};
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_arity_loop.hpp" 2 3 4
# 276 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_variate_loop/preprocessed.hpp" 2 3 4
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_cc_loop/preprocessed.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/aliases_undef.hpp" 1 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/encoding/undef.hpp" 1 3 4
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/pp_loop.hpp" 2 3 4
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/synthesize.hpp" 2 3 4

} } }
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/member_function_pointer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/to_sequence.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/to_sequence.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/is_sequence.hpp" 1 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/is_sequence.hpp" 3 4
namespace boost { namespace mpl {
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/is_sequence.hpp" 3 4
template<
      typename T = na
    >
struct is_sequence
    : not_< is_same< typename begin<T>::type, void_ > >
{
   
};
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/is_sequence.hpp" 3 4
template<> struct is_sequence< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_sequence< T1 > { }; }; template< typename Tag > struct lambda< is_sequence< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_sequence< na > result_; typedef is_sequence< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_sequence< T1 > > : int_<1> { }; template<> struct template_arity< is_sequence< na > > : int_<-1> { }; }

}}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/to_sequence.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/detail/to_sequence.hpp" 2 3 4




namespace boost { namespace function_types { namespace detail {


template<typename T>
struct to_sequence
{
  typedef typename
   mpl::eval_if
   < is_callable_builtin<T>
   , to_sequence< components<T> >
   , mpl::identity< T >
   >::type
  type;
};


template<typename T, typename U>
struct to_sequence< components<T,U> >
{
  typedef typename components<T,U>::types type;
};

} } }
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function_types/member_function_pointer.hpp" 2 3 4

namespace boost
{
  namespace function_types
  {
    template<typename Types, typename Tag = null_tag>
    struct member_function_pointer
      : detail::synthesize_mfp< typename detail::to_sequence<Types>::type, Tag >
    {
     
    };
  }
}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dptmf.hpp" 2 3 4

namespace boost
  {
  namespace tti
    {
    namespace detail
      {
      template
        <
        class BOOST_TTI_DETAIL_TP_T,
        class BOOST_TTI_DETAIL_TP_R,
        class BOOST_TTI_DETAIL_TP_FS,
        class BOOST_TTI_DETAIL_TP_TAG
        >
      struct ptmf_seq
        {
        typedef typename
        boost::function_types::member_function_pointer
          <
          typename
          boost::mpl::push_front
            <
            typename
            boost::mpl::push_front<BOOST_TTI_DETAIL_TP_FS,BOOST_TTI_DETAIL_TP_T>::type,
            BOOST_TTI_DETAIL_TP_R
            >::type,
          BOOST_TTI_DETAIL_TP_TAG
          >::type type;
        };
      }
    }
  }
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/detail/dmem_fun.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/has_member_function.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/gen/has_member_function_gen.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/tti/has_member_function.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/entropy_error.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/entropy_error.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/entropy_error.hpp" 2 3 4



namespace boost {
namespace uuids {




class entropy_error : public std::runtime_error
{
public:
    entropy_error(boost::intmax_t errCode, const std::string& message)
        : std::runtime_error(message)
        , m_errcode(errCode)
    {
    }

    virtual boost::intmax_t errcode() const
    {
        return m_errcode;
    }

private:
    boost::intmax_t m_errcode;
};

}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider.hpp" 2 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_detect_platform.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_detect_platform.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/cloudabi.h" 1 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/cloudabi.h" 3 4

# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_detect_platform.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 1 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/library/c/gnu.h" 3 4

# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_detect_platform.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 1 3 4
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/bsd/open.h" 3 4

# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_detect_platform.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 1 3 4
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/os/windows.h" 3 4

# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_detect_platform.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_include_platform.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_include_platform.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_getentropy.ipp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_getentropy.ipp" 3 4
# 1 "/usr/include/c++/10/cerrno" 1 3 4
# 39 "/usr/include/c++/10/cerrno" 3 4
       
# 40 "/usr/include/c++/10/cerrno" 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_getentropy.ipp" 2 3 4


namespace boost {
namespace uuids {
namespace detail {

class random_provider_base
{
  public:



    void get_random_bytes(void *buf, size_t siz)
    {
        if (-1 == getentropy(buf, siz))
        {
            int err = (*__errno_location ());
            ::boost::exception_detail::throw_exception_(entropy_error(err, "getentropy"),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_getentropy.ipp",30);
        }
    }
};

}
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider_include_platform.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/detail/random_provider.hpp" 2 3 4


namespace boost {
namespace uuids {
namespace detail {







class random_provider
    : public detail::random_provider_base,
      public noncopyable
{
public:



    template<class Iter>
    void generate(Iter first, Iter last)
    {
        typedef typename std::iterator_traits<Iter>::value_type value_type;
        static_assert(is_integral<value_type>::value, "is_integral<value_type>::value");
        static_assert(is_unsigned<value_type>::value, "is_unsigned<value_type>::value");
        static_assert(sizeof(value_type) * 8 >= 32, "sizeof(value_type) * CHAR_BIT >= 32");

        for (; first != last; ++first)
        {
            get_random_bytes(&*first, sizeof(*first));
            *first &= (std::numeric_limits<boost::uint32_t>::max)();
        }
    }


    const char * name() const
    {
        return "getentropy";
    }
};

}
}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/random_generator.hpp" 2 3 4



namespace boost {
namespace uuids {

namespace detail {
    template<class U>
    U& set_uuid_random_vv(U& u)
    {


        *(u.begin() + 8) &= 0xBF;
        *(u.begin() + 8) |= 0x80;



        *(u.begin() + 6) &= 0x4F;
        *(u.begin() + 6) |= 0x40;

        return u;
    }

    template<class BOOST_TTI_DETAIL_TP_PMEMF,class BOOST_TTI_DETAIL_TP_C> struct has_member_function_seed_detail_types { template<BOOST_TTI_DETAIL_TP_PMEMF> struct helper; template<class BOOST_TTI_DETAIL_TP_EC> static ::boost::type_traits::yes_type chkt(helper<&BOOST_TTI_DETAIL_TP_EC::seed> *); template<class BOOST_TTI_DETAIL_TP_EC> static ::boost::type_traits::no_type chkt(...); typedef boost::mpl::bool_<sizeof(chkt<BOOST_TTI_DETAIL_TP_C>(nullptr))==sizeof(::boost::type_traits::yes_type)> type; }; template<class BOOST_TTI_DETAIL_TP_T,class BOOST_TTI_DETAIL_TP_R,class BOOST_TTI_DETAIL_TP_FS,class BOOST_TTI_DETAIL_TP_TAG> struct has_member_function_seed_detail_ctmf_invoke : has_member_function_seed_detail_types < typename boost::tti::detail::ptmf_seq<BOOST_TTI_DETAIL_TP_T,BOOST_TTI_DETAIL_TP_R,BOOST_TTI_DETAIL_TP_FS,BOOST_TTI_DETAIL_TP_TAG>::type, BOOST_TTI_DETAIL_TP_T > { }; template<class BOOST_TTI_DETAIL_TP_T,class BOOST_TTI_DETAIL_TP_R,class BOOST_TTI_DETAIL_TP_FS,class BOOST_TTI_DETAIL_TP_TAG> struct has_member_function_seed_detail_call_types : boost::mpl::eval_if < boost::is_class<BOOST_TTI_DETAIL_TP_T>, has_member_function_seed_detail_ctmf_invoke < BOOST_TTI_DETAIL_TP_T, BOOST_TTI_DETAIL_TP_R, BOOST_TTI_DETAIL_TP_FS, BOOST_TTI_DETAIL_TP_TAG >, boost::mpl::false_ > { }; template<class BOOST_TTI_DETAIL_TP_T> struct has_member_function_seed_detail_hcmf { template<class BOOST_TTI_DETAIL_TP_F> struct cl_type : boost::remove_const < typename boost::tti::detail::class_type<BOOST_TTI_DETAIL_TP_F>::type > { }; template<BOOST_TTI_DETAIL_TP_T> struct helper; template<class BOOST_TTI_DETAIL_TP_U> static ::boost::type_traits::yes_type chkt(helper<&BOOST_TTI_DETAIL_TP_U::seed> *); template<class BOOST_TTI_DETAIL_TP_U> static ::boost::type_traits::no_type chkt(...); typedef boost::mpl::bool_<sizeof(chkt<typename cl_type<BOOST_TTI_DETAIL_TP_T>::type>(nullptr))==sizeof(::boost::type_traits::yes_type)> type; }; template<class BOOST_TTI_DETAIL_TP_T> struct has_member_function_seed_detail_check_comp : has_member_function_seed_detail_hcmf<BOOST_TTI_DETAIL_TP_T> { enum { mpl_assertion_in_line_44 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::function_types::is_member_function_pointer<BOOST_TTI_DETAIL_TP_T>))0, 1 ) ) ) }; }; template<class BOOST_TTI_DETAIL_TP_T,class BOOST_TTI_DETAIL_TP_R,class BOOST_TTI_DETAIL_TP_FS,class BOOST_TTI_DETAIL_TP_TAG> struct has_member_function_seed_detail_hmf : boost::mpl::eval_if < boost::mpl::and_ < boost::is_same<BOOST_TTI_DETAIL_TP_R,boost::tti::detail::deftype>, boost::is_same<BOOST_TTI_DETAIL_TP_FS,boost::mpl::vector<> >, boost::is_same<BOOST_TTI_DETAIL_TP_TAG,boost::function_types::null_tag> >, has_member_function_seed_detail_check_comp<BOOST_TTI_DETAIL_TP_T>, has_member_function_seed_detail_call_types<BOOST_TTI_DETAIL_TP_T,BOOST_TTI_DETAIL_TP_R,BOOST_TTI_DETAIL_TP_FS,BOOST_TTI_DETAIL_TP_TAG> > { }; template<class BOOST_TTI_TP_T,class BOOST_TTI_TP_R = boost::tti::detail::deftype,class BOOST_TTI_TP_FS = boost::mpl::vector<>,class BOOST_TTI_TP_TAG = boost::function_types::null_tag> struct has_member_function_seed { typedef typename has_member_function_seed_detail_hmf<BOOST_TTI_TP_T,BOOST_TTI_TP_R,BOOST_TTI_TP_FS,BOOST_TTI_TP_TAG>::type type; static const bool value=type::value; };
}



template <typename UniformRandomNumberGenerator>
class basic_random_generator {
private:
    typedef uniform_int<unsigned long> distribution_type;
    typedef variate_generator<UniformRandomNumberGenerator*, distribution_type> generator_type;

public:
    typedef uuid result_type;




    basic_random_generator()
        : pURNG(new UniformRandomNumberGenerator)
        , generator
          ( pURNG.get()
          , distribution_type
            ( (std::numeric_limits<unsigned long>::min)()
            , (std::numeric_limits<unsigned long>::max)()
            )
          )
    {

        seed(*pURNG);
    }



    explicit basic_random_generator(UniformRandomNumberGenerator& gen)
        : pURNG(&gen, boost::null_deleter())
        , generator
          ( pURNG.get()
          , distribution_type
            ( (std::numeric_limits<unsigned long>::min)()
            , (std::numeric_limits<unsigned long>::max)()
            )
          )
    {}



    explicit basic_random_generator(UniformRandomNumberGenerator* pGen)
        : pURNG(pGen, boost::null_deleter())
        , generator
          ( pURNG.get()
          , distribution_type
            ( (std::numeric_limits<unsigned long>::min)()
            , (std::numeric_limits<unsigned long>::max)()
            )
          )
    {
        (static_cast<void> (0));
    }

    result_type operator()()
    {
        result_type u;

        int i=0;
        unsigned long random_value = generator();
        for (uuid::iterator it=u.begin(); it!=u.end(); ++it, ++i) {
            if (i==sizeof(unsigned long)) {
                random_value = generator();
                i = 0;
            }


            *it = static_cast<uuid::value_type>((random_value >> (i*8)) & 0xFF);
        }

        return detail::set_uuid_random_vv(u);
    }

private:





    template<class MaybePseudoRandomNumberGenerator>
    typename boost::enable_if<detail::has_member_function_seed<MaybePseudoRandomNumberGenerator, void> >::type
        seed(MaybePseudoRandomNumberGenerator& rng)
    {
        detail::random_provider seeder;
        rng.seed(seeder);
    }

    template<class MaybePseudoRandomNumberGenerator>
    typename boost::disable_if<detail::has_member_function_seed<MaybePseudoRandomNumberGenerator, void> >::type
        seed(MaybePseudoRandomNumberGenerator&)
    {
    }

    shared_ptr<UniformRandomNumberGenerator> pURNG;
    generator_type generator;
};




class random_generator_pure
{
public:
    typedef uuid result_type;



    result_type operator()()
    {
        result_type result;
        prov_.get_random_bytes(&result, sizeof(result_type));
        return detail::set_uuid_random_vv(result);
    }

private:
    detail::random_provider prov_;
};




typedef random_generator_pure random_generator;
typedef basic_random_generator<mt19937> random_generator_mt19937;


}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_generators.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_io.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_io.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/io/ios_state.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/io/ios_state.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/io_fwd.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/io_fwd.hpp" 3 4
namespace boost
{
namespace io
{




class ios_flags_saver;
class ios_precision_saver;
class ios_width_saver;
class ios_base_all_saver;

template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_iostate_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_exception_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_tie_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_rdbuf_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_fill_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_locale_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_all_saver;

typedef basic_ios_iostate_saver<char> ios_iostate_saver;
typedef basic_ios_iostate_saver<wchar_t> wios_iostate_saver;
typedef basic_ios_exception_saver<char> ios_exception_saver;
typedef basic_ios_exception_saver<wchar_t> wios_exception_saver;
typedef basic_ios_tie_saver<char> ios_tie_saver;
typedef basic_ios_tie_saver<wchar_t> wios_tie_saver;
typedef basic_ios_rdbuf_saver<char> ios_rdbuf_saver;
typedef basic_ios_rdbuf_saver<wchar_t> wios_rdbuf_saver;
typedef basic_ios_fill_saver<char> ios_fill_saver;
typedef basic_ios_fill_saver<wchar_t> wios_fill_saver;
typedef basic_ios_locale_saver<char> ios_locale_saver;
typedef basic_ios_locale_saver<wchar_t> wios_locale_saver;
typedef basic_ios_all_saver<char> ios_all_saver;
typedef basic_ios_all_saver<wchar_t> wios_all_saver;

class ios_iword_saver;
class ios_pword_saver;
class ios_all_word_saver;


}
}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/io/ios_state.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/io/ios_state.hpp" 3 4
namespace boost
{
namespace io
{




class ios_flags_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef ::std::ios_base::fmtflags aspect_type;

    explicit ios_flags_saver( state_type &s )
        : s_save_( s ), a_save_( s.flags() )
        {}
    ios_flags_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.flags(a) )
        {}
    ~ios_flags_saver()
        { this->restore(); }

    void restore()
        { s_save_.flags( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;

    ios_flags_saver& operator=(const ios_flags_saver&);
};

class ios_precision_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef ::std::streamsize aspect_type;

    explicit ios_precision_saver( state_type &s )
        : s_save_( s ), a_save_( s.precision() )
        {}
    ios_precision_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.precision(a) )
        {}
    ~ios_precision_saver()
        { this->restore(); }

    void restore()
        { s_save_.precision( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;

    ios_precision_saver& operator=(const ios_precision_saver&);
};

class ios_width_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef ::std::streamsize aspect_type;

    explicit ios_width_saver( state_type &s )
        : s_save_( s ), a_save_( s.width() )
        {}
    ios_width_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.width(a) )
        {}
    ~ios_width_saver()
        { this->restore(); }

    void restore()
        { s_save_.width( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    ios_width_saver& operator=(const ios_width_saver&);
};




template < typename Ch, class Tr >
class basic_ios_iostate_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::ios_base::iostate aspect_type;

    explicit basic_ios_iostate_saver( state_type &s )
        : s_save_( s ), a_save_( s.rdstate() )
        {}
    basic_ios_iostate_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.rdstate() )
        { s.clear(a); }
    ~basic_ios_iostate_saver()
        { this->restore(); }

    void restore()
        { s_save_.clear( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&);
};

template < typename Ch, class Tr >
class basic_ios_exception_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::ios_base::iostate aspect_type;

    explicit basic_ios_exception_saver( state_type &s )
        : s_save_( s ), a_save_( s.exceptions() )
        {}



    basic_ios_exception_saver( state_type &s, aspect_type const &a )

        : s_save_( s ), a_save_( s.exceptions() )
        { s.exceptions(a); }
    ~basic_ios_exception_saver()
        { this->restore(); }

    void restore()
        { s_save_.exceptions( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_exception_saver& operator=(const basic_ios_exception_saver&);
};

template < typename Ch, class Tr >
class basic_ios_tie_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::basic_ostream<Ch, Tr> * aspect_type;

    explicit basic_ios_tie_saver( state_type &s )
        : s_save_( s ), a_save_( s.tie() )
        {}
    basic_ios_tie_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.tie(a) )
        {}
    ~basic_ios_tie_saver()
        { this->restore(); }

    void restore()
        { s_save_.tie( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_tie_saver& operator=(const basic_ios_tie_saver&);
};

template < typename Ch, class Tr >
class basic_ios_rdbuf_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::basic_streambuf<Ch, Tr> * aspect_type;

    explicit basic_ios_rdbuf_saver( state_type &s )
        : s_save_( s ), a_save_( s.rdbuf() )
        {}
    basic_ios_rdbuf_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.rdbuf(a) )
        {}
    ~basic_ios_rdbuf_saver()
        { this->restore(); }

    void restore()
        { s_save_.rdbuf( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&);
};

template < typename Ch, class Tr >
class basic_ios_fill_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef typename state_type::char_type aspect_type;

    explicit basic_ios_fill_saver( state_type &s )
        : s_save_( s ), a_save_( s.fill() )
        {}
    basic_ios_fill_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.fill(a) )
        {}
    ~basic_ios_fill_saver()
        { this->restore(); }

    void restore()
        { s_save_.fill( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_fill_saver& operator=(const basic_ios_fill_saver&);
};


template < typename Ch, class Tr >
class basic_ios_locale_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::locale aspect_type;

    explicit basic_ios_locale_saver( state_type &s )
        : s_save_( s ), a_save_( s.getloc() )
        {}
    basic_ios_locale_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.imbue(a) )
        {}
    ~basic_ios_locale_saver()
        { this->restore(); }

    void restore()
        { s_save_.imbue( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_locale_saver& operator=(const basic_ios_locale_saver&);
};





class ios_iword_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef int index_type;
    typedef long aspect_type;

    explicit ios_iword_saver( state_type &s, index_type i )
        : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
        {}
    ios_iword_saver( state_type &s, index_type i, aspect_type const &a )
        : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
        { s.iword(i) = a; }
    ~ios_iword_saver()
        { this->restore(); }

    void restore()
        { s_save_.iword( i_save_ ) = a_save_; }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    index_type const i_save_;

    ios_iword_saver& operator=(const ios_iword_saver&);
};

class ios_pword_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef int index_type;
    typedef void * aspect_type;

    explicit ios_pword_saver( state_type &s, index_type i )
        : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
        {}
    ios_pword_saver( state_type &s, index_type i, aspect_type const &a )
        : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
        { s.pword(i) = a; }
    ~ios_pword_saver()
        { this->restore(); }

    void restore()
        { s_save_.pword( i_save_ ) = a_save_; }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    index_type const i_save_;

    ios_pword_saver operator=(const ios_pword_saver&);
};




class ios_base_all_saver
{
public:
    typedef ::std::ios_base state_type;

    explicit ios_base_all_saver( state_type &s )
        : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
        , a3_save_( s.width() )
        {}

    ~ios_base_all_saver()
        { this->restore(); }

    void restore()
    {
        s_save_.width( a3_save_ );
        s_save_.precision( a2_save_ );
        s_save_.flags( a1_save_ );
    }

private:
    state_type & s_save_;
    state_type::fmtflags const a1_save_;
    ::std::streamsize const a2_save_;
    ::std::streamsize const a3_save_;

    ios_base_all_saver& operator=(const ios_base_all_saver&);
};

template < typename Ch, class Tr >
class basic_ios_all_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;

    explicit basic_ios_all_saver( state_type &s )
        : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
        , a3_save_( s.width() ), a4_save_( s.rdstate() )
        , a5_save_( s.exceptions() ), a6_save_( s.tie() )
        , a7_save_( s.rdbuf() ), a8_save_( s.fill() )

        , a9_save_( s.getloc() )

        {}

    ~basic_ios_all_saver()
        { this->restore(); }

    void restore()
    {

        s_save_.imbue( a9_save_ );

        s_save_.fill( a8_save_ );
        s_save_.rdbuf( a7_save_ );
        s_save_.tie( a6_save_ );
        s_save_.exceptions( a5_save_ );
        s_save_.clear( a4_save_ );
        s_save_.width( a3_save_ );
        s_save_.precision( a2_save_ );
        s_save_.flags( a1_save_ );
    }

private:
    state_type & s_save_;
    typename state_type::fmtflags const a1_save_;
    ::std::streamsize const a2_save_;
    ::std::streamsize const a3_save_;
    typename state_type::iostate const a4_save_;
    typename state_type::iostate const a5_save_;
    ::std::basic_ostream<Ch, Tr> * const a6_save_;
    ::std::basic_streambuf<Ch, Tr> * const a7_save_;
    typename state_type::char_type const a8_save_;

    ::std::locale const a9_save_;


    basic_ios_all_saver& operator=(const basic_ios_all_saver&);
};

class ios_all_word_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef int index_type;

    ios_all_word_saver( state_type &s, index_type i )
        : s_save_( s ), i_save_( i ), a1_save_( s.iword(i) )
        , a2_save_( s.pword(i) )
        {}

    ~ios_all_word_saver()
        { this->restore(); }

    void restore()
    {
        s_save_.pword( i_save_ ) = a2_save_;
        s_save_.iword( i_save_ ) = a1_save_;
    }

private:
    state_type & s_save_;
    index_type const i_save_;
    long const a1_save_;
    void * const a2_save_;

    ios_all_word_saver& operator=(const ios_all_word_saver&);
};


}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_io.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/uuid/uuid_io.hpp" 3 4
namespace boost {
namespace uuids {

template <typename ch, typename char_traits>
    std::basic_ostream<ch, char_traits>& operator<<(std::basic_ostream<ch, char_traits> &os, uuid const& u)
{
    io::ios_flags_saver flags_saver(os);
    io::basic_ios_fill_saver<ch, char_traits> fill_saver(os);

    const typename std::basic_ostream<ch, char_traits>::sentry ok(os);
    if (ok) {
        const std::streamsize width = os.width(0);
        const std::streamsize uuid_width = 36;
        const std::ios_base::fmtflags flags = os.flags();
        const typename std::basic_ios<ch, char_traits>::char_type fill = os.fill();
        if (flags & (std::ios_base::right | std::ios_base::internal)) {
            for (std::streamsize i=uuid_width; i<width; i++) {
                os << fill;
            }
        }

        os << std::hex << std::right;
        os.fill(os.widen('0'));

        std::size_t i=0;
        for (uuid::const_iterator i_data = u.begin(); i_data!=u.end(); ++i_data, ++i) {
            os.width(2);
            os << static_cast<unsigned int>(*i_data);
            if (i == 3 || i == 5 || i == 7 || i == 9) {
                os << os.widen('-');
            }
        }

        if (flags & std::ios_base::left) {
            for (std::streamsize s=uuid_width; s<width; s++) {
                os << fill;
            }
        }

        os.width(0);
    }
    return os;
}

template <typename ch, typename char_traits>
    std::basic_istream<ch, char_traits>& operator>>(std::basic_istream<ch, char_traits> &is, uuid &u)
{
    const typename std::basic_istream<ch, char_traits>::sentry ok(is);
    if (ok) {
        unsigned char data[16];

        typedef std::ctype<ch> ctype_t;
        ctype_t const& ctype = std::use_facet<ctype_t>(is.getloc());

        ch xdigits[16];
        {
            char szdigits[] = "0123456789ABCDEF";
            ctype.widen(szdigits, szdigits+16, xdigits);
        }
        ch*const xdigits_end = xdigits+16;

        ch c;
        for (std::size_t i=0; i<u.size() && is; ++i) {
            is >> c;
            c = ctype.toupper(c);

            ch* f = std::find(xdigits, xdigits_end, c);
            if (f == xdigits_end) {
                is.setstate(std::ios_base::failbit);
                break;
            }

            unsigned char byte = static_cast<unsigned char>(std::distance(&xdigits[0], f));

            is >> c;
            c = ctype.toupper(c);
            f = std::find(xdigits, xdigits_end, c);
            if (f == xdigits_end) {
                is.setstate(std::ios_base::failbit);
                break;
            }

            byte <<= 4;
            byte |= static_cast<unsigned char>(std::distance(&xdigits[0], f));

            data[i] = byte;

            if (is) {
                if (i == 3 || i == 5 || i == 7 || i == 9) {
                    is >> c;
                    if (c != is.widen('-')) is.setstate(std::ios_base::failbit);
                }
            }
        }

        if (is) {
            std::copy(data, data+16, u.begin());
        }
    }
    return is;
}

namespace detail {
inline char to_char(size_t i) {
    if (i <= 9) {
        return static_cast<char>('0' + i);
    } else {
        return static_cast<char>('a' + (i-10));
    }
}

inline wchar_t to_wchar(size_t i) {
    if (i <= 9) {
        return static_cast<wchar_t>(L'0' + i);
    } else {
        return static_cast<wchar_t>(L'a' + (i-10));
    }
}

}

inline std::string to_string(uuid const& u)
{
    std::string result;
    result.reserve(36);

    std::size_t i=0;
    for (uuid::const_iterator it_data = u.begin(); it_data!=u.end(); ++it_data, ++i) {
        const size_t hi = ((*it_data) >> 4) & 0x0F;
        result += detail::to_char(hi);

        const size_t lo = (*it_data) & 0x0F;
        result += detail::to_char(lo);

        if (i == 3 || i == 5 || i == 7 || i == 9) {
            result += '-';
        }
    }
    return result;
}


inline std::wstring to_wstring(uuid const& u)
{
    std::wstring result;
    result.reserve(36);

    std::size_t i=0;
    for (uuid::const_iterator it_data = u.begin(); it_data!=u.end(); ++it_data, ++i) {
        const size_t hi = ((*it_data) >> 4) & 0x0F;
        result += detail::to_wchar(hi);

        const size_t lo = (*it_data) & 0x0F;
        result += detail::to_wchar(lo);

        if (i == 3 || i == 5 || i == 7 || i == 9) {
            result += L'-';
        }
    }
    return result;
}



}}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h" 2


# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h"
struct uuid_d {
  boost::uuids::uuid uuid;

  uuid_d() {
    boost::uuids::nil_generator gen;
    uuid = gen();
  }

  bool is_zero() const {
    return uuid.is_nil();
  }

  void generate_random() {
    std::random_device rng;
    boost::uuids::basic_random_generator gen(rng);
    uuid = gen();
  }

  bool parse(const char *s) {
    try {
      boost::uuids::string_generator gen;
      uuid = gen(s);
      return true;
    } catch (std::runtime_error& e) {
      return false;
    }
  }
  void print(char *s) const {
    memcpy(s, boost::uuids::to_string(uuid).c_str(), 37);
  }

 std::string to_string() const {
    return boost::uuids::to_string(uuid);
  }

  char *bytes() const {
    return (char*)uuid.data;
  }

  void encode(bufferlist& bl) const {
    ::encode_raw(uuid, bl);
  }

  void decode(bufferlist::const_iterator& p) const {
    ::decode_raw(uuid, p);
  }
};
inline void encode(const uuid_d &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(uuid_d &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

inline std::ostream& operator<<(std::ostream& out, const uuid_d& u) {
  char b[37];
  u.print(b);
  return out << b;
}

inline bool operator==(const uuid_d& l, const uuid_d& r) {
  return l.uuid == r.uuid;
}
inline bool operator!=(const uuid_d& l, const uuid_d& r) {
  return l.uuid != r.uuid;
}
inline bool operator<(const uuid_d& l, const uuid_d& r) {
  return l.to_string() < r.to_string();
}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2

# 1 "/usr/include/netinet/in.h" 1 3 4
# 23 "/usr/include/netinet/in.h" 3 4
# 1 "/usr/include/sys/socket.h" 1 3 4
# 24 "/usr/include/sys/socket.h" 3 4

# 24 "/usr/include/sys/socket.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 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/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 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
# 175 "/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;
# 176 "/usr/include/bits/socket.h" 2 3 4


struct sockaddr
  {
    sa_family_t sa_family;
    char sa_data[14];
  };
# 191 "/usr/include/bits/socket.h" 3 4
struct 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 [];

  };
# 305 "/usr/include/bits/socket.h" 3 4
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
          struct cmsghdr *__cmsg) throw ();




extern __inline __attribute__ ((__gnu_inline__)) struct cmsghdr *
__attribute__ ((__leaf__)) __cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) throw ()
{
  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))

    return (struct cmsghdr *) 0;

  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
          + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)));
  if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
     + __mhdr->msg_controllen)
      || ((unsigned char *) __cmsg + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
   > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))

    return (struct cmsghdr *) 0;
  return __cmsg;
}




enum
  {
    SCM_RIGHTS = 0x01


    , SCM_CREDENTIALS = 0x02


  };



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
# 355 "/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) throw ();





extern int socketpair (int __domain, int __type, int __protocol,
         int __fds[2]) throw ();


extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
     throw ();


extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
   socklen_t *__restrict __len) throw ();
# 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) throw ();






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);







extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
   int __flags);







extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
       unsigned int __vlen, int __flags);







extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);







extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
       unsigned int __vlen, int __flags,
       struct timespec *__tmo);






extern int getsockopt (int __fd, int __level, int __optname,
         void *__restrict __optval,
         socklen_t *__restrict __optlen) throw ();




extern int setsockopt (int __fd, int __level, int __optname,
         const void *__optval, socklen_t __optlen) throw ();





extern int listen (int __fd, int __n) throw ();
# 232 "/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);
# 250 "/usr/include/sys/socket.h" 3 4
extern int shutdown (int __fd, int __how) throw ();




extern int sockatmark (int __fd) throw ();







extern int isfdtype (int __fd, int __fdtype) throw ();





# 1 "/usr/include/bits/socket2.h" 1 3 4
# 23 "/usr/include/bits/socket2.h" 3 4
extern ssize_t __recv_chk (int __fd, void *__buf, size_t __n, size_t __buflen,
      int __flags);
extern ssize_t __recv_alias (int __fd, void *__buf, size_t __n, int __flags) __asm__ ("" "recv")
                          ;
extern ssize_t __recv_chk_warn (int __fd, void *__buf, size_t __n, size_t __buflen, int __flags) __asm__ ("" "__recv_chk")


     __attribute__((__warning__ ("recv called with bigger length than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) ssize_t
recv (int __fd, void *__buf, size_t __n, int __flags)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __recv_chk (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags);

      if (__n > __builtin_object_size (__buf, 0))
 return __recv_chk_warn (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags);
    }
  return __recv_alias (__fd, __buf, __n, __flags);
}

extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n,
          size_t __buflen, int __flags,
          struct sockaddr *__restrict __addr,
          socklen_t *__restrict __addr_len);
extern ssize_t __recvfrom_alias (int __fd, void *__restrict __buf, size_t __n, int __flags, struct sockaddr *__restrict __addr, socklen_t *__restrict __addr_len) __asm__ ("" "recvfrom")


                                                   ;
extern ssize_t __recvfrom_chk_warn (int __fd, void *__restrict __buf, size_t __n, size_t __buflen, int __flags, struct sockaddr *__restrict __addr, socklen_t *__restrict __addr_len) __asm__ ("" "__recvfrom_chk")




     __attribute__((__warning__ ("recvfrom called with bigger length than size of " "destination buffer")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) ssize_t
recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags,
   struct sockaddr *__restrict __addr, socklen_t *__restrict __addr_len)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __recvfrom_chk (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags,
          __addr, __addr_len);
      if (__n > __builtin_object_size (__buf, 0))
 return __recvfrom_chk_warn (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags,
        __addr, __addr_len);
    }
  return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
}
# 270 "/usr/include/sys/socket.h" 2 3 4


}
# 24 "/usr/include/netinet/in.h" 2 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
# 142 "/usr/include/bits/in.h" 3 4
struct ip_opts
  {
    struct in_addr ip_dst;
    char ip_opts[40];
  };


struct ip_mreqn
  {
    struct in_addr imr_multiaddr;
    struct in_addr imr_address;
    int imr_ifindex;
  };


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_SCTP = 132,

    IPPROTO_UDPLITE = 136,

    IPPROTO_MPLS = 137,

    IPPROTO_RAW = 255,

    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
  };
# 212 "/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;
# 238 "/usr/include/netinet/in.h" 3 4
struct 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 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_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];
};
# 375 "/usr/include/netinet/in.h" 3 4
extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
     throw () __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
     throw () __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
     throw () __attribute__ ((__const__));




# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 387 "/usr/include/netinet/in.h" 2 3 4
# 1 "/usr/include/bits/uintn-identity.h" 1 3 4
# 388 "/usr/include/netinet/in.h" 2 3 4
# 503 "/usr/include/netinet/in.h" 3 4
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();


extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
     throw ();
# 533 "/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)
     throw () __attribute__ ((__deprecated__));
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
         int __type) throw () __attribute__ ((__deprecated__));
extern int inet6_option_append (struct cmsghdr *__cmsg,
    const uint8_t *__typep, int __multx,
    int __plusy) throw () __attribute__ ((__deprecated__));
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
        int __multx, int __plusy)
     throw () __attribute__ ((__deprecated__));
extern int inet6_option_next (const struct cmsghdr *__cmsg,
         uint8_t **__tptrp)
     throw () __attribute__ ((__deprecated__));
extern int inet6_option_find (const struct cmsghdr *__cmsg,
         uint8_t **__tptrp, int __type)
     throw () __attribute__ ((__deprecated__));



extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
        uint8_t __type, socklen_t __len, uint8_t __align,
        void **__databufp) throw ();
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
     throw ();
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
         socklen_t __vallen) throw ();
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
      uint8_t *__typep, socklen_t *__lenp,
      void **__databufp) throw ();
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
      uint8_t __type, socklen_t *__lenp,
      void **__databufp) throw ();
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
         socklen_t __vallen) throw ();



extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
        int __segments) throw ();
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
extern int inet6_rth_segments (const void *__bp) throw ();
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
     throw ();





extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
    struct in_addr __group, uint32_t *__fmode,
    uint32_t *__numsrc, struct in_addr *__slist)
     throw ();


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)
     throw ();



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) throw ();


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) throw ();


}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
# 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;




    __off64_t l_start;
    __off64_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
# 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;
  };
# 353 "/usr/include/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/linux/falloc.h" 1 3 4
# 354 "/usr/include/bits/fcntl-linux.h" 2 3 4



struct file_handle
{
  unsigned int handle_bytes;
  int handle_type;

  unsigned char f_handle[0];
};





extern "C" {




extern __ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
    throw ();






extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
       unsigned int __flags);






extern __ssize_t vmsplice (int __fdout, const struct iovec *__iov,
      size_t __count, unsigned int __flags);





extern __ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
    __off64_t *__offout, size_t __len,
    unsigned int __flags);





extern __ssize_t tee (int __fdin, int __fdout, size_t __len,
        unsigned int __flags);
# 416 "/usr/include/bits/fcntl-linux.h" 3 4
extern int fallocate (int __fd, int __mode, __off64_t __offset, __off64_t __len) __asm__ ("" "fallocate64")

                     ;





extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
   __off64_t __len);




extern int name_to_handle_at (int __dfd, const char *__name,
         struct file_handle *__handle, int *__mnt_id,
         int __flags) throw ();





extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
         int __flags);



}
# 62 "/usr/include/bits/fcntl.h" 2 3 4
# 36 "/usr/include/fcntl.h" 2 3 4
# 78 "/usr/include/fcntl.h" 3 4
# 1 "/usr/include/bits/stat.h" 1 3 4
# 46 "/usr/include/bits/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;
# 91 "/usr/include/bits/stat.h" 3 4
    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 106 "/usr/include/bits/stat.h" 3 4
    __syscall_slong_t __glibc_reserved[3];
# 115 "/usr/include/bits/stat.h" 3 4
  };



struct stat64
  {
    __dev_t st_dev;

    __ino64_t st_ino;
    __nlink_t st_nlink;
    __mode_t st_mode;






    __uid_t st_uid;
    __gid_t st_gid;

    int __pad0;
    __dev_t st_rdev;
    __off_t st_size;





    __blksize_t st_blksize;
    __blkcnt64_t st_blocks;







    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 164 "/usr/include/bits/stat.h" 3 4
    __syscall_slong_t __glibc_reserved[3];



  };
# 79 "/usr/include/fcntl.h" 2 3 4
# 179 "/usr/include/fcntl.h" 3 4
extern int fcntl (int __fd, int __cmd, ...) __asm__ ("" "fcntl64");





extern int fcntl64 (int __fd, int __cmd, ...);
# 199 "/usr/include/fcntl.h" 3 4
extern int open (const char *__file, int __oflag, ...) __asm__ ("" "open64")
     __attribute__ ((__nonnull__ (1)));





extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 224 "/usr/include/fcntl.h" 3 4
extern int openat (int __fd, const char *__file, int __oflag, ...) __asm__ ("" "openat64")
                    __attribute__ ((__nonnull__ (2)));





extern int openat64 (int __fd, const char *__file, int __oflag, ...)
     __attribute__ ((__nonnull__ (2)));
# 245 "/usr/include/fcntl.h" 3 4
extern int creat (const char *__file, mode_t __mode) __asm__ ("" "creat64")
                  __attribute__ ((__nonnull__ (1)));





extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 292 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise (int __fd, __off64_t __offset, __off64_t __len, int __advise) throw () __asm__ ("" "posix_fadvise64")

                      ;





extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
       int __advise) throw ();
# 313 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate (int __fd, __off64_t __offset, __off64_t __len) __asm__ ("" "posix_fallocate64")

                           ;





extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);







# 1 "/usr/include/bits/fcntl2.h" 1 3 4
# 30 "/usr/include/bits/fcntl2.h" 3 4
extern int __open_2 (const char *__path, int __oflag) __asm__ ("" "__open64_2")
                     __attribute__ ((__nonnull__ (1)));
extern int __open_alias (const char *__path, int __oflag, ...) __asm__ ("" "open64")
                 __attribute__ ((__nonnull__ (1)));

extern void __open_too_many_args (void) __attribute__((__error__ ("open can be called either with 2 or 3 arguments, not more")))
                                                                  ;
extern void __open_missing_mode (void) __attribute__((__error__ ("open with O_CREAT or O_TMPFILE in second argument needs 3 arguments")))
                                                                            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
open (const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __open_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((((__oflag) & 0100) != 0 || ((__oflag) & (020000000 | 0200000)) == (020000000 | 0200000)) && __builtin_va_arg_pack_len () < 1)
 {
   __open_missing_mode ();
   return __open_2 (__path, __oflag);
 }
      return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __open_2 (__path, __oflag);

  return __open_alias (__path, __oflag, __builtin_va_arg_pack ());
}



extern int __open64_2 (const char *__path, int __oflag) __attribute__ ((__nonnull__ (1)));
extern int __open64_alias (const char *__path, int __oflag, ...) __asm__ ("" "open64")
                   __attribute__ ((__nonnull__ (1)));
extern void __open64_too_many_args (void) __attribute__((__error__ ("open64 can be called either with 2 or 3 arguments, not more")))
                                                                    ;
extern void __open64_missing_mode (void) __attribute__((__error__ ("open64 with O_CREAT or O_TMPFILE in second argument needs 3 arguments")))
                                                                              ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
open64 (const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __open64_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((((__oflag) & 0100) != 0 || ((__oflag) & (020000000 | 0200000)) == (020000000 | 0200000)) && __builtin_va_arg_pack_len () < 1)
 {
   __open64_missing_mode ();
   return __open64_2 (__path, __oflag);
 }
      return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __open64_2 (__path, __oflag);

  return __open64_alias (__path, __oflag, __builtin_va_arg_pack ());
}
# 104 "/usr/include/bits/fcntl2.h" 3 4
extern int __openat_2 (int __fd, const char *__path, int __oflag) __asm__ ("" "__openat64_2")

     __attribute__ ((__nonnull__ (2)));
extern int __openat_alias (int __fd, const char *__path, int __oflag, ...) __asm__ ("" "openat64")

     __attribute__ ((__nonnull__ (2)));

extern void __openat_too_many_args (void) __attribute__((__error__ ("openat can be called either with 3 or 4 arguments, not more")))
                                                                    ;
extern void __openat_missing_mode (void) __attribute__((__error__ ("openat with O_CREAT or O_TMPFILE in third argument needs 4 arguments")))
                                                                             ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
openat (int __fd, const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __openat_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((((__oflag) & 0100) != 0 || ((__oflag) & (020000000 | 0200000)) == (020000000 | 0200000)) && __builtin_va_arg_pack_len () < 1)
 {
   __openat_missing_mode ();
   return __openat_2 (__fd, __path, __oflag);
 }
      return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __openat_2 (__fd, __path, __oflag);

  return __openat_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
}



extern int __openat64_2 (int __fd, const char *__path, int __oflag)
     __attribute__ ((__nonnull__ (2)));
extern int __openat64_alias (int __fd, const char *__path, int __oflag, ...) __asm__ ("" "openat64")

     __attribute__ ((__nonnull__ (2)));
extern void __openat64_too_many_args (void) __attribute__((__error__ ("openat64 can be called either with 3 or 4 arguments, not more")))
                                                                      ;
extern void __openat64_missing_mode (void) __attribute__((__error__ ("openat64 with O_CREAT or O_TMPFILE in third argument needs 4 arguments")))
                                                                               ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
openat64 (int __fd, const char *__path, int __oflag, ...)
{
  if (__builtin_va_arg_pack_len () > 1)
    __openat64_too_many_args ();

  if (__builtin_constant_p (__oflag))
    {
      if ((((__oflag) & 0100) != 0 || ((__oflag) & (020000000 | 0200000)) == (020000000 | 0200000)) && __builtin_va_arg_pack_len () < 1)
 {
   __openat64_missing_mode ();
   return __openat64_2 (__fd, __path, __oflag);
 }
      return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
    }

  if (__builtin_va_arg_pack_len () < 1)
    return __openat64_2 (__fd, __path, __oflag);

  return __openat64_alias (__fd, __path, __oflag, __builtin_va_arg_pack ());
}
# 330 "/usr/include/fcntl.h" 2 3 4


}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h" 1
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/msgr.h" 1
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/msgr.h"

# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/msgr.h"
typedef __u32 ceph_seq_t;

static inline __s32 ceph_seq_cmp(__u32 a, __u32 b)
{
       return (__s32)a - (__s32)b;
}






struct ceph_entity_name {
 __u8 type;
 ceph_le64 num;
} __attribute__ ((packed));
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/msgr.h"
extern const char *ceph_entity_type_name(int type);




struct ceph_entity_addr {
 ceph_le32 type;
 ceph_le32 nonce;
 struct sockaddr_storage in_addr;
} __attribute__ ((packed));

struct ceph_entity_inst {
 struct ceph_entity_name name;
 struct ceph_entity_addr addr;
} __attribute__ ((packed));
# 137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/msgr.h"
struct ceph_msg_connect {
 ceph_le64 features;
 ceph_le32 host_type;
 ceph_le32 global_seq;
 ceph_le32 connect_seq;
 ceph_le32 protocol_version;
 ceph_le32 authorizer_protocol;
 ceph_le32 authorizer_len;
 __u8 flags;
} __attribute__ ((packed));

struct ceph_msg_connect_reply {
 __u8 tag;
 ceph_le64 features;
 ceph_le32 global_seq;
 ceph_le32 connect_seq;
 ceph_le32 protocol_version;
 ceph_le32 authorizer_len;
 __u8 flags;
} __attribute__ ((packed));







struct ceph_msg_header_old {
 ceph_le64 seq;
 ceph_le64 tid;
 ceph_le16 type;
 ceph_le16 priority;
 ceph_le16 version;

 ceph_le32 front_len;
 ceph_le32 middle_len;
 ceph_le32 data_len;
 ceph_le16 data_off;


 struct ceph_entity_inst src, orig_src;
 ceph_le32 reserved;
 ceph_le32 crc;
} __attribute__ ((packed));

struct ceph_msg_header {
 ceph_le64 seq;
 ceph_le64 tid;
 ceph_le16 type;
 ceph_le16 priority;
 ceph_le16 version;

 ceph_le32 front_len;
 ceph_le32 middle_len;
 ceph_le32 data_len;
 ceph_le16 data_off;


 struct ceph_entity_name src;


 ceph_le16 compat_version;
 ceph_le16 reserved;
 ceph_le32 crc;
} __attribute__ ((packed));

struct ceph_msg_header2 {
 ceph_le64 seq;
 ceph_le64 tid;
 ceph_le16 type;
 ceph_le16 priority;
 ceph_le16 version;

 ceph_le32 data_pre_padding_len;
 ceph_le16 data_off;


 ceph_le64 ack_seq;
 __u8 flags;

 ceph_le16 compat_version;
 ceph_le16 reserved;
} __attribute__ ((packed));
# 231 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/msgr.h"
struct ceph_msg_footer_old {
 ceph_le32 front_crc, middle_crc, data_crc;
 __u8 flags;
} __attribute__ ((packed));

struct ceph_msg_footer {
 ceph_le32 front_crc, middle_crc, data_crc;

 ceph_le64 sig;
 __u8 flags;
} __attribute__ ((packed));
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h" 1
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
struct ceph_fsid {
 unsigned char fsid[16];
};

static inline int ceph_fsid_compare(const struct ceph_fsid *a,
        const struct ceph_fsid *b)
{
 return memcmp(a, b, sizeof(*a));
}




typedef ceph_le64 ceph_snapid_t;




struct ceph_timespec {
 ceph_le32 tv_sec;
 ceph_le32 tv_nsec;
} __attribute__ ((packed));
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
struct ceph_pg {
 ceph_le16 preferred;
 ceph_le16 ps;
 ceph_le32 pool;
} __attribute__ ((packed));
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
static inline int ceph_stable_mod(int x, int b, int bmask)
{
 if ((x & bmask) < b)
  return x & bmask;
 else
  return x & (bmask >> 1);
}




struct ceph_object_layout {
 struct ceph_pg ol_pgid;
 ceph_le32 ol_stripe_unit;
} __attribute__ ((packed));




struct ceph_eversion {
 ceph_le32 epoch;
 ceph_le64 version;
} __attribute__ ((packed));
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
extern const char *ceph_osd_state_name(int s);
# 203 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
extern const char *ceph_release_name(int r);
extern int ceph_release_from_name(const char *s);
extern uint64_t ceph_release_features(int r);
extern int ceph_release_from_features(uint64_t features);
# 365 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
enum {

CEPH_OSD_OP_READ = ((0x1000 | 0x0200 | (1))), CEPH_OSD_OP_STAT = ((0x1000 | 0x0200 | (2))), CEPH_OSD_OP_MAPEXT = ((0x1000 | 0x0200 | (3))), CEPH_OSD_OP_CHECKSUM = ((0x1000 | 0x0200 | (31))), CEPH_OSD_OP_MASKTRUNC = ((0x1000 | 0x0200 | (4))), CEPH_OSD_OP_SPARSE_READ = ((0x1000 | 0x0200 | (5))), CEPH_OSD_OP_NOTIFY = ((0x1000 | 0x0200 | (6))), CEPH_OSD_OP_NOTIFY_ACK = ((0x1000 | 0x0200 | (7))), CEPH_OSD_OP_ASSERT_VER = ((0x1000 | 0x0200 | (8))), CEPH_OSD_OP_LIST_WATCHERS = ((0x1000 | 0x0200 | (9))), CEPH_OSD_OP_LIST_SNAPS = ((0x1000 | 0x0200 | (10))), CEPH_OSD_OP_SYNC_READ = ((0x1000 | 0x0200 | (11))), CEPH_OSD_OP_WRITE = ((0x2000 | 0x0200 | (1))), CEPH_OSD_OP_WRITEFULL = ((0x2000 | 0x0200 | (2))), CEPH_OSD_OP_TRUNCATE = ((0x2000 | 0x0200 | (3))), CEPH_OSD_OP_ZERO = ((0x2000 | 0x0200 | (4))), CEPH_OSD_OP_DELETE = ((0x2000 | 0x0200 | (5))), CEPH_OSD_OP_APPEND = ((0x2000 | 0x0200 | (6))), CEPH_OSD_OP_STARTSYNC = ((0x2000 | 0x0200 | (7))), CEPH_OSD_OP_SETTRUNC = ((0x2000 | 0x0200 | (8))), CEPH_OSD_OP_TRIMTRUNC = ((0x2000 | 0x0200 | (9))), CEPH_OSD_OP_TMAPUP = ((0x3000 | 0x0200 | (10))), CEPH_OSD_OP_TMAPPUT = ((0x2000 | 0x0200 | (11))), CEPH_OSD_OP_TMAPGET = ((0x1000 | 0x0200 | (12))), CEPH_OSD_OP_CREATE = ((0x2000 | 0x0200 | (13))), CEPH_OSD_OP_ROLLBACK = ((0x2000 | 0x0200 | (14))), CEPH_OSD_OP_WATCH = ((0x2000 | 0x0200 | (15))), CEPH_OSD_OP_OMAPGETKEYS = ((0x1000 | 0x0200 | (17))), CEPH_OSD_OP_OMAPGETVALS = ((0x1000 | 0x0200 | (18))), CEPH_OSD_OP_OMAPGETHEADER = ((0x1000 | 0x0200 | (19))), CEPH_OSD_OP_OMAPGETVALSBYKEYS = ((0x1000 | 0x0200 | (20))), CEPH_OSD_OP_OMAPSETVALS = ((0x2000 | 0x0200 | (21))), CEPH_OSD_OP_OMAPSETHEADER = ((0x2000 | 0x0200 | (22))), CEPH_OSD_OP_OMAPCLEAR = ((0x2000 | 0x0200 | (23))), CEPH_OSD_OP_OMAPRMKEYS = ((0x2000 | 0x0200 | (24))), CEPH_OSD_OP_OMAP_CMP = ((0x1000 | 0x0200 | (25))), CEPH_OSD_OP_COPY_FROM = ((0x2000 | 0x0200 | (26))), CEPH_OSD_OP_UNDIRTY = ((0x2000 | 0x0200 | (28))), CEPH_OSD_OP_ISDIRTY = ((0x1000 | 0x0200 | (29))), CEPH_OSD_OP_COPY_GET = ((0x1000 | 0x0200 | (30))), CEPH_OSD_OP_CACHE_FLUSH = ((0x8000 | 0x0200 | (31))), CEPH_OSD_OP_CACHE_EVICT = ((0x8000 | 0x0200 | (32))), CEPH_OSD_OP_CACHE_TRY_FLUSH = ((0x8000 | 0x0200 | (33))), CEPH_OSD_OP_TMAP2OMAP = ((0x3000 | 0x0200 | (34))), CEPH_OSD_OP_SETALLOCHINT = ((0x2000 | 0x0200 | (35))), CEPH_OSD_OP_CACHE_PIN = ((0x2000 | 0x0200 | (36))), CEPH_OSD_OP_CACHE_UNPIN = ((0x2000 | 0x0200 | (37))), CEPH_OSD_OP_WRITESAME = ((0x2000 | 0x0200 | (38))), CEPH_OSD_OP_CMPEXT = ((0x1000 | 0x0200 | (32))), CEPH_OSD_OP_SET_REDIRECT = ((0x2000 | 0x0200 | (39))), CEPH_OSD_OP_SET_CHUNK = ((0x2000 | 0x0200 | (40))), CEPH_OSD_OP_TIER_PROMOTE = ((0x2000 | 0x0200 | (41))), CEPH_OSD_OP_UNSET_MANIFEST = ((0x2000 | 0x0200 | (42))), CEPH_OSD_OP_GETXATTR = ((0x1000 | 0x0300 | (1))), CEPH_OSD_OP_GETXATTRS = ((0x1000 | 0x0300 | (2))), CEPH_OSD_OP_CMPXATTR = ((0x1000 | 0x0300 | (3))), CEPH_OSD_OP_SETXATTR = ((0x2000 | 0x0300 | (1))), CEPH_OSD_OP_SETXATTRS = ((0x2000 | 0x0300 | (2))), CEPH_OSD_OP_RESETXATTRS = ((0x2000 | 0x0300 | (3))), CEPH_OSD_OP_RMXATTR = ((0x2000 | 0x0300 | (4))), CEPH_OSD_OP_PULL = ((0x4000 | (1))), CEPH_OSD_OP_PUSH = ((0x4000 | (2))), CEPH_OSD_OP_BALANCEREADS = ((0x4000 | (3))), CEPH_OSD_OP_UNBALANCEREADS = ((0x4000 | (4))), CEPH_OSD_OP_SCRUB = ((0x4000 | (5))), CEPH_OSD_OP_SCRUB_RESERVE = ((0x4000 | (6))), CEPH_OSD_OP_SCRUB_UNRESERVE = ((0x4000 | (7))), CEPH_OSD_OP_SCRUB_MAP = ((0x4000 | (9))), CEPH_OSD_OP_CALL = ((0x1000 | 0x0400 | (1))), CEPH_OSD_OP_PGLS = ((0x1000 | 0x0500 | (1))), CEPH_OSD_OP_PGLS_FILTER = ((0x1000 | 0x0500 | (2))), CEPH_OSD_OP_PG_HITSET_LS = ((0x1000 | 0x0500 | (3))), CEPH_OSD_OP_PG_HITSET_GET = ((0x1000 | 0x0500 | (4))), CEPH_OSD_OP_PGNLS = ((0x1000 | 0x0500 | (5))), CEPH_OSD_OP_PGNLS_FILTER = ((0x1000 | 0x0500 | (6))), CEPH_OSD_OP_SCRUBLS = ((0x1000 | 0x0500 | (7))),

};

static inline int ceph_osd_op_type_data(int op)
{
 return (op & 0x0f00) == 0x0200;
}
static inline int ceph_osd_op_type_attr(int op)
{
 return (op & 0x0f00) == 0x0300;
}
static inline int ceph_osd_op_type_exec(int op)
{
 return (op & 0x0f00) == 0x0400;
}
static inline int ceph_osd_op_type_pg(int op)
{
 return (op & 0x0f00) == 0x0500;
}

static inline int ceph_osd_op_mode_subop(int op)
{
 return (op & 0xf000) == 0x4000;
}
static inline int ceph_osd_op_mode_read(int op)
{
 return (op & 0x1000) &&
  op != CEPH_OSD_OP_CALL;
}
static inline int ceph_osd_op_mode_modify(int op)
{
 return op & 0x2000;
}
static inline int ceph_osd_op_mode_cache(int op)
{
 return op & 0x8000;
}
static inline int ceph_osd_op_uses_extent(int op)
{
 switch(op) {
 case CEPH_OSD_OP_READ:
 case CEPH_OSD_OP_MAPEXT:
 case CEPH_OSD_OP_MASKTRUNC:
 case CEPH_OSD_OP_SPARSE_READ:
 case CEPH_OSD_OP_SYNC_READ:
 case CEPH_OSD_OP_WRITE:
 case CEPH_OSD_OP_WRITEFULL:
 case CEPH_OSD_OP_TRUNCATE:
 case CEPH_OSD_OP_ZERO:
 case CEPH_OSD_OP_APPEND:
 case CEPH_OSD_OP_TRIMTRUNC:
 case CEPH_OSD_OP_CMPEXT:
  return true;
 default:
  return false;
 }
}
# 436 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
extern const char *ceph_osd_op_name(int op);






enum {
 CEPH_OSD_FLAG_ACK = 0x0001,
 CEPH_OSD_FLAG_ONNVRAM = 0x0002,
 CEPH_OSD_FLAG_ONDISK = 0x0004,
 CEPH_OSD_FLAG_RETRY = 0x0008,
 CEPH_OSD_FLAG_READ = 0x0010,
 CEPH_OSD_FLAG_WRITE = 0x0020,
 CEPH_OSD_FLAG_ORDERSNAP = 0x0040,
 CEPH_OSD_FLAG_PEERSTAT_OLD = 0x0080,
 CEPH_OSD_FLAG_BALANCE_READS = 0x0100,
 CEPH_OSD_FLAG_PARALLELEXEC = 0x0200,
 CEPH_OSD_FLAG_PGOP = 0x0400,
 CEPH_OSD_FLAG_EXEC = 0x0800,
 CEPH_OSD_FLAG_EXEC_PUBLIC = 0x1000,
 CEPH_OSD_FLAG_LOCALIZE_READS = 0x2000,
 CEPH_OSD_FLAG_RWORDERED = 0x4000,
 CEPH_OSD_FLAG_IGNORE_CACHE = 0x8000,
 CEPH_OSD_FLAG_SKIPRWLOCKS = 0x10000,
 CEPH_OSD_FLAG_IGNORE_OVERLAY =0x20000,
 CEPH_OSD_FLAG_FLUSH = 0x40000,
 CEPH_OSD_FLAG_MAP_SNAP_CLONE =0x80000,

 CEPH_OSD_FLAG_ENFORCE_SNAPC =0x100000,

 CEPH_OSD_FLAG_REDIRECTED = 0x200000,
 CEPH_OSD_FLAG_KNOWN_REDIR = 0x400000,
 CEPH_OSD_FLAG_FULL_TRY = 0x800000,
 CEPH_OSD_FLAG_FULL_FORCE = 0x1000000,
 CEPH_OSD_FLAG_IGNORE_REDIRECT = 0x2000000,
};

enum {
 CEPH_OSD_OP_FLAG_EXCL = 0x1,
 CEPH_OSD_OP_FLAG_FAILOK = 0x2,
 CEPH_OSD_OP_FLAG_FADVISE_RANDOM = 0x4,
 CEPH_OSD_OP_FLAG_FADVISE_SEQUENTIAL = 0x8,
 CEPH_OSD_OP_FLAG_FADVISE_WILLNEED = 0x10,
 CEPH_OSD_OP_FLAG_FADVISE_DONTNEED = 0x20,
 CEPH_OSD_OP_FLAG_FADVISE_NOCACHE = 0x40,
 CEPH_OSD_OP_FLAG_WITH_REFERENCE = 0x80,
 CEPH_OSD_OP_FLAG_BYPASS_CLEAN_CACHE = 0x100,
};





enum {
 CEPH_OSD_CMPXATTR_OP_EQ = 1,
 CEPH_OSD_CMPXATTR_OP_NE = 2,
 CEPH_OSD_CMPXATTR_OP_GT = 3,
 CEPH_OSD_CMPXATTR_OP_GTE = 4,
 CEPH_OSD_CMPXATTR_OP_LT = 5,
 CEPH_OSD_CMPXATTR_OP_LTE = 6
};

enum {
 CEPH_OSD_CMPXATTR_MODE_STRING = 1,
 CEPH_OSD_CMPXATTR_MODE_U64 = 2
};

enum {
 CEPH_OSD_COPY_FROM_FLAG_FLUSH = 1,
 CEPH_OSD_COPY_FROM_FLAG_IGNORE_OVERLAY = 2,
 CEPH_OSD_COPY_FROM_FLAG_IGNORE_CACHE = 4,
 CEPH_OSD_COPY_FROM_FLAG_MAP_SNAP_CLONE = 8,

 CEPH_OSD_COPY_FROM_FLAG_RWORDERED = 16,
};

enum {
 CEPH_OSD_TMAP2OMAP_NULLOK = 1,
};

enum {
 CEPH_OSD_WATCH_OP_UNWATCH = 0,
 CEPH_OSD_WATCH_OP_LEGACY_WATCH = 1,


 CEPH_OSD_WATCH_OP_WATCH = 3,
 CEPH_OSD_WATCH_OP_RECONNECT = 5,
 CEPH_OSD_WATCH_OP_PING = 7,
};

enum {
 CEPH_OSD_CHECKSUM_OP_TYPE_XXHASH32 = 0,
 CEPH_OSD_CHECKSUM_OP_TYPE_XXHASH64 = 1,
 CEPH_OSD_CHECKSUM_OP_TYPE_CRC32C = 2
};

const char *ceph_osd_watch_op_name(int o);

enum {
 CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_WRITE = 1,
 CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_WRITE = 2,
 CEPH_OSD_ALLOC_HINT_FLAG_SEQUENTIAL_READ = 4,
 CEPH_OSD_ALLOC_HINT_FLAG_RANDOM_READ = 8,
 CEPH_OSD_ALLOC_HINT_FLAG_APPEND_ONLY = 16,
 CEPH_OSD_ALLOC_HINT_FLAG_IMMUTABLE = 32,
 CEPH_OSD_ALLOC_HINT_FLAG_SHORTLIVED = 64,
 CEPH_OSD_ALLOC_HINT_FLAG_LONGLIVED = 128,
 CEPH_OSD_ALLOC_HINT_FLAG_COMPRESSIBLE = 256,
 CEPH_OSD_ALLOC_HINT_FLAG_INCOMPRESSIBLE = 512,
};

const char *ceph_osd_alloc_hint_flag_name(int f);

enum {
 CEPH_OSD_BACKOFF_OP_BLOCK = 1,
 CEPH_OSD_BACKOFF_OP_ACK_BLOCK = 2,
 CEPH_OSD_BACKOFF_OP_UNBLOCK = 3,
};

const char *ceph_osd_backoff_op_name(int op);





struct ceph_osd_op {
 ceph_le16 op;
 ceph_le32 flags;
 union {
  struct {
   ceph_le64 offset, length;
   ceph_le64 truncate_size;
   ceph_le32 truncate_seq;
  } __attribute__ ((packed)) extent;
  struct {
   ceph_le32 name_len;
   ceph_le32 value_len;
   __u8 cmp_op;
   __u8 cmp_mode;
  } __attribute__ ((packed)) xattr;
  struct {
   __u8 class_len;
   __u8 method_len;
   __u8 argc;
   ceph_le32 indata_len;
  } __attribute__ ((packed)) cls;
  struct {
   ceph_le64 count;
   ceph_le32 start_epoch;
  } __attribute__ ((packed)) pgls;
         struct {
          ceph_le64 snapid;
         } __attribute__ ((packed)) snap;
  struct {
   ceph_le64 cookie;
   ceph_le64 ver;
   __u8 op;
   __u32 gen;
   __u32 timeout;
  } __attribute__ ((packed)) watch;
  struct {
   ceph_le64 cookie;
  } __attribute__ ((packed)) notify;
  struct {
   ceph_le64 unused;
   ceph_le64 ver;
  } __attribute__ ((packed)) assert_ver;
  struct {
   ceph_le64 offset, length;
   ceph_le64 src_offset;
  } __attribute__ ((packed)) clonerange;
  struct {
   ceph_le64 max;
  } __attribute__ ((packed)) copy_get;
  struct {
   ceph_le64 snapid;
   ceph_le64 src_version;
   __u8 flags;





   ceph_le32 src_fadvise_flags;
  } __attribute__ ((packed)) copy_from;
  struct {
   struct ceph_timespec stamp;
  } __attribute__ ((packed)) hit_set_get;
  struct {
   __u8 flags;
  } __attribute__ ((packed)) tmap2omap;
  struct {
   ceph_le64 expected_object_size;
   ceph_le64 expected_write_size;
   ceph_le32 flags;
  } __attribute__ ((packed)) alloc_hint;
  struct {
   ceph_le64 offset;
   ceph_le64 length;
   ceph_le64 data_length;
  } __attribute__ ((packed)) writesame;
  struct {
   ceph_le64 offset;
   ceph_le64 length;
   ceph_le32 chunk_size;
   __u8 type;
  } __attribute__ ((packed)) checksum;
 };
 ceph_le32 payload_len;
} __attribute__ ((packed));
# 656 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h"
static_assert(sizeof(ceph_osd_op) == (2+4+(2*8+8+4)+4),
              "sizeof(ceph_osd_op) breaks the compatibility");


struct ceph_osd_reply_head {
 ceph_le32 client_inc;
 ceph_le32 flags;
 struct ceph_object_layout layout;
 ceph_le32 osdmap_epoch;
 struct ceph_eversion reassert_version;

 ceph_le32 result;

 ceph_le32 object_len;
 ceph_le32 num_ops;
 struct ceph_osd_op ops[0];
} __attribute__ ((packed));
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h" 2
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
struct ceph_file_layout {

 ceph_le32 fl_stripe_unit;

 ceph_le32 fl_stripe_count;
 ceph_le32 fl_object_size;

 ceph_le32 fl_cas_hash;


 ceph_le32 fl_object_stripe_unit;


 ceph_le32 fl_unused;
 ceph_le32 fl_pg_pool;
} __attribute__ ((packed));



struct ceph_dir_layout {
 __u8 dl_dir_hash;
 __u8 dl_unused1;
 __u16 dl_unused2;
 __u32 dl_unused3;
} __attribute__ ((packed));
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
extern const char *ceph_con_mode_name(int con_mode);
# 178 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
enum {
 CEPH_WATCH_EVENT_NOTIFY = 1,
 CEPH_WATCH_EVENT_NOTIFY_COMPLETE = 2,
 CEPH_WATCH_EVENT_DISCONNECT = 3,
};

const char *ceph_watch_event_name(int o);


enum {
  POOL_OP_CREATE = 0x01,
  POOL_OP_DELETE = 0x02,
  POOL_OP_AUID_CHANGE = 0x03,
  POOL_OP_CREATE_SNAP = 0x11,
  POOL_OP_DELETE_SNAP = 0x12,
  POOL_OP_CREATE_UNMANAGED_SNAP = 0x21,
  POOL_OP_DELETE_UNMANAGED_SNAP = 0x22,
};

struct ceph_mon_request_header {
 ceph_le64 have_version;
 ceph_le16 session_mon;
 ceph_le64 session_mon_tid;
} __attribute__ ((packed));

struct ceph_mon_statfs {
 struct ceph_mon_request_header monhdr;
 struct ceph_fsid fsid;
} __attribute__ ((packed));

struct ceph_statfs {
 ceph_le64 kb, kb_used, kb_avail;
 ceph_le64 num_objects;
} __attribute__ ((packed));

struct ceph_mon_statfs_reply {
 struct ceph_fsid fsid;
 ceph_le64 version;
 struct ceph_statfs st;
} __attribute__ ((packed));

const char *ceph_pool_op_name(int op);

struct ceph_mon_poolop {
 struct ceph_mon_request_header monhdr;
 struct ceph_fsid fsid;
 ceph_le32 pool;
 ceph_le32 op;
 ceph_le64 __old_auid;
 ceph_le64 snapid;
 ceph_le32 name_len;
} __attribute__ ((packed));

struct ceph_mon_poolop_reply {
 struct ceph_mon_request_header monhdr;
 struct ceph_fsid fsid;
 ceph_le32 reply_code;
 ceph_le32 epoch;
 char has_data;
 char data[0];
} __attribute__ ((packed));

struct ceph_mon_unmanaged_snap {
 ceph_le64 snapid;
} __attribute__ ((packed));

struct ceph_osd_getmap {
 struct ceph_mon_request_header monhdr;
 struct ceph_fsid fsid;
 ceph_le32 start;
} __attribute__ ((packed));

struct ceph_mds_getmap {
 struct ceph_mon_request_header monhdr;
 struct ceph_fsid fsid;
} __attribute__ ((packed));

struct ceph_client_mount {
 struct ceph_mon_request_header monhdr;
} __attribute__ ((packed));



struct ceph_mon_subscribe_item {
 ceph_le64 start;
 __u8 flags;
} __attribute__ ((packed));

struct ceph_mon_subscribe_ack {
 ceph_le32 duration;
 struct ceph_fsid fsid;
} __attribute__ ((packed));
# 312 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
extern const char *ceph_mds_state_name(int s);
# 336 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
enum {
 CEPH_SESSION_REQUEST_OPEN,
 CEPH_SESSION_OPEN,
 CEPH_SESSION_REQUEST_CLOSE,
 CEPH_SESSION_CLOSE,
 CEPH_SESSION_REQUEST_RENEWCAPS,
 CEPH_SESSION_RENEWCAPS,
 CEPH_SESSION_STALE,
 CEPH_SESSION_RECALL_STATE,
 CEPH_SESSION_FLUSHMSG,
 CEPH_SESSION_FLUSHMSG_ACK,
 CEPH_SESSION_FORCE_RO,


 CEPH_SESSION_REJECT,
        CEPH_SESSION_REQUEST_FLUSH_MDLOG
};




extern const char *ceph_session_op_name(int op);

struct ceph_mds_session_head {
 ceph_le32 op;
 ceph_le64 seq;
 struct ceph_timespec stamp;
 ceph_le32 max_caps, max_leases;
} __attribute__ ((packed));
# 374 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
enum {
 CEPH_MDS_OP_LOOKUP = 0x00100,
 CEPH_MDS_OP_GETATTR = 0x00101,
 CEPH_MDS_OP_LOOKUPHASH = 0x00102,
 CEPH_MDS_OP_LOOKUPPARENT = 0x00103,
 CEPH_MDS_OP_LOOKUPINO = 0x00104,
 CEPH_MDS_OP_LOOKUPNAME = 0x00105,

 CEPH_MDS_OP_SETXATTR = 0x01105,
 CEPH_MDS_OP_RMXATTR = 0x01106,
 CEPH_MDS_OP_SETLAYOUT = 0x01107,
 CEPH_MDS_OP_SETATTR = 0x01108,
 CEPH_MDS_OP_SETFILELOCK= 0x01109,
 CEPH_MDS_OP_GETFILELOCK= 0x00110,
 CEPH_MDS_OP_SETDIRLAYOUT=0x0110a,

 CEPH_MDS_OP_MKNOD = 0x01201,
 CEPH_MDS_OP_LINK = 0x01202,
 CEPH_MDS_OP_UNLINK = 0x01203,
 CEPH_MDS_OP_RENAME = 0x01204,
 CEPH_MDS_OP_MKDIR = 0x01220,
 CEPH_MDS_OP_RMDIR = 0x01221,
 CEPH_MDS_OP_SYMLINK = 0x01222,

 CEPH_MDS_OP_CREATE = 0x01301,
 CEPH_MDS_OP_OPEN = 0x00302,
 CEPH_MDS_OP_READDIR = 0x00305,

 CEPH_MDS_OP_LOOKUPSNAP = 0x00400,
 CEPH_MDS_OP_MKSNAP = 0x01400,
 CEPH_MDS_OP_RMSNAP = 0x01401,
 CEPH_MDS_OP_LSSNAP = 0x00402,
 CEPH_MDS_OP_RENAMESNAP = 0x01403,


 CEPH_MDS_OP_FRAGMENTDIR= 0x01500,
 CEPH_MDS_OP_EXPORTDIR = 0x01501,
 CEPH_MDS_OP_FLUSH = 0x01502,
 CEPH_MDS_OP_ENQUEUE_SCRUB = 0x01503,
 CEPH_MDS_OP_REPAIR_FRAGSTATS = 0x01504,
 CEPH_MDS_OP_REPAIR_INODESTATS = 0x01505,
 CEPH_MDS_OP_UPGRADE_SNAPREALM = 0x01506
};

extern const char *ceph_mds_op_name(int op);
# 447 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
int ceph_flags_sys2wire(int flags);
# 470 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
union ceph_mds_request_args_legacy {
 struct {
  ceph_le32 mask;
 } __attribute__ ((packed)) getattr;
 struct {
  ceph_le32 mode;
  ceph_le32 uid;
  ceph_le32 gid;
  struct ceph_timespec mtime;
  struct ceph_timespec atime;
  ceph_le64 size, old_size;
  ceph_le32 mask;
 } __attribute__ ((packed)) setattr;
 struct {
  ceph_le32 frag;
  ceph_le32 max_entries;
  ceph_le32 max_bytes;
  ceph_le16 flags;
               ceph_le32 offset_hash;
 } __attribute__ ((packed)) readdir;
 struct {
  ceph_le32 mode;
  ceph_le32 rdev;
 } __attribute__ ((packed)) mknod;
 struct {
  ceph_le32 mode;
 } __attribute__ ((packed)) mkdir;
 struct {
  ceph_le32 flags;
  ceph_le32 mode;
  ceph_le32 stripe_unit;
  ceph_le32 stripe_count;
  ceph_le32 object_size;
  ceph_le32 pool;
  ceph_le32 mask;
  ceph_le64 old_size;
 } __attribute__ ((packed)) open;
 struct {
  ceph_le32 flags;
  ceph_le32 osdmap_epoch;
 } __attribute__ ((packed)) setxattr;
 struct {
  struct ceph_file_layout layout;
 } __attribute__ ((packed)) setlayout;
 struct {
  __u8 rule;
  __u8 type;
  ceph_le64 owner;
  ceph_le64 pid;
  ceph_le64 start;
  ceph_le64 length;
  __u8 wait;
 } __attribute__ ((packed)) filelock_change;
} __attribute__ ((packed));




struct ceph_mds_request_head_legacy {
 ceph_le64 oldest_client_tid;
 ceph_le32 mdsmap_epoch;
 ceph_le32 flags;
 __u8 num_retry, num_fwd;
 ceph_le16 num_releases;
 ceph_le32 op;
 ceph_le32 caller_uid, caller_gid;
 ceph_le64 ino;

 union ceph_mds_request_args_legacy args;
} __attribute__ ((packed));





union ceph_mds_request_args {
 struct {
  ceph_le32 mask;
 } __attribute__ ((packed)) getattr;
 struct {
  ceph_le32 mode;
  ceph_le32 uid;
  ceph_le32 gid;
  struct ceph_timespec mtime;
  struct ceph_timespec atime;
  ceph_le64 size, old_size;
  ceph_le32 mask;
  struct ceph_timespec btime;
 } __attribute__ ((packed)) setattr;
 struct {
  ceph_le32 frag;
  ceph_le32 max_entries;
  ceph_le32 max_bytes;
  ceph_le16 flags;
               ceph_le32 offset_hash;
 } __attribute__ ((packed)) readdir;
 struct {
  ceph_le32 mode;
  ceph_le32 rdev;
 } __attribute__ ((packed)) mknod;
 struct {
  ceph_le32 mode;
 } __attribute__ ((packed)) mkdir;
 struct {
  ceph_le32 flags;
  ceph_le32 mode;
  ceph_le32 stripe_unit;
  ceph_le32 stripe_count;
  ceph_le32 object_size;
  ceph_le32 pool;
  ceph_le32 mask;
  ceph_le64 old_size;
 } __attribute__ ((packed)) open;
 struct {
  ceph_le32 flags;
  ceph_le32 osdmap_epoch;
 } __attribute__ ((packed)) setxattr;
 struct {
  struct ceph_file_layout layout;
 } __attribute__ ((packed)) setlayout;
 struct {
  __u8 rule;
  __u8 type;
  ceph_le64 owner;
  ceph_le64 pid;
  ceph_le64 start;
  ceph_le64 length;
  __u8 wait;
 } __attribute__ ((packed)) filelock_change;
 struct {
  ceph_le32 mask;
  ceph_le64 snapid;
  ceph_le64 parent;
  ceph_le32 hash;
 } __attribute__ ((packed)) lookupino;
} __attribute__ ((packed));







struct ceph_mds_request_head {
 ceph_le16 version;
 ceph_le64 oldest_client_tid;
 ceph_le32 mdsmap_epoch;
 ceph_le32 flags;
 __u8 num_retry, num_fwd;
 ceph_le16 num_releases;
 ceph_le32 op;
 ceph_le32 caller_uid, caller_gid;
 ceph_le64 ino;

 union ceph_mds_request_args args;
} __attribute__ ((packed));


struct ceph_mds_request_release {
 ceph_le64 ino, cap_id;
 ceph_le32 caps, wanted;
 ceph_le32 seq, issue_seq, mseq;
 ceph_le32 dname_seq;
 ceph_le32 dname_len;
} __attribute__ ((packed));

static inline void
copy_from_legacy_head(struct ceph_mds_request_head *head,
   struct ceph_mds_request_head_legacy *legacy)
{
 memcpy(&(head->oldest_client_tid), legacy, sizeof(*legacy));
}

static inline void
copy_to_legacy_head(struct ceph_mds_request_head_legacy *legacy,
   struct ceph_mds_request_head *head)
{
 memcpy(legacy, &(head->oldest_client_tid), sizeof(*legacy));
}


struct ceph_mds_reply_head {
 ceph_le32 op;
 ceph_le32 result;
 ceph_le32 mdsmap_epoch;
 __u8 safe;
 __u8 is_dentry, is_target;

} __attribute__ ((packed));


struct ceph_frag_tree_split {
 ceph_le32 frag;
 ceph_le32 by;
} __attribute__ ((packed));

struct ceph_frag_tree_head {
 ceph_le32 nsplits;
 struct ceph_frag_tree_split splits[];
} __attribute__ ((packed));


struct ceph_mds_reply_cap {
 ceph_le32 caps, wanted;
 ceph_le64 cap_id;
 ceph_le32 seq, mseq;
 ceph_le64 realm;
 __u8 flags;
} __attribute__ ((packed));





struct ceph_mds_reply_lease {
 ceph_le16 mask;
 ceph_le32 duration_ms;
 ceph_le32 seq;
} __attribute__ ((packed));

struct ceph_mds_reply_dirfrag {
 ceph_le32 frag;
 ceph_le32 auth;
 ceph_le32 ndist;
 ceph_le32 dist[];
} __attribute__ ((packed));
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
struct ceph_filelock {
 ceph_le64 start;
 ceph_le64 length;
 ceph_le64 client;
 ceph_le64 owner;
 ceph_le64 pid;
 __u8 type;
} __attribute__ ((packed));
# 724 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
int ceph_flags_to_mode(int flags);
# 815 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_fs.h"
int ceph_caps_for_mode(int mode);

enum {
 CEPH_CAP_OP_GRANT,
 CEPH_CAP_OP_REVOKE,
 CEPH_CAP_OP_TRUNC,
 CEPH_CAP_OP_EXPORT,
 CEPH_CAP_OP_IMPORT,
 CEPH_CAP_OP_UPDATE,
 CEPH_CAP_OP_DROP,
 CEPH_CAP_OP_FLUSH,
 CEPH_CAP_OP_FLUSH_ACK,
 CEPH_CAP_OP_FLUSHSNAP,
 CEPH_CAP_OP_FLUSHSNAP_ACK,
 CEPH_CAP_OP_RELEASE,
 CEPH_CAP_OP_RENEW,
};

extern const char *ceph_cap_op_name(int op);


struct ceph_mds_cap_peer {
 ceph_le64 cap_id;
 ceph_le32 seq;
 ceph_le32 mseq;
 ceph_le32 mds;
 __u8 flags;
} __attribute__ ((packed));




struct ceph_mds_caps_head {
 ceph_le32 op;
 ceph_le64 ino, realm;
 ceph_le64 cap_id;
 ceph_le32 seq, issue_seq;
 ceph_le32 caps, wanted, dirty;
 ceph_le32 migrate_seq;
 ceph_le64 snap_follows;
 ceph_le32 snap_trace_len;


 ceph_le32 uid, gid, mode;


 ceph_le32 nlink;


 ceph_le32 xattr_len;
 ceph_le64 xattr_version;
} __attribute__ ((packed));

struct ceph_mds_caps_body_legacy {
 union {

  struct {

   ceph_le64 size, max_size, truncate_size;
   ceph_le32 truncate_seq;
   struct ceph_timespec mtime, atime, ctime;
   struct ceph_file_layout layout;
   ceph_le32 time_warp_seq;
  };

  struct ceph_mds_cap_peer peer;
 };
} __attribute__ ((packed));


struct ceph_mds_cap_release {
 ceph_le32 num;
} __attribute__ ((packed));

struct ceph_mds_cap_item {
 ceph_le64 ino;
 ceph_le64 cap_id;
 ceph_le32 migrate_seq, seq;
} __attribute__ ((packed));






extern const char *ceph_lease_op_name(int o);


struct ceph_mds_lease {
 __u8 action;
 ceph_le16 mask;
 ceph_le64 ino;
 ceph_le64 first, last;
 ceph_le32 seq;
 ceph_le32 duration_ms;
} __attribute__ ((packed));



struct ceph_mds_cap_reconnect {
 ceph_le64 cap_id;
 ceph_le32 wanted;
 ceph_le32 issued;
 ceph_le64 snaprealm;
 ceph_le64 pathbase;
 ceph_le32 flock_len;
} __attribute__ ((packed));


struct ceph_mds_cap_reconnect_v1 {
 ceph_le64 cap_id;
 ceph_le32 wanted;
 ceph_le32 issued;
 ceph_le64 size;
 struct ceph_timespec mtime, atime;
 ceph_le64 snaprealm;
 ceph_le64 pathbase;
} __attribute__ ((packed));

struct ceph_mds_snaprealm_reconnect {
 ceph_le64 ino;
 ceph_le64 seq;
 ceph_le64 parent;
} __attribute__ ((packed));




enum {
 CEPH_SNAP_OP_UPDATE,
 CEPH_SNAP_OP_CREATE,
 CEPH_SNAP_OP_DESTROY,
 CEPH_SNAP_OP_SPLIT,
};

extern const char *ceph_snap_op_name(int o);


struct ceph_mds_snap_head {
 ceph_le32 op;
 ceph_le64 split;
 ceph_le32 num_split_inos;
 ceph_le32 num_split_realms;
 ceph_le32 trace_len;
} __attribute__ ((packed));





struct ceph_mds_snap_realm {
 ceph_le64 ino;
 ceph_le64 created;
 ceph_le64 parent;
 ceph_le64 parent_since;
 ceph_le64 seq;
 ceph_le32 num_snaps;
 ceph_le32 num_prior_parent_snaps;
} __attribute__ ((packed));
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_frag.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_frag.h"
static inline __u32 ceph_frag_make(__u32 b, __u32 v)
{
 return (b << 24) |
  (v & (0xffffffu << (24-b)) & 0xffffffu);
}
static inline __u32 ceph_frag_bits(__u32 f)
{
 return f >> 24;
}
static inline __u32 ceph_frag_value(__u32 f)
{
 return f & 0xffffffu;
}
static inline __u32 ceph_frag_mask(__u32 f)
{
 return (0xffffffu << (24-ceph_frag_bits(f))) & 0xffffffu;
}
static inline __u32 ceph_frag_mask_shift(__u32 f)
{
 return 24 - ceph_frag_bits(f);
}

static inline int ceph_frag_contains_value(__u32 f, __u32 v)
{
 return (v & ceph_frag_mask(f)) == ceph_frag_value(f);
}
static inline int ceph_frag_contains_frag(__u32 f, __u32 sub)
{

 return ceph_frag_bits(sub) >= ceph_frag_bits(f) &&
        (ceph_frag_value(sub) & ceph_frag_mask(f)) == ceph_frag_value(f);
}

static inline __u32 ceph_frag_parent(__u32 f)
{
 return ceph_frag_make(ceph_frag_bits(f) - 1,
    ceph_frag_value(f) & (ceph_frag_mask(f) << 1));
}
static inline int ceph_frag_is_left_child(__u32 f)
{
 return ceph_frag_bits(f) > 0 &&
  (ceph_frag_value(f) & (0x1000000 >> ceph_frag_bits(f))) == 0;
}
static inline int ceph_frag_is_right_child(__u32 f)
{
 return ceph_frag_bits(f) > 0 &&
  (ceph_frag_value(f) & (0x1000000 >> ceph_frag_bits(f))) == 1;
}
static inline __u32 ceph_frag_sibling(__u32 f)
{
 return ceph_frag_make(ceph_frag_bits(f),
        ceph_frag_value(f) ^ (0x1000000 >> ceph_frag_bits(f)));
}
static inline __u32 ceph_frag_left_child(__u32 f)
{
 return ceph_frag_make(ceph_frag_bits(f)+1, ceph_frag_value(f));
}
static inline __u32 ceph_frag_right_child(__u32 f)
{
 return ceph_frag_make(ceph_frag_bits(f)+1,
       ceph_frag_value(f) | (0x1000000 >> (1+ceph_frag_bits(f))));
}
static inline __u32 ceph_frag_make_child(__u32 f, int by, int i)
{
 int newbits = ceph_frag_bits(f) + by;
 return ceph_frag_make(newbits,
    ceph_frag_value(f) | (i << (24 - newbits)));
}
static inline int ceph_frag_is_leftmost(__u32 f)
{
 return ceph_frag_value(f) == 0;
}
static inline int ceph_frag_is_rightmost(__u32 f)
{
 return ceph_frag_value(f) == ceph_frag_mask(f);
}
static inline __u32 ceph_frag_next(__u32 f)
{
 return ceph_frag_make(ceph_frag_bits(f),
    ceph_frag_value(f) + (0x1000000 >> ceph_frag_bits(f)));
}





int ceph_frag_compare(__u32 a, __u32 b);
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rbd_types.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rbd_types.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 1
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rbd_types.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rbd/features.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rbd_types.h" 2
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rbd_types.h"
struct rbd_info {
 ceph_le64 max_id;
} __attribute__ ((packed));

struct rbd_obj_snap_ondisk {
 ceph_le64 id;
 ceph_le64 image_size;
} __attribute__((packed));

struct rbd_obj_header_ondisk {
 char text[40];
 char block_name[24];
 char signature[4];
 char version[8];
 struct {
  __u8 order;
  __u8 crypt_type;
  __u8 comp_type;
  __u8 unused;
 } __attribute__((packed)) options;
 ceph_le64 image_size;
 ceph_le64 snap_seq;
 ceph_le32 snap_count;
 ceph_le32 reserved;
 ceph_le64 snap_names_len;
 struct rbd_obj_snap_ondisk snaps[0];
} __attribute__((packed));

enum {
  RBD_PROTECTION_STATUS_UNPROTECTED = 0,
  RBD_PROTECTION_STATUS_UNPROTECTING = 1,
  RBD_PROTECTION_STATUS_PROTECTED = 2,
  RBD_PROTECTION_STATUS_LAST = 3
};
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2







extern "C" {


# 1 "/usr/include/sys/stat.h" 1 3 4
# 99 "/usr/include/sys/stat.h" 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
# 213 "/usr/include/sys/stat.h" 3 4
extern int stat (const char *__restrict __file, struct stat *__restrict __buf) throw () __asm__ ("" "stat64")

     __attribute__ ((__nonnull__ (1, 2)));
extern int fstat (int __fd, struct stat *__buf) throw () __asm__ ("" "fstat64")
     __attribute__ ((__nonnull__ (2)));






extern int stat64 (const char *__restrict __file,
     struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
# 239 "/usr/include/sys/stat.h" 3 4
extern int fstatat (int __fd, const char *__restrict __file, struct stat *__restrict __buf, int __flag) throw () __asm__ ("" "fstatat64")


                 __attribute__ ((__nonnull__ (2, 3)));






extern int fstatat64 (int __fd, const char *__restrict __file,
        struct stat64 *__restrict __buf, int __flag)
     throw () __attribute__ ((__nonnull__ (2, 3)));
# 263 "/usr/include/sys/stat.h" 3 4
extern int lstat (const char *__restrict __file, struct stat *__restrict __buf) throw () __asm__ ("" "lstat64")


     __attribute__ ((__nonnull__ (1, 2)));





extern int lstat64 (const char *__restrict __file,
      struct stat64 *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern int chmod (const char *__file, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int lchmod (const char *__file, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));




extern int fchmod (int __fd, __mode_t __mode) throw ();





extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
       int __flag)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));






extern __mode_t umask (__mode_t __mask) throw ();




extern __mode_t getumask (void) throw ();



extern int mkdir (const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (2)));






extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mknodat (int __fd, const char *__path, __mode_t __mode,
      __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));





extern int mkfifo (const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (2)));





extern int utimensat (int __fd, const char *__path,
        const struct timespec __times[2],
        int __flags)
     throw () __attribute__ ((__nonnull__ (2)));




extern int futimens (int __fd, const struct timespec __times[2]) throw ();
# 406 "/usr/include/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) throw () __asm__ ("" "__fxstat64")

     __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename, struct stat *__stat_buf) throw () __asm__ ("" "__xstat64")

     __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename, struct stat *__stat_buf) throw () __asm__ ("" "__lxstat64")

     __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, const char *__filename, struct stat *__stat_buf, int __flag) throw () __asm__ ("" "__fxstatat64")


                    __attribute__ ((__nonnull__ (3, 4)));
# 428 "/usr/include/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
     throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
        struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
         struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
    struct stat64 *__stat_buf, int __flag)
     throw () __attribute__ ((__nonnull__ (3, 4)));

extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
       __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));

extern int __xmknodat (int __ver, int __fd, const char *__path,
         __mode_t __mode, __dev_t *__dev)
     throw () __attribute__ ((__nonnull__ (3, 5)));


# 1 "/usr/include/bits/statx.h" 1 3 4
# 31 "/usr/include/bits/statx.h" 3 4
# 1 "/usr/include/linux/stat.h" 1 3 4
# 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 __spare2[14];

};
# 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
# 53 "/usr/include/bits/statx-generic.h" 3 4
extern "C" {


int statx (int __dirfd, const char *__restrict __path, int __flags,
           unsigned int __mask, struct statx *__restrict __buf)
  throw () __attribute__ ((__nonnull__ (2, 5)));

}
# 40 "/usr/include/bits/statx.h" 2 3 4
# 447 "/usr/include/sys/stat.h" 2 3 4





extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) stat (const char *__path, struct stat *__statbuf) throw ()
{
  return __xstat (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) lstat (const char *__path, struct stat *__statbuf) throw ()
{
  return __lxstat (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstat (int __fd, struct stat *__statbuf) throw ()
{
  return __fxstat (1, __fd, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstatat (int __fd, const char *__filename, struct stat *__statbuf, int __flag) throw ()

{
  return __fxstatat (1, __fd, __filename, __statbuf, __flag);
}



extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev) throw ()
{
  return __xmknod (0, __path, __mode, &__dev);
}



extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) mknodat (int __fd, const char *__path, __mode_t __mode, __dev_t __dev) throw ()

{
  return __xmknodat (0, __fd, __path, __mode, &__dev);
}





extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) stat64 (const char *__path, struct stat64 *__statbuf) throw ()
{
  return __xstat64 (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) lstat64 (const char *__path, struct stat64 *__statbuf) throw ()
{
  return __lxstat64 (1, __path, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstat64 (int __fd, struct stat64 *__statbuf) throw ()
{
  return __fxstat64 (1, __fd, __statbuf);
}


extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) fstatat64 (int __fd, const char *__filename, struct stat64 *__statbuf, int __flag) throw ()

{
  return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
}






}
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/statlite.h" 1






# 6 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/statlite.h"
extern "C" {





# 1 "/usr/include/dirent.h" 1 3 4
# 27 "/usr/include/dirent.h" 3 4

# 27 "/usr/include/dirent.h" 3 4
extern "C" {
# 61 "/usr/include/dirent.h" 3 4
# 1 "/usr/include/bits/dirent.h" 1 3 4
# 22 "/usr/include/bits/dirent.h" 3 4
struct dirent
  {




    __ino64_t d_ino;
    __off64_t d_off;

    unsigned short int d_reclen;
    unsigned char d_type;
    char d_name[256];
  };


struct dirent64
  {
    __ino64_t d_ino;
    __off64_t d_off;
    unsigned short int d_reclen;
    unsigned char d_type;
    char d_name[256];
  };
# 62 "/usr/include/dirent.h" 2 3 4
# 97 "/usr/include/dirent.h" 3 4
enum
  {
    DT_UNKNOWN = 0,

    DT_FIFO = 1,

    DT_CHR = 2,

    DT_DIR = 4,

    DT_BLK = 6,

    DT_REG = 8,

    DT_LNK = 10,

    DT_SOCK = 12,

    DT_WHT = 14

  };
# 127 "/usr/include/dirent.h" 3 4
typedef struct __dirstream DIR;






extern DIR *opendir (const char *__name) __attribute__ ((__nonnull__ (1)));






extern DIR *fdopendir (int __fd);







extern int closedir (DIR *__dirp) __attribute__ ((__nonnull__ (1)));
# 165 "/usr/include/dirent.h" 3 4
extern struct dirent *readdir (DIR *__dirp) __asm__ ("" "readdir64")
     __attribute__ ((__nonnull__ (1)));






extern struct dirent64 *readdir64 (DIR *__dirp) __attribute__ ((__nonnull__ (1)));
# 189 "/usr/include/dirent.h" 3 4
extern int readdir_r (DIR *__restrict __dirp, struct dirent *__restrict __entry, struct dirent **__restrict __result) __asm__ ("" "readdir64_r")




  __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__deprecated__));






extern int readdir64_r (DIR *__restrict __dirp,
   struct dirent64 *__restrict __entry,
   struct dirent64 **__restrict __result)
  __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__deprecated__));




extern void rewinddir (DIR *__dirp) throw () __attribute__ ((__nonnull__ (1)));





extern void seekdir (DIR *__dirp, long int __pos) throw () __attribute__ ((__nonnull__ (1)));


extern long int telldir (DIR *__dirp) throw () __attribute__ ((__nonnull__ (1)));





extern int dirfd (DIR *__dirp) throw () __attribute__ ((__nonnull__ (1)));
# 245 "/usr/include/dirent.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 246 "/usr/include/dirent.h" 2 3 4
# 263 "/usr/include/dirent.h" 3 4
extern int scandir (const char *__restrict __dir, struct dirent ***__restrict __namelist, int (*__selector) (const struct dirent *), int (*__cmp) (const struct dirent **, const struct dirent **)) __asm__ ("" "scandir64")





                    __attribute__ ((__nonnull__ (1, 2)));
# 278 "/usr/include/dirent.h" 3 4
extern int scandir64 (const char *__restrict __dir,
        struct dirent64 ***__restrict __namelist,
        int (*__selector) (const struct dirent64 *),
        int (*__cmp) (const struct dirent64 **,
        const struct dirent64 **))
     __attribute__ ((__nonnull__ (1, 2)));
# 301 "/usr/include/dirent.h" 3 4
extern int scandirat (int __dfd, const char *__restrict __dir, struct dirent ***__restrict __namelist, int (*__selector) (const struct dirent *), int (*__cmp) (const struct dirent **, const struct dirent **)) __asm__ ("" "scandirat64")





                      __attribute__ ((__nonnull__ (2, 3)));







extern int scandirat64 (int __dfd, const char *__restrict __dir,
   struct dirent64 ***__restrict __namelist,
   int (*__selector) (const struct dirent64 *),
   int (*__cmp) (const struct dirent64 **,
          const struct dirent64 **))
     __attribute__ ((__nonnull__ (2, 3)));
# 330 "/usr/include/dirent.h" 3 4
extern int alphasort (const struct dirent **__e1, const struct dirent **__e2) throw () __asm__ ("" "alphasort64")


                   __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern int alphasort64 (const struct dirent64 **__e1,
   const struct dirent64 **__e2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 359 "/usr/include/dirent.h" 3 4
extern __ssize_t getdirentries (int __fd, char *__restrict __buf, size_t __nbytes, __off64_t *__restrict __basep) throw () __asm__ ("" "getdirentries64")



                      __attribute__ ((__nonnull__ (2, 4)));






extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
      size_t __nbytes,
      __off64_t *__restrict __basep)
     throw () __attribute__ ((__nonnull__ (2, 4)));
# 385 "/usr/include/dirent.h" 3 4
extern int versionsort (const struct dirent **__e1, const struct dirent **__e2) throw () __asm__ ("" "versionsort64")



     __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern int versionsort64 (const struct dirent64 **__e1,
     const struct dirent64 **__e2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



}

# 1 "/usr/include/bits/dirent_ext.h" 1 3 4
# 23 "/usr/include/bits/dirent_ext.h" 3 4
extern "C" {





extern __ssize_t getdents64 (int __fd, void *__buffer, size_t __length)
  throw () __attribute__ ((__nonnull__ (2)));


}
# 405 "/usr/include/dirent.h" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/statlite.h" 2


# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/statlite.h"
struct statlite {
  dev_t st_dev;
  ino_t st_ino;
  mode_t st_mode;
  nlink_t st_nlink;
  uid_t st_uid;
  gid_t st_gid;
  dev_t st_rdev;
  unsigned long st_litemask;


  off_t st_size;
  blksize_t st_blksize;
  blkcnt_t st_blocks;
  struct timespec st_atim;
  struct timespec st_mtim;
  struct timespec st_ctim;



};
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/statlite.h"
struct dirent_plus {
 struct dirent d_dirent;
 struct stat d_stat;
 int d_stat_err;
};
struct dirent_lite {
 struct dirent d_dirent;
 struct statlite d_stat;
 int d_stat_err;
};

}
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
}
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/object.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/object.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/object.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/hash.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/hash.h"
template <class _Key> struct rjhash { };

inline uint64_t rjhash64(uint64_t key) {
  key = (~key) + (key << 21);
  key = key ^ (key >> 24);
  key = (key + (key << 3)) + (key << 8);
  key = key ^ (key >> 14);
  key = (key + (key << 2)) + (key << 4);
  key = key ^ (key >> 28);
  key = key + (key << 31);
  return key;
}

inline uint32_t rjhash32(uint32_t a) {
  a = (a+0x7ed55d16) + (a<<12);
  a = (a^0xc761c23c) ^ (a>>19);
  a = (a+0x165667b1) + (a<<5);
  a = (a+0xd3a2646c) ^ (a<<9);
  a = (a+0xfd7046c5) + (a<<3);
  a = (a^0xb55a4f09) ^ (a>>16);
  return a;
}


template<> struct rjhash<uint32_t> {
  inline size_t operator()(const uint32_t x) const {
    return rjhash32(x);
  }
};

template<> struct rjhash<uint64_t> {
  inline size_t operator()(const uint64_t x) const {
    return rjhash64(x);
  }
};
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/object.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_hash.h" 1






extern unsigned ceph_str_hash_linux(const char *s, unsigned len);
extern unsigned ceph_str_hash_rjenkins(const char *s, unsigned len);

extern unsigned ceph_str_hash(int type, const char *s, unsigned len);
extern const char *ceph_str_hash_name(int type);
extern bool ceph_str_hash_valid(int type);
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/object.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/cmp.h" 1
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/object.h" 2

using namespace std;

struct object_t {
  string name;

  object_t() {}

  object_t(const char *s) : name(s) {}

  object_t(const string& s) : name(s) {}

  void swap(object_t& o) {
    name.swap(o.name);
  }
  void clear() {
    name.clear();
  }

  void encode(bufferlist &bl) const {
    using ceph::encode;
    encode(name, bl);
  }
  void decode(bufferlist::const_iterator &bl) {
    using ceph::decode;
    decode(name, bl);
  }
};
inline void encode(const object_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(object_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

inline bool operator==(const object_t& l, const object_t& r) {
  return l.name == r.name;
}
inline bool operator!=(const object_t& l, const object_t& r) {
  return l.name != r.name;
}
inline bool operator>(const object_t& l, const object_t& r) {
  return l.name > r.name;
}
inline bool operator<(const object_t& l, const object_t& r) {
  return l.name < r.name;
}
inline bool operator>=(const object_t& l, const object_t& r) {
  return l.name >= r.name;
}
inline bool operator<=(const object_t& l, const object_t& r) {
  return l.name <= r.name;
}
inline ostream& operator<<(ostream& out, const object_t& o) {
  return out << o.name;
}

namespace std {
  template<> struct hash<object_t> {
    size_t operator()(const object_t& r) const {


      return ceph_str_hash_linux(r.name.c_str(), r.name.length());
    }
  };
}


struct file_object_t {
  uint64_t ino, bno;
  mutable char buf[34];

  file_object_t(uint64_t i=0, uint64_t b=0) : ino(i), bno(b) {
    buf[0] = 0;
  }

  const char *c_str() const {
    if (!buf[0])
      snprintf(buf, sizeof(buf), "%llx.%08llx", (long long unsigned)ino, (long long unsigned)bno);
    return buf;
  }

  operator object_t() {
    return object_t(c_str());
  }
};





struct snapid_t {
  uint64_t val;

  snapid_t(uint64_t v=0) : val(v) {}
  snapid_t operator+=(snapid_t o) { val += o.val; return *this; }
  snapid_t operator++() { ++val; return *this; }
  operator uint64_t() const { return val; }
};

inline void encode(snapid_t i, bufferlist &bl) { encode(i.val, bl); }
inline void decode(snapid_t &i, bufferlist::const_iterator &p) { decode(i.val, p); }

template<>
struct denc_traits<snapid_t> {
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = true;
  static constexpr bool need_contiguous = true;
  static void bound_encode(const snapid_t& o, size_t& p) {
    denc(o.val, p);
  }
  static void encode(const snapid_t &o, buffer::list::contiguous_appender& p) {
    denc(o.val, p);
  }
  static void decode(snapid_t& o, buffer::ptr::const_iterator &p) {
    denc(o.val, p);
  }
};

inline ostream& operator<<(ostream& out, const snapid_t& s) {
  if (s == ((__u64)(-2)))
    return out << "head";
  else if (s == ((__u64)(-1)))
    return out << "snapdir";
  else
    return out << hex << s.val << dec;
}


struct sobject_t {
  object_t oid;
  snapid_t snap;

  sobject_t() : snap(0) {}
  sobject_t(object_t o, snapid_t s) : oid(o), snap(s) {}

  void swap(sobject_t& o) {
    oid.swap(o.oid);
    snapid_t t = snap;
    snap = o.snap;
    o.snap = t;
  }

  void encode(bufferlist& bl) const {
    using ceph::encode;
    encode(oid, bl);
    encode(snap, bl);
  }
  void decode(bufferlist::const_iterator& bl) {
    using ceph::decode;
    decode(oid, bl);
    decode(snap, bl);
  }
};
inline void encode(const sobject_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(sobject_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

inline bool operator==(const sobject_t &l, const sobject_t &r) {
  return l.oid == r.oid && l.snap == r.snap;
}
inline bool operator!=(const sobject_t &l, const sobject_t &r) {
  return l.oid != r.oid || l.snap != r.snap;
}
inline bool operator>(const sobject_t &l, const sobject_t &r) {
  return l.oid > r.oid || (l.oid == r.oid && l.snap > r.snap);
}
inline bool operator<(const sobject_t &l, const sobject_t &r) {
  return l.oid < r.oid || (l.oid == r.oid && l.snap < r.snap);
}
inline bool operator>=(const sobject_t &l, const sobject_t &r) {
  return l.oid > r.oid || (l.oid == r.oid && l.snap >= r.snap);
}
inline bool operator<=(const sobject_t &l, const sobject_t &r) {
  return l.oid < r.oid || (l.oid == r.oid && l.snap <= r.snap);
}
inline ostream& operator<<(ostream& out, const sobject_t &o) {
  return out << o.oid << "/" << o.snap;
}
namespace std {
  template<> struct hash<sobject_t> {
    size_t operator()(const sobject_t &r) const {
      static hash<object_t> H;
      static rjhash<uint64_t> I;
      return H(r.oid) ^ I(r.snap);
    }
  };
}
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/intarith.h" 1
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2



# 1 "/usr/include/assert.h" 1 3 4
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 2
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
namespace std {
template<class A, class B>
inline std::ostream& operator<<(std::ostream&out, const std::pair<A,B>& v);
template<class A, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::vector<A,Alloc>& v);
template<class A, std::size_t N, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const boost::container::small_vector<A,N,Alloc>& v);
template<class A, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::deque<A,Alloc>& v);
template<typename... Ts>
inline std::ostream& operator<<(std::ostream& out, const std::tuple<Ts...> &t);
template<class A, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::list<A,Alloc>& ilist);
template<class A, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::set<A, Comp, Alloc>& iset);
template<class A, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::multiset<A,Comp,Alloc>& iset);
template<class A, class B, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::map<A,B,Comp,Alloc>& m);
template<class A, class B, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::multimap<A,B,Comp,Alloc>& m);
}

namespace boost {
template<typename... Ts>
inline std::ostream& operator<<(std::ostream& out, const boost::tuple<Ts...> &t);

namespace container {
template<class A, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const boost::container::flat_set<A, Comp, Alloc>& iset);
template<class A, class B, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const boost::container::flat_map<A, B, Comp, Alloc>& iset);
}
}

namespace std {
template<class A, class B>
inline std::ostream& operator<<(std::ostream& out, const std::pair<A,B>& v) {
  return out << v.first << "," << v.second;
}

template<class A, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::vector<A,Alloc>& v) {
  bool first = true;
  out << "[";
  for (const auto& p : v) {
    if (!first) out << ",";
    out << p;
    first = false;
  }
  out << "]";
  return out;
}

template<class A, std::size_t N, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const boost::container::small_vector<A,N,Alloc>& v) {
  bool first = true;
  out << "[";
  for (const auto& p : v) {
    if (!first) out << ",";
    out << p;
    first = false;
  }
  out << "]";
  return out;
}

template<class A, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::deque<A,Alloc>& v) {
  out << "<";
  for (auto p = v.begin(); p != v.end(); ++p) {
    if (p != v.begin()) out << ",";
    out << *p;
  }
  out << ">";
  return out;
}

template<typename... Ts>
inline std::ostream& operator<<(std::ostream& out, const std::tuple<Ts...> &t) {
  auto f = [n = sizeof...(Ts), i = 0U, &out](const auto& e) mutable {
    out << e;
    if (++i != n)
      out << ",";
  };
  ceph::for_each(t, f);
  return out;
}

template<class A, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::list<A,Alloc>& ilist) {
  for (auto it = ilist.begin();
       it != ilist.end();
       ++it) {
    if (it != ilist.begin()) out << ",";
    out << *it;
  }
  return out;
}

template<class A, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::set<A, Comp, Alloc>& iset) {
  for (auto it = iset.begin();
       it != iset.end();
       ++it) {
    if (it != iset.begin()) out << ",";
    out << *it;
  }
  return out;
}

template<class A, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::multiset<A,Comp,Alloc>& iset) {
  for (auto it = iset.begin();
       it != iset.end();
       ++it) {
    if (it != iset.begin()) out << ",";
    out << *it;
  }
  return out;
}

template<class A, class B, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::map<A,B,Comp,Alloc>& m)
{
  out << "{";
  for (auto it = m.begin();
       it != m.end();
       ++it) {
    if (it != m.begin()) out << ",";
    out << it->first << "=" << it->second;
  }
  out << "}";
  return out;
}

template<class A, class B, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const std::multimap<A,B,Comp,Alloc>& m)
{
  out << "{{";
  for (auto it = m.begin();
       it != m.end();
       ++it) {
    if (it != m.begin()) out << ",";
    out << it->first << "=" << it->second;
  }
  out << "}}";
  return out;
}

}

namespace boost {
namespace tuples {
template<typename A, typename B, typename C>
inline std::ostream& operator<<(std::ostream& out, const boost::tuples::tuple<A, B, C> &t) {
  return out << boost::get<0>(t) << ","
      << boost::get<1>(t) << ","
      << boost::get<2>(t);
}
}
namespace container {
template<class A, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const boost::container::flat_set<A, Comp, Alloc>& iset) {
  for (auto it = iset.begin();
       it != iset.end();
       ++it) {
    if (it != iset.begin()) out << ",";
    out << *it;
  }
  return out;
}

template<class A, class B, class Comp, class Alloc>
inline std::ostream& operator<<(std::ostream& out, const boost::container::flat_map<A, B, Comp, Alloc>& m) {
  for (auto it = m.begin();
       it != m.end();
       ++it) {
    if (it != m.begin()) out << ",";
    out << it->first << "=" << it->second;
  }
  return out;
}
}
}
# 281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
struct eqstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) == 0;
  }
};


struct ltstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};


namespace ceph {
  class Formatter;
}



inline void encode(const ceph_fsid &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_fsid &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_file_layout &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_file_layout &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_dir_layout &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_dir_layout &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_session_head &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_session_head &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_request_head_legacy &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_request_head_legacy &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_request_head &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_request_head &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_request_release &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_request_release &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_filelock &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_filelock &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_caps_head &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_caps_head &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_caps_body_legacy &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_caps_body_legacy &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_cap_peer &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_cap_peer &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_cap_release &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_cap_release &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_cap_item &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_cap_item &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_lease &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_lease &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_snap_head &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_snap_head &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_snap_realm &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_snap_realm &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_reply_head &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_reply_head &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_reply_cap &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_reply_cap &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_cap_reconnect &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_cap_reconnect &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mds_snaprealm_reconnect &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mds_snaprealm_reconnect &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_frag_tree_split &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_frag_tree_split &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_osd_reply_head &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_osd_reply_head &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_osd_op &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_osd_op &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_msg_header &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_msg_header &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_msg_footer &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_msg_footer &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_msg_footer_old &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_msg_footer_old &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mon_subscribe_item &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mon_subscribe_item &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }

inline void encode(const ceph_mon_statfs &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mon_statfs &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }
inline void encode(const ceph_mon_statfs_reply &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } inline void decode(ceph_mon_statfs_reply &v, ::ceph::bufferlist::const_iterator& p) { ::ceph::decode_raw(v, p); }





typedef uint64_t ceph_tid_t;
typedef uint64_t version_t;
typedef __u32 epoch_t;




struct client_t {
  int64_t v;


  client_t(int64_t _v = -2) : v(_v) {}

  void encode(bufferlist& bl) const {
    using ceph::encode;
    encode(v, bl);
  }
  void decode(bufferlist::const_iterator& bl) {
    using ceph::decode;
    decode(v, bl);
  }
};
inline void encode(const client_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(client_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

static inline bool operator==(const client_t& l, const client_t& r) { return l.v == r.v; }
static inline bool operator!=(const client_t& l, const client_t& r) { return l.v != r.v; }
static inline bool operator<(const client_t& l, const client_t& r) { return l.v < r.v; }
static inline bool operator<=(const client_t& l, const client_t& r) { return l.v <= r.v; }
static inline bool operator>(const client_t& l, const client_t& r) { return l.v > r.v; }
static inline bool operator>=(const client_t& l, const client_t& r) { return l.v >= r.v; }

static inline bool operator>=(const client_t& l, int64_t o) { return l.v >= o; }
static inline bool operator<(const client_t& l, int64_t o) { return l.v < o; }

inline ostream& operator<<(ostream& out, const client_t& c) {
  return out << c.v;
}





namespace {
  inline ostream& format_u(ostream& out, const uint64_t v, const uint64_t n,
      const int index, const uint64_t mult, const char* u)
  {
    char buffer[32];

    if (index == 0) {
      (void) snprintf(buffer, sizeof(buffer), "%" 
# 389 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 3 4
                                                 "l" "d" 
# 389 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
                                                        "%s", n, u);
    } else if ((v % mult) == 0) {


      (void) snprintf(buffer, sizeof(buffer), "%" 
# 393 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h" 3 4
                                                 "l" "d" 
# 393 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
                                                        "%s", n, u);
    } else {







      int i;
      for (i = 2; i >= 0; i--) {
        if (snprintf(buffer, sizeof(buffer), "%.*f%s", i,
          static_cast<double>(v) / mult, u) <= 7)
          break;
      }
    }

    return out << buffer;
  }
}





struct si_u_t {
  uint64_t v;
  explicit si_u_t(uint64_t _v) : v(_v) {};
};

inline ostream& operator<<(ostream& out, const si_u_t& b)
{
  uint64_t n = b.v;
  int index = 0;
  uint64_t mult = 1;
  const char* u[] = {"", "k", "M", "G", "T", "P", "E"};

  while (n >= 1000 && index < 7) {
    n /= 1000;
    index++;
    mult *= 1000;
  }

  return format_u(out, b.v, n, index, mult, u[index]);
}
# 446 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
struct byte_u_t {
  uint64_t v;
  explicit byte_u_t(uint64_t _v) : v(_v) {};
};

inline ostream& operator<<(ostream& out, const byte_u_t& b)
{
  uint64_t n = b.v;
  int index = 0;
  const char* u[] = {" B", " KiB", " MiB", " GiB", " TiB", " PiB", " EiB"};

  while (n >= 1024 && index < 7) {
    n /= 1024;
    index++;
  }

  return format_u(out, b.v, n, index, 1ULL << (10 * index), u[index]);
}

inline ostream& operator<<(ostream& out, const ceph_mon_subscribe_item& i)
{
  return out << i.start
      << ((i.flags & 1) ? "" : "+");
}

struct weightf_t {
  float v;

  weightf_t(float _v) : v(_v) {}
};

inline ostream& operator<<(ostream& out, const weightf_t& w)
{
  if (w.v < -0.01F) {
    return out << "-";
  } else if (w.v < 0.000001F) {
    return out << "0";
  } else {
    std::streamsize p = out.precision();
    return out << std::fixed << std::setprecision(5) << w.v << std::setprecision(p);
  }
}

struct shard_id_t {
  int8_t id;

  shard_id_t() : id(0) {}
  explicit shard_id_t(int8_t _id) : id(_id) {}

  operator int8_t() const { return id; }

  const static shard_id_t NO_SHARD;

  void encode(bufferlist &bl) const {
    using ceph::encode;
    encode(id, bl);
  }
  void decode(bufferlist::const_iterator &bl) {
    using ceph::decode;
    decode(id, bl);
  }
};
inline void encode(const shard_id_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(shard_id_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
inline bool operator==(const shard_id_t &l, const shard_id_t &r) { return l.id == r.id; } inline bool operator!=(const shard_id_t &l, const shard_id_t &r) { return l.id != r.id; }
inline bool operator>(const shard_id_t &l, const shard_id_t &r) { return l.id > r.id; } inline bool operator<(const shard_id_t &l, const shard_id_t &r) { return l.id < r.id; } inline bool operator>=(const shard_id_t &l, const shard_id_t &r) { return l.id >= r.id; } inline bool operator<=(const shard_id_t &l, const shard_id_t &r) { return l.id <= r.id; }
ostream &operator<<(ostream &lhs, const shard_id_t &rhs);
# 521 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/types.h"
struct errorcode32_t {
  int32_t code;

  errorcode32_t() : code(0) {}

  errorcode32_t(int32_t i) : code(i) {}

  operator int() const { return code; }
  int* operator&() { return &code; }
  int operator==(int i) { return code == i; }
  int operator>(int i) { return code > i; }
  int operator>=(int i) { return code >= i; }
  int operator<(int i) { return code < i; }
  int operator<=(int i) { return code <= i; }

  void encode(bufferlist &bl) const {
    using ceph::encode;
    __s32 newcode = (code);
    encode(newcode, bl);
  }
  void decode(bufferlist::const_iterator &bl) {
    using ceph::decode;
    decode(code, bl);
    code = (code);
  }
};
inline void encode(const errorcode32_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(errorcode32_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
inline bool operator==(const errorcode32_t &l, const errorcode32_t &r) { return l.code == r.code; } inline bool operator!=(const errorcode32_t &l, const errorcode32_t &r) { return l.code != r.code; }
inline bool operator>(const errorcode32_t &l, const errorcode32_t &r) { return l.code > r.code; } inline bool operator<(const errorcode32_t &l, const errorcode32_t &r) { return l.code < r.code; } inline bool operator>=(const errorcode32_t &l, const errorcode32_t &r) { return l.code >= r.code; } inline bool operator<=(const errorcode32_t &l, const errorcode32_t &r) { return l.code <= r.code; }

template <uint8_t S>
struct sha_digest_t {
  constexpr static uint32_t SIZE = S;


  unsigned char v[S] = {0};

  string to_str() const {
    char str[S * 2 + 1] = {0};
    str[0] = '\0';
    for (size_t i = 0; i < S; i++) {
      ::sprintf(&str[i * 2], "%02x", static_cast<int>(v[i]));
    }
    return string(str);
  }
  sha_digest_t(const unsigned char *_v) { memcpy(v, _v, SIZE); };
  sha_digest_t() {}

  bool operator==(const sha_digest_t& r) const {
    return ::memcmp(v, r.v, SIZE) == 0;
  }
  bool operator!=(const sha_digest_t& r) const {
    return ::memcmp(v, r.v, SIZE) != 0;
  }

  void encode(bufferlist &bl) const {

    using ceph::encode;
    std::array<unsigned char, SIZE> tmparr;
    memcpy(tmparr.data(), v, SIZE);
    encode(tmparr, bl);
  }
  void decode(bufferlist::const_iterator &bl) {
    using ceph::decode;
    std::array<unsigned char, SIZE> tmparr;
    decode(tmparr, bl);
    memcpy(v, tmparr.data(), SIZE);
  }
};

template <uint8_t S>
inline ostream &operator<<(ostream &out, const sha_digest_t<S> &b) {
  string str = b.to_str();
  return out << str;
}

using sha1_digest_t = sha_digest_t<20>;
inline void encode(const sha1_digest_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(sha1_digest_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

using sha256_digest_t = sha_digest_t<32>;
inline void encode(const sha256_digest_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(sha256_digest_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 5 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 2



       


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 1
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/config.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 2 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/template_arity.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute_fwd.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute_fwd.hpp" 3 4

# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute_fwd.hpp" 3 4
namespace boost {
namespace detail { namespace variant {
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute_fwd.hpp" 3 4
template <
      typename T, typename Dest, typename Source
      , typename Arity = mpl::int_< mpl::aux::template_arity<T>::value >


    >
struct substitute;



}}
}
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 2 3 4
# 168 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
namespace boost {

namespace detail { namespace variant {
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
struct void_;

template <typename T>
struct convert_void
{
    typedef T type;
};

template <>
struct convert_void< void_ >
{
    typedef mpl::na type;
};
# 232 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
}}
# 282 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
template < typename T0, typename... TN > class variant;







template < typename T0, typename... TN > struct make_recursive_variant;
# 301 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
    struct recursive_variant_ {};
# 311 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant_fwd.hpp" 3 4
template <typename Types> struct make_variant_over;






template <typename Types> struct make_recursive_variant_over;

}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/backup_holder.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/backup_holder.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/backup_holder.hpp" 2 3 4

namespace boost {
namespace detail { namespace variant {

template <typename T>
class backup_holder
{
private:

    T* backup_;

public:

    ~backup_holder() noexcept
    {
        delete backup_;
    }

    explicit backup_holder(T* backup) noexcept
        : backup_(backup)
    {
    }

    backup_holder(const backup_holder&);

public:

    backup_holder& operator=(const backup_holder& rhs)
    {
        *backup_ = rhs.get();
        return *this;
    }

    backup_holder& operator=(const T& rhs)
    {
        *backup_ = rhs;
        return *this;
    }

    void swap(backup_holder& rhs) noexcept
    {
        T* tmp = rhs.backup_;
        rhs.backup_ = this->backup_;
        this->backup_ = tmp;
    }

public:

    T& get() noexcept
    {
        return *backup_;
    }

    const T& get() const noexcept
    {
        return *backup_;
    }

};

template <typename T>
backup_holder<T>::backup_holder(const backup_holder&)
    : backup_(0)
{

    (static_cast<void> (0));
}

template <typename T>
void swap(backup_holder<T>& lhs, backup_holder<T>& rhs) noexcept
{
    lhs.swap(rhs);
}

}}
}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive_fwd.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive_fwd.hpp" 3 4
namespace boost {
namespace detail { namespace variant {
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive_fwd.hpp" 3 4
template <typename T>
struct recursive_flag
{
    typedef T type;
};
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive_fwd.hpp" 3 4
template <typename T>
struct is_recursive_flag
    : mpl::false_
{
};

template <typename T>
struct is_recursive_flag< recursive_flag<T> >
    : mpl::true_
{
};
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive_fwd.hpp" 3 4
template <
      typename T
    , typename RecursiveVariant
    , typename NoWrapper = mpl::false_
    >
struct enable_recursive;






template <
      typename RecursiveVariant
    , typename NoWrapper = mpl::false_
    >
struct quoted_enable_recursive;

}}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/forced_return.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/forced_return.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/generic_result_type.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/forced_return.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/forced_return.hpp" 2 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/forced_return.hpp" 2 3 4







namespace boost { namespace detail { namespace variant {

__attribute__ ((__noreturn__)) inline void forced_return_no_return() {
    using namespace std;
    abort();
}
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/forced_return.hpp" 3 4
template <typename T>
__attribute__ ((__noreturn__)) inline
    T
forced_return()
{

    (static_cast<void> (0));

    forced_return_no_return();





}

}}}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/call_traits.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/call_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/call_traits.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/call_traits.hpp" 3 4
namespace boost{

namespace detail{

template <typename T, bool small_>
struct ct_imp2
{
   typedef const T& param_type;
};

template <typename T>
struct ct_imp2<T, true>
{
   typedef const T param_type;
};

template <typename T, bool isp, bool b1, bool b2>
struct ct_imp
{
   typedef const T& param_type;
};

template <typename T, bool isp, bool b2>
struct ct_imp<T, isp, true, b2>
{
   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
};

template <typename T, bool isp, bool b1>
struct ct_imp<T, isp, b1, true>
{
   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
};

template <typename T, bool b1, bool b2>
struct ct_imp<T, true, b1, b2>
{
   typedef const T param_type;
};

}

template <typename T>
struct call_traits
{
public:
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;






   typedef typename boost::detail::ct_imp<
      T,
      ::boost::is_pointer<T>::value,
      ::boost::is_arithmetic<T>::value,
      ::boost::is_enum<T>::value
   >::param_type param_type;
};

template <typename T>
struct call_traits<T&>
{
   typedef T& value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef T& param_type;
};
# 143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/call_traits.hpp" 3 4
template <typename T, std::size_t N>
struct call_traits<T [N]>
{
private:
   typedef T array_type[N];
public:

   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};

template <typename T, std::size_t N>
struct call_traits<const T [N]>
{
private:
   typedef const T array_type[N];
public:

   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};


}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/call_traits.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/reference_content.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/reference_content.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_copy.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_copy.hpp" 3 4
namespace boost {

template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, ((__has_nothrow_copy(T) ) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)>{};
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_nothrow_copy.hpp" 3 4
template <> struct has_nothrow_copy_constructor<void> : public false_type{};
template <class T> struct has_nothrow_copy_constructor<T volatile> : public false_type{};
template <class T> struct has_nothrow_copy_constructor<T&> : public false_type{};

template <class T> struct has_nothrow_copy_constructor<T&&> : public false_type{};


template <> struct has_nothrow_copy_constructor<void const> : public false_type{};
template <> struct has_nothrow_copy_constructor<void volatile> : public false_type{};
template <> struct has_nothrow_copy_constructor<void const volatile> : public false_type{};


template <class T> struct has_nothrow_copy : public has_nothrow_copy_constructor<T>{};

}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/reference_content.hpp" 2 3 4



namespace boost {

namespace detail {






template <typename RefT>
class reference_content
{
private:

    RefT content_;

public:

    ~reference_content()
    {
    }

    reference_content(RefT r)
        : content_( r )
    {
    }

    reference_content(const reference_content& operand)
        : content_( operand.content_ )
    {
    }

private:

    reference_content& operator=(const reference_content&);

public:

    RefT get() const
    {
        return content_;
    }

};







template <typename T = mpl::void_> struct make_reference_content;


template <typename T>
struct make_reference_content
{
    typedef T type;
};

template <typename T>
struct make_reference_content< T& >
{
    typedef reference_content<T&> type;
};


template <>
struct make_reference_content< mpl::void_ >
{
    template <typename T>
    struct apply
        : make_reference_content<T>
    {
    };

    typedef mpl::void_ type;
};

}






template <typename T>
struct has_nothrow_copy<
      ::boost::detail::reference_content< T& >
    >
    : mpl::true_
{
};


}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_wrapper_fwd.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_wrapper_fwd.hpp" 3 4
namespace boost {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_wrapper_fwd.hpp" 3 4
template <typename T> class recursive_wrapper;







template <class T> struct is_constructible<recursive_wrapper<T>, T> : boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const T> : boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, T&> : boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const T&> : boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T> > : boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T> > : boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T>& > : boost::true_type{};
template <class T> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T>& > : boost::true_type{};

template <class T, class U> struct is_constructible<recursive_wrapper<T>, U > : boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U > : boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, U& > : boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U& > : boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U> > : boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U> > : boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U>& > : boost::false_type{};
template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U>& > : boost::false_type{};



template <class T> struct is_nothrow_move_constructible<recursive_wrapper<T> > : boost::false_type{};







namespace detail {


template <typename T>
struct is_recursive_wrapper_impl
    : mpl::false_
{
};

template <typename T>
struct is_recursive_wrapper_impl< recursive_wrapper<T> >
    : mpl::true_
{
};


}

template< typename T > struct is_recursive_wrapper
    : public ::boost::integral_constant<bool,(::boost::detail::is_recursive_wrapper_impl<T>::value)>
{
public:
   
};
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_wrapper_fwd.hpp" 3 4
template <typename T>
struct unwrap_recursive
{
    typedef T type;

   
};

template <typename T>
struct unwrap_recursive< recursive_wrapper<T> >
{
    typedef T type;

   
};


}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/move.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/move.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/move.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/move.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/move.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 3 4
namespace boost {







namespace move_detail {

template
<typename I,
typename F>
inline F uninitialized_move_move_iterator(I f, I l, F r

)
{
   return ::boost::uninitialized_move(f, l, r);
}
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 3 4
}

template
<typename I,
typename F>
inline F uninitialized_copy_or_move(I f, I l, F r,
                             typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0)
{
   return ::boost::move_detail::uninitialized_move_move_iterator(f, l, r);
}







namespace move_detail {

template
<typename I,
typename F>
inline F move_move_iterator(I f, I l, F r

)
{
   return ::boost::move(f, l, r);
}
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 3 4
}

template
<typename I,
typename F>
inline F copy_or_move(I f, I l, F r,
                             typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0)
{
   return ::boost::move_detail::move_move_iterator(f, l, r);
}
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 3 4
template
<typename I,
typename F>
inline F uninitialized_copy_or_move(I f, I l, F r

   ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0

   )
{
   return std::uninitialized_copy(f, l, r);
}
# 151 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 3 4
template
<typename I,
typename F>
inline F copy_or_move(I f, I l, F r

   ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0

   )
{
   return std::copy(f, l, r);
}

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/algorithm.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/move.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/detail/config_end.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/move/move.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/move.hpp" 2 3 4


namespace boost { namespace detail { namespace variant {

using boost::move;
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/move.hpp" 3 4
template <typename T>
inline void move_swap(T& lhs, T& rhs)
{
    ::boost::adl_move_swap(lhs, rhs);
}

}}}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair.hpp" 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> { }; }

}}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 3 4
namespace boost {
namespace detail { namespace variant {
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 3 4
struct make_initializer_node
{
    template <typename BaseIndexPair, typename Iterator>
    struct apply
    {
    private:

        typedef typename BaseIndexPair::first
            base;
        typedef typename BaseIndexPair::second
            index;

        class initializer_node
            : public base
        {
        private:

            typedef typename mpl::deref<Iterator>::type
                recursive_enabled_T;
            typedef typename unwrap_recursive<recursive_enabled_T>::type
                public_T;


            typedef boost::is_reference<public_T>
                is_reference_content_t;

            typedef typename boost::mpl::if_<is_reference_content_t, public_T, const public_T& >::type
                param_T;

            template <class T> struct disable_overload{};

            typedef typename boost::mpl::if_<is_reference_content_t, disable_overload<public_T>, public_T&& >::type
                param2_T;





        public:

            using base::initialize;

            static int initialize(void* dest, param_T operand)
            {
                typedef typename boost::detail::make_reference_content<
                      recursive_enabled_T
                    >::type internal_T;

                new(dest) internal_T(operand);
                return index::value;
            }


            static int initialize(void* dest, param2_T operand)
            {


                (static_cast<void> (0));

                typedef typename boost::mpl::if_<is_reference_content_t, param2_T, recursive_enabled_T>::type value_T;
                new(dest) value_T( boost::detail::variant::move(operand) );
                return index::value;
            }

        };

        friend class initializer_node;

    public:

        typedef mpl::pair<
              initializer_node
            , typename mpl::next< index >::type
            > type;

    };
};






class initializer_root
{
public:

    static void initialize();

};
# 208 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/initializer.hpp" 3 4
}}
}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/make_variant_list.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/make_variant_list.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/limits/list.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list20.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list20.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list10.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list10.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/push_front.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/push_front.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/item.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/item.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/tag.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/tag.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

struct list_tag;
struct l_iter_tag;

}}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/item.hpp" 2 3 4



namespace boost { namespace mpl {

template<
      typename Size
    , typename T
    , typename Next
    >
struct l_item
{




    typedef aux::list_tag tag;
    typedef l_item type;

    typedef Size size;
    typedef T item;
    typedef Next next;
};

struct l_end
{



    typedef aux::list_tag tag;
    typedef l_end type;
    typedef long_<0> size;
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/push_front.hpp" 2 3 4


namespace boost { namespace mpl {

template<>
struct push_front_impl< aux::list_tag >
{
    template< typename List, typename T > struct apply
    {
        typedef l_item<
              typename next<typename List::size>::type
            , T
            , typename List::type
            > type;
    };
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/pop_front.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/pop_front.hpp" 3 4
namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef typename mpl::next<List>::type type;
    };
};

}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/push_back.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/push_back.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct has_push_back_impl;

template<>
struct has_push_back_impl< aux::list_tag >
{
    template< typename Seq > struct apply
        : false_
    {
    };
};

}}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/front.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/front.hpp" 3 4
namespace boost { namespace mpl {

template<>
struct front_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef typename List::item type;
    };
};

}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/clear.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/clear.hpp" 3 4
namespace boost { namespace mpl {

template<>
struct clear_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef l_end type;
    };
};

}}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/O1_size.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/O1_size.hpp" 3 4
namespace boost { namespace mpl {

template<>
struct O1_size_impl< aux::list_tag >
{
    template< typename List > struct apply
        : List::size
    {
    };
};

}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/size.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/size.hpp" 3 4
namespace boost { namespace mpl {

template<>
struct size_impl< aux::list_tag >
{
    template< typename List > struct apply
        : List::size
    {
    };
};

}}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/empty.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/empty.hpp" 3 4
namespace boost { namespace mpl {

template<>
struct empty_impl< aux::list_tag >
{
    template< typename List > struct apply
        : not_<typename List::size>
    {
    };
};

}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/begin_end.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/begin_end.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/iterator.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/iterator.hpp" 3 4
namespace boost { namespace mpl {



template< typename Node >
struct l_iter
{
    typedef aux::l_iter_tag tag;
    typedef forward_iterator_tag category;
};

template< typename Node >
struct deref< l_iter<Node> >
{
    typedef typename Node::item type;
};

template< typename Node >
struct next< l_iter<Node> >
{
    typedef l_iter< typename Node::next > type;
};
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/iterator.hpp" 3 4
template<> struct l_iter<l_end>
{
    typedef aux::l_iter_tag tag;
    typedef forward_iterator_tag category;




};

template< typename T1 , typename Tag > struct lambda< l_iter< T1 > , Tag , int_<1> > { typedef false_ is_le; typedef l_iter< T1 > result_; typedef result_ type; };

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/begin_end.hpp" 2 3 4



namespace boost { namespace mpl {

template<>
struct begin_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef l_iter<typename List::type> type;
    };
};

template<>
struct end_impl< aux::list_tag >
{
    template< typename > struct apply
    {
        typedef l_iter<l_end> type;
    };
};

}}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list0.hpp" 2 3 4


namespace boost { namespace mpl {

template< typename Dummy = na > struct list0;

template<> struct list0<na>
    : l_end
{
    typedef l_end type;
};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list10.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list10.hpp" 3 4
namespace boost { namespace mpl {



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0
    >
struct list1
    : l_item<
          long_<1>
        , T0
        , l_end
        >
{
    typedef list1 type;
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1
    >
struct list2
    : l_item<
          long_<2>
        , T0
        , list1< T1 >
        >
{
    typedef list2 type;
};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2
    >
struct list3
    : l_item<
          long_<3>
        , T0
        , list2< T1 , T2 >
        >
{
    typedef list3 type;
};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3
    >
struct list4
    : l_item<
          long_<4>
        , T0
        , list3< T1 , T2 , T3 >
        >
{
    typedef list4 type;
};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4
    >
struct list5
    : l_item<
          long_<5>
        , T0
        , list4< T1 , T2 , T3 , T4 >
        >
{
    typedef list5 type;
};
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
    >
struct list6
    : l_item<
          long_<6>
        , T0
        , list5< T1 , T2 , T3 , T4 , T5 >
        >
{
    typedef list6 type;
};
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
    >
struct list7
    : l_item<
          long_<7>
        , T0
        , list6< T1 , T2 , T3 , T4 , T5 , T6 >
        >
{
    typedef list7 type;
};
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
    >
struct list8
    : l_item<
          long_<8>
        , T0
        , list7< T1 , T2 , T3 , T4 , T5 , T6 , T7 >
        >
{
    typedef list8 type;
};
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
    >
struct list9
    : l_item<
          long_<9>
        , T0
        , list8< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 >
        >
{
    typedef list9 type;
};
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
    >
struct list10
    : l_item<
          long_<10>
        , T0
        , list9< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 >
        >
{
    typedef list10 type;
};
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list10.hpp" 2 3 4

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list20.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list20.hpp" 3 4
namespace boost { namespace mpl {



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10
    >
struct list11
    : l_item<
          long_<11>
        , T0
        , list10< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 >
        >
{
    typedef list11 type;
};
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11
    >
struct list12
    : l_item<
          long_<12>
        , T0
        , list11< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 >
        >
{
    typedef list12 type;
};
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12
    >
struct list13
    : l_item<
          long_<13>
        , T0
        , list12< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 >
        >
{
    typedef list13 type;
};
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13
    >
struct list14
    : l_item<
          long_<14>
        , T0
        , list13< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 >
        >
{
    typedef list14 type;
};
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14
    >
struct list15
    : l_item<
          long_<15>
        , T0
        , list14< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 >
        >
{
    typedef list15 type;
};
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15
    >
struct list16
    : l_item<
          long_<16>
        , T0
        , list15< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 >
        >
{
    typedef list16 type;
};
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16
    >
struct list17
    : l_item<
          long_<17>
        , T0
        , list16< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 >
        >
{
    typedef list17 type;
};
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17
    >
struct list18
    : l_item<
          long_<18>
        , T0
        , list17< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 >
        >
{
    typedef list18 type;
};
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18
    >
struct list19
    : l_item<
          long_<19>
        , T0
        , list18< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 >
        >
{
    typedef list19 type;
};
# 143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/aux_/numbered.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
    >
struct list20
    : l_item<
          long_<20>
        , T0
        , list19< T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >
        >
{
    typedef list20 type;
};
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list/list20.hpp" 2 3 4

}}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list.hpp" 2 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
namespace boost { namespace mpl {
# 151 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 = na , typename T1 = na , typename T2 = na , typename T3 = na , typename T4 = na , typename T5 = na , typename T6 = na , typename T7 = na , typename T8 = na , typename T9 = na , typename T10 = na , typename T11 = na , typename T12 = na , typename T13 = na , typename T14 = na , typename T15 = na , typename T16 = na , typename T17 = na , typename T18 = na , typename T19 = na
    >
struct list;
# 164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
     
    >
struct list< na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list0< >
{



    typedef list0< >::type type;

};
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0
    >
struct list< T0 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list1< T0 >
{

    typedef typename list1< T0 >::type type;



};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1
    >
struct list< T0 , T1 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list2< T0 , T1 >
{

    typedef typename list2< T0 , T1 >::type type;



};
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2
    >
struct list< T0 , T1 , T2 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list3< T0 , T1 , T2 >
{

    typedef typename list3< T0 , T1 , T2 >::type type;



};
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3
    >
struct list< T0 , T1 , T2 , T3 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list4< T0 , T1 , T2 , T3 >
{

    typedef typename list4< T0 , T1 , T2 , T3 >::type type;



};
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4
    >
struct list< T0 , T1 , T2 , T3 , T4 , na , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list5< T0 , T1 , T2 , T3 , T4 >
{

    typedef typename list5< T0 , T1 , T2 , T3 , T4 >::type type;



};
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , na , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list6< T0 , T1 , T2 , T3 , T4 , T5 >
{

    typedef typename list6< T0 , T1 , T2 , T3 , T4 , T5 >::type type;



};
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , na , na , na , na , na , na , na , na , na , na , na , na , na >
    : list7< T0 , T1 , T2 , T3 , T4 , T5 , T6 >
{

    typedef typename list7< T0 , T1 , T2 , T3 , T4 , T5 , T6 >::type type;



};
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , na , na , na , na , na , na , na , na , na , na , na , na >
    : list8< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 >
{

    typedef typename list8< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 >::type type;



};
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , na , na , na , na , na , na , na , na , na , na , na >
    : list9< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 >
{

    typedef typename list9< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 >::type type;



};
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , na , na , na , na , na , na , na , na , na , na >
    : list10< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 >
{

    typedef typename list10< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 >::type type;



};
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , na , na , na , na , na , na , na , na , na >
    : list11< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 >
{

    typedef typename list11< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 >::type type;



};
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , na , na , na , na , na , na , na , na >
    : list12< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 >
{

    typedef typename list12< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 >::type type;



};
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , na , na , na , na , na , na , na >
    : list13< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 >
{

    typedef typename list13< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 >::type type;



};
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , na , na , na , na , na , na >
    : list14< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 >
{

    typedef typename list14< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 >::type type;



};
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , na , na , na , na , na >
    : list15< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 >
{

    typedef typename list15< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 >::type type;



};
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , na , na , na , na >
    : list16< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 >
{

    typedef typename list16< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 >::type type;



};
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , na , na , na >
    : list17< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 >
{

    typedef typename list17< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 >::type type;



};
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , na , na >
    : list18< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 >
{

    typedef typename list18< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 >::type type;



};
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18
    >
struct list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , na >
    : list19< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 >
{

    typedef typename list19< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 >::type type;



};
# 143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 1 3 4
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
template<
      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
    >
struct list
    : list20< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >
{
    typedef typename list20< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >::type type;
};
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 165 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 2 3 4
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/sequence_wrapper.hpp" 3 4
}}
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/list.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/make_variant_list.hpp" 2 3 4



namespace boost {
namespace detail { namespace variant {
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/make_variant_list.hpp" 3 4
template < typename... T >
struct make_variant_list
{
    typedef typename mpl::list< T... >::type type;
};
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/make_variant_list.hpp" 3 4
}}
}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/over_sequence.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/over_sequence.hpp" 3 4
namespace boost {
namespace detail { namespace variant {






template <typename Types>
struct over_sequence
{
    typedef Types type;
};
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/over_sequence.hpp" 3 4
template <typename T>
struct is_over_sequence
    : mpl::false_
{
};

template <typename Types>
struct is_over_sequence< over_sequence<Types> >
    : mpl::true_
{
};


}}
}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/cast_storage.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/cast_storage.hpp" 3 4
namespace boost {
namespace detail { namespace variant {







template <typename T>
inline T& cast_storage(void* storage)
{
    return *static_cast<T*>(storage);
}

template <typename T>
inline const T& cast_storage(const void* storage)
{
    return *static_cast<const T*>(storage);
}

}}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 2 3 4
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 3 4
namespace boost {
namespace detail { namespace variant {






struct apply_visitor_unrolled {};
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 3 4
template <typename Iter, typename LastIter>
struct visitation_impl_step
{
    typedef typename mpl::deref<Iter>::type type;

    typedef typename mpl::next<Iter>::type next_iter;
    typedef visitation_impl_step<
          next_iter, LastIter
        > next;
};

template <typename LastIter>
struct visitation_impl_step< LastIter,LastIter >
{
    typedef apply_visitor_unrolled type;
    typedef visitation_impl_step next;
};
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 3 4
template <typename Visitor, typename VoidPtrCV, typename T>
inline
    typename Visitor::result_type
visitation_impl_invoke_impl(
      int, Visitor& visitor, VoidPtrCV storage, T*
    , mpl::true_
    )
{
    return visitor.internal_visit(
          cast_storage<T>(storage), 1L
        );
}

template <typename Visitor, typename VoidPtrCV, typename T>
inline
    typename Visitor::result_type
visitation_impl_invoke_impl(
      int internal_which, Visitor& visitor, VoidPtrCV storage, T*
    , mpl::false_
    )
{
    if (internal_which >= 0)
    {
        return visitor.internal_visit(
              cast_storage<T>(storage), 1L
            );
    }
    else
    {
        return visitor.internal_visit(
              cast_storage< backup_holder<T> >(storage), 1L
            );
    }
}

template <typename Visitor, typename VoidPtrCV, typename T, typename NoBackupFlag>
inline
    typename Visitor::result_type
visitation_impl_invoke(
      int internal_which, Visitor& visitor, VoidPtrCV storage, T* t
    , NoBackupFlag
    , int
    )
{
    typedef typename mpl::or_<
          NoBackupFlag
        , is_nothrow_move_constructible<T>
        , has_nothrow_copy<T>
        >::type never_uses_backup;

    return (visitation_impl_invoke_impl)(
          internal_which, visitor, storage, t
        , never_uses_backup()
        );
}

template <typename Visitor, typename VoidPtrCV, typename NBF>
inline
    typename Visitor::result_type
visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long)
{

    typedef typename Visitor::result_type result_type;
    return ::boost::detail::variant::forced_return< result_type >();
}







template <
      typename W, typename S
    , typename Visitor, typename VPCV
    , typename NBF
    >
inline
    typename Visitor::result_type
visitation_impl(
      int, int, Visitor&, VPCV
    , mpl::true_
    , NBF, W* = 0, S* = 0
    )
{

    typedef typename Visitor::result_type result_type;
    return ::boost::detail::variant::forced_return< result_type >();
}

template <
      typename Which, typename step0
    , typename Visitor, typename VoidPtrCV
    , typename NoBackupFlag
    >
inline
    typename Visitor::result_type
visitation_impl(
      const int internal_which, const int logical_which
    , Visitor& visitor, VoidPtrCV storage
    , mpl::false_
    , NoBackupFlag no_backup_flag
    , Which* = 0, step0* = 0
    )
{







    typedef typename step0::type T0; typedef typename step0::next step1; typedef typename step1::type T1; typedef typename step1::next step2; typedef typename step2::type T2; typedef typename step2::next step3; typedef typename step3::type T3; typedef typename step3::next step4; typedef typename step4::type T4; typedef typename step4::next step5; typedef typename step5::type T5; typedef typename step5::next step6; typedef typename step6::type T6; typedef typename step6::next step7; typedef typename step7::type T7; typedef typename step7::next step8; typedef typename step8::type T8; typedef typename step8::next step9; typedef typename step9::type T9; typedef typename step9::next step10; typedef typename step10::type T10; typedef typename step10::next step11; typedef typename step11::type T11; typedef typename step11::next step12; typedef typename step12::type T12; typedef typename step12::next step13; typedef typename step13::type T13; typedef typename step13::next step14; typedef typename step14::type T14; typedef typename step14::next step15; typedef typename step15::type T15; typedef typename step15::next step16; typedef typename step16::type T16; typedef typename step16::next step17; typedef typename step17::type T17; typedef typename step17::next step18; typedef typename step18::type T18; typedef typename step18::next step19; typedef typename step19::type T19; typedef typename step19::next step20;
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 3 4
    switch (logical_which)
    {
# 238 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/visitation_impl.hpp" 3 4
    case (Which::value + (0)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T0*>(0) , no_backup_flag, 1L ); case (Which::value + (1)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T1*>(0) , no_backup_flag, 1L ); case (Which::value + (2)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T2*>(0) , no_backup_flag, 1L ); case (Which::value + (3)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T3*>(0) , no_backup_flag, 1L ); case (Which::value + (4)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T4*>(0) , no_backup_flag, 1L ); case (Which::value + (5)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T5*>(0) , no_backup_flag, 1L ); case (Which::value + (6)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T6*>(0) , no_backup_flag, 1L ); case (Which::value + (7)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T7*>(0) , no_backup_flag, 1L ); case (Which::value + (8)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T8*>(0) , no_backup_flag, 1L ); case (Which::value + (9)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T9*>(0) , no_backup_flag, 1L ); case (Which::value + (10)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T10*>(0) , no_backup_flag, 1L ); case (Which::value + (11)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T11*>(0) , no_backup_flag, 1L ); case (Which::value + (12)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T12*>(0) , no_backup_flag, 1L ); case (Which::value + (13)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T13*>(0) , no_backup_flag, 1L ); case (Which::value + (14)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T14*>(0) , no_backup_flag, 1L ); case (Which::value + (15)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T15*>(0) , no_backup_flag, 1L ); case (Which::value + (16)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T16*>(0) , no_backup_flag, 1L ); case (Which::value + (17)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T17*>(0) , no_backup_flag, 1L ); case (Which::value + (18)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T18*>(0) , no_backup_flag, 1L ); case (Which::value + (19)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T19*>(0) , no_backup_flag, 1L );







    default: break;
    }


    typedef mpl::int_<
          Which::value + (20)
        > next_which;

    typedef step20
        next_step;

    typedef typename next_step::type next_type;
    typedef typename is_same< next_type,apply_visitor_unrolled >::type
        is_apply_visitor_unrolled;

    return detail::variant::visitation_impl(
          internal_which, logical_which
        , visitor, storage
        , is_apply_visitor_unrolled()
        , no_backup_flag
        , static_cast<next_which*>(0), static_cast<next_step*>(0)
        );
}

}}
}
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/hash_variant.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/hash_variant.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/static_visitor.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/static_visitor.hpp" 3 4
namespace boost {
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/static_visitor.hpp" 3 4
namespace detail {

    struct is_static_visitor_tag { };

    typedef void static_visitor_default_return;

}

template <typename R = ::boost::detail::static_visitor_default_return>
class static_visitor
    : public detail::is_static_visitor_tag
{
public:

    typedef R result_type;

protected:

    static_visitor() = default;
    ~static_visitor() = default;




};
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/static_visitor.hpp" 3 4
namespace detail {

template <typename T>
struct is_static_visitor_impl
{
    static const bool value = (::boost::is_base_and_derived< detail::is_static_visitor_tag, T >::value)



                  ;
};

}

template< typename T > struct is_static_visitor
 : public ::boost::integral_constant<bool,(::boost::detail::is_static_visitor_impl<T>::value)>
{
public:
   
};

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/hash_variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/apply_visitor.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/apply_visitor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_unary.hpp" 1 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_unary.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/declval.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_unary.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/has_result_type.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/has_result_type.hpp" 3 4
namespace boost { namespace detail { namespace variant {

template <typename T >
struct has_result_type {
private:
    typedef char yes;
    typedef struct { char array[2]; } no;

    template<typename C> static yes test(typename boost::remove_reference<typename C::result_type>::type*);
    template<typename C> static no test(...);

public:
    static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};

}}}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_unary.hpp" 2 3 4


namespace boost {
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_unary.hpp" 3 4
template <typename Visitor, typename Visitable>
inline
    typename Visitor::result_type
apply_visitor(Visitor& visitor, Visitable&& visitable)
{
    return ::boost::forward<Visitable>(visitable).apply_visitor(visitor);
}
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_unary.hpp" 3 4
template <typename Visitor, typename Visitable>
inline
    typename Visitor::result_type
apply_visitor(const Visitor& visitor, Visitable&& visitable)
{
    return ::boost::forward<Visitable>(visitable).apply_visitor(visitor);
}
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_unary.hpp" 3 4
namespace detail { namespace variant {


template <class Visitor, class Variant>
struct result_multideduce1 {
    typedef typename Variant::types types;
    typedef typename boost::mpl::begin<types>::type begin_it;
    typedef typename boost::mpl::advance<
        begin_it, boost::mpl::int_<boost::mpl::size<types>::type::value - 1>
    >::type last_it;


    static Visitor& vis() noexcept {


        Visitor&(*f)() = 0;
        return f();
    }

    static decltype(auto) deduce_impl(last_it, unsigned ) {
        typedef typename boost::mpl::deref<last_it>::type value_t;
        return vis()( boost::declval< value_t& >() );
    }

    template <class It>
    static decltype(auto) deduce_impl(It, unsigned helper) {
        typedef typename boost::mpl::next<It>::type next_t;
        typedef typename boost::mpl::deref<It>::type value_t;
        if (helper == boost::mpl::distance<begin_it, It>::type::value) {
            return deduce_impl(next_t(), ++helper);
        }

        return vis()( boost::declval< value_t& >() );
    }

    static decltype(auto) deduce() {
        return deduce_impl(begin_it(), 0);
    }
};

template <class Visitor, class Variant>
struct result_wrapper1
{
    typedef decltype(result_multideduce1<Visitor, Variant>::deduce()) result_type;

    Visitor&& visitor_;
    explicit result_wrapper1(Visitor&& visitor) noexcept
        : visitor_(::boost::forward<Visitor>(visitor))
    {}

    template <class T>
    result_type operator()(T&& val) const {
        return visitor_(::boost::forward<T>(val));
    }
};

}}

template <typename Visitor, typename Visitable>
inline decltype(auto) apply_visitor(Visitor&& visitor, Visitable&& visitable,
    typename boost::disable_if<
        boost::detail::variant::has_result_type<Visitor>
    >::type* = 0)
{
    boost::detail::variant::result_wrapper1<Visitor, typename remove_reference<Visitable>::type> cpp14_vis(::boost::forward<Visitor>(visitor));
    return ::boost::forward<Visitable>(visitable).apply_visitor(cpp14_vis);
}



}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/apply_visitor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 1 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 3 4
namespace boost {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 3 4
namespace detail { namespace variant {

template <typename Visitor, typename Value1, bool MoveSemantics>
class apply_visitor_binary_invoke
{
public:

    typedef typename Visitor::result_type
        result_type;

private:

    Visitor& visitor_;
    Value1& value1_;

public:

    apply_visitor_binary_invoke(Visitor& visitor, Value1& value1) noexcept
        : visitor_(visitor)
        , value1_(value1)
    {
    }

public:



    template <typename Value2>
        typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value, result_type>::type
    operator()(Value2&& value2)
    {
        return visitor_(::boost::move(value1_), ::boost::forward<Value2>(value2));
    }

    template <typename Value2>
        typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value, result_type>::type
    operator()(Value2&& value2)
    {
        return visitor_(value1_, ::boost::forward<Value2>(value2));
    }
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 3 4
private:
    apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&);
};

template <typename Visitor, typename Visitable2, bool MoveSemantics>
class apply_visitor_binary_unwrap
{
public:

    typedef typename Visitor::result_type
        result_type;

private:

    Visitor& visitor_;
    Visitable2& visitable2_;

public:

    apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2) noexcept
        : visitor_(visitor)
        , visitable2_(visitable2)
    {
    }

public:



    template <typename Value1>
        typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value, result_type>::type
    operator()(Value1&& value1)
    {
        apply_visitor_binary_invoke<
              Visitor
            , Value1
            , ! ::boost::is_lvalue_reference<Value1>::value
            > invoker(visitor_, value1);

        return boost::apply_visitor(invoker, ::boost::move(visitable2_));
    }

    template <typename Value1>
        typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value, result_type>::type
    operator()(Value1&& value1)
    {
        apply_visitor_binary_invoke<
              Visitor
            , Value1
            , ! ::boost::is_lvalue_reference<Value1>::value
            > invoker(visitor_, value1);

        return boost::apply_visitor(invoker, visitable2_);
    }
# 174 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 3 4
private:
    apply_visitor_binary_unwrap& operator=(const apply_visitor_binary_unwrap&);

};

}}
# 204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 3 4
template <typename Visitor, typename Visitable1, typename Visitable2>
inline
    typename Visitor::result_type
apply_visitor( Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2)
{
    ::boost::detail::variant::apply_visitor_binary_unwrap<
          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
        > unwrapper(visitor, visitable2);

    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
}
# 240 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 3 4
template <typename Visitor, typename Visitable1, typename Visitable2>
inline
    typename Visitor::result_type


apply_visitor( const Visitor& visitor , Visitable1&& visitable1 , Visitable2&& visitable2)
{
    ::boost::detail::variant::apply_visitor_binary_unwrap<
          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
        > unwrapper(visitor, visitable2);

    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
}
# 281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_binary.hpp" 3 4
namespace detail { namespace variant {

template <typename Visitor, typename Value1, bool MoveSemantics>
class apply_visitor_binary_invoke_cpp14
{
    Visitor& visitor_;
    Value1& value1_;

public:

    apply_visitor_binary_invoke_cpp14(Visitor& visitor, Value1& value1) noexcept
        : visitor_(visitor)
        , value1_(value1)
    {
    }

public:

    template <typename Value2>
    decltype(auto) operator()(Value2&& value2, typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value>::type* = 0)
    {
        return visitor_(::boost::move(value1_), ::boost::forward<Value2>(value2));
    }

    template <typename Value2>
    decltype(auto) operator()(Value2&& value2, typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value>::type* = 0)
    {
        return visitor_(value1_, ::boost::forward<Value2>(value2));
    }

private:
    apply_visitor_binary_invoke_cpp14& operator=(const apply_visitor_binary_invoke_cpp14&);
};

template <typename Visitor, typename Visitable2, bool MoveSemantics>
class apply_visitor_binary_unwrap_cpp14
{
    Visitor& visitor_;
    Visitable2& visitable2_;

public:

    apply_visitor_binary_unwrap_cpp14(Visitor& visitor, Visitable2& visitable2) noexcept
        : visitor_(visitor)
        , visitable2_(visitable2)
    {
    }

public:

    template <typename Value1>
    decltype(auto) operator()(Value1&& value1, typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value>::type* = 0)
    {
        apply_visitor_binary_invoke_cpp14<
              Visitor
            , Value1
            , ! ::boost::is_lvalue_reference<Value1>::value
            > invoker(visitor_, value1);

        return boost::apply_visitor(invoker, ::boost::move(visitable2_));
    }

    template <typename Value1>
    decltype(auto) operator()(Value1&& value1, typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value>::type* = 0)
    {
        apply_visitor_binary_invoke_cpp14<
              Visitor
            , Value1
            , ! ::boost::is_lvalue_reference<Value1>::value
            > invoker(visitor_, value1);

        return boost::apply_visitor(invoker, visitable2_);
    }

private:
    apply_visitor_binary_unwrap_cpp14& operator=(const apply_visitor_binary_unwrap_cpp14&);
};

}}

template <typename Visitor, typename Visitable1, typename Visitable2>
inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
    typename boost::disable_if<
        boost::detail::variant::has_result_type<Visitor>
    >::type* = 0)
{
    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
        > unwrapper(visitor, visitable2);

    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
}

template <typename Visitor, typename Visitable1, typename Visitable2>
inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
    typename boost::disable_if<
        boost::detail::variant::has_result_type<Visitor>
    >::type* = 0)
{
    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
        > unwrapper(visitor, visitable2);

    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
}




}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/apply_visitor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_delayed.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_delayed.hpp" 3 4
namespace boost {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_delayed.hpp" 3 4
template <typename Visitor>
class apply_visitor_delayed_t
{
public:

    typedef typename Visitor::result_type
        result_type;

private:

    Visitor& visitor_;

public:

    explicit apply_visitor_delayed_t(Visitor& visitor) noexcept
      : visitor_(visitor)
    {
    }



public:
    template <typename... Visitables>
        result_type
    operator()(Visitables&... visitables) const
    {
        return apply_visitor(visitor_, visitables...);
    }
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/apply_visitor_delayed.hpp" 3 4
private:
    apply_visitor_delayed_t& operator=(const apply_visitor_delayed_t&);

};

template <typename Visitor>
inline typename boost::enable_if<
        boost::detail::variant::has_result_type<Visitor>,
        apply_visitor_delayed_t<Visitor>
    >::type apply_visitor(Visitor& visitor)
{
    return apply_visitor_delayed_t<Visitor>(visitor);
}




template <typename Visitor>
class apply_visitor_delayed_cpp14_t
{
private:
    Visitor& visitor_;

public:

    explicit apply_visitor_delayed_cpp14_t(Visitor& visitor) noexcept
      : visitor_(visitor)
    {
    }

public:
    template <typename... Visitables>
    decltype(auto) operator()(Visitables&... visitables) const
    {
        return apply_visitor(visitor_, visitables...);
    }

private:
    apply_visitor_delayed_cpp14_t& operator=(const apply_visitor_delayed_cpp14_t&);

};

template <typename Visitor>
inline typename boost::disable_if<
        boost::detail::variant::has_result_type<Visitor>,
        apply_visitor_delayed_cpp14_t<Visitor>
    >::type apply_visitor(Visitor& visitor)
{
    return apply_visitor_delayed_cpp14_t<Visitor>(visitor);
}





}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/apply_visitor.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/hash_variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/functional/hash_fwd.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/hash_variant.hpp" 2 3 4

namespace boost {

    namespace detail { namespace variant {
        struct variant_hasher: public boost::static_visitor<std::size_t> {
            template <class T>
            std::size_t operator()(T const& val) const {
                boost::hash<T> hasher;
                return hasher(val);
            }
        };
    }}

    template < typename T0, typename... TN >
    std::size_t hash_value(variant< T0, TN... > const& val) {
        std::size_t seed = boost::apply_visitor(detail::variant::variant_hasher(), val);
        hash_combine(seed, val.which());
        return seed;
    }
}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/aligned_storage.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/aligned_storage.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/aligned_storage.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/aligned_storage.hpp" 3 4
namespace boost {

namespace detail { namespace aligned_storage {

static const std::size_t alignment_of_max_align = ::boost::alignment_of<boost::detail::max_align>::value


     ;




template <
      std::size_t size_
    , std::size_t alignment_
>
struct aligned_storage_imp
{
    union data_t
    {
        char buf[size_];

        typename ::boost::type_with_alignment<alignment_>::type align_;
    } data_;
    void* address() const { return const_cast<aligned_storage_imp*>(this); }
};
template <std::size_t size>
struct aligned_storage_imp<size, std::size_t(-1)>
{
   union data_t
   {
      char buf[size];
      ::boost::detail::max_align align_;
   } data_;
   void* address() const { return const_cast<aligned_storage_imp*>(this); }
};

template< std::size_t alignment_ >
struct aligned_storage_imp<0u,alignment_>
{

    void* address() const { return 0; }
};

}}

template <
      std::size_t size_
    , std::size_t alignment_ = std::size_t(-1)
>
class aligned_storage :

   private



   ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_>
{

public:

    typedef ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;

    static const std::size_t size = size_


         ;
    static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ )






         ;

private:

    aligned_storage(const aligned_storage&);
    aligned_storage& operator=(const aligned_storage&);

public:

    aligned_storage()
    {
    }

    ~aligned_storage()
    {
    }

public:

    void* address()
    {
        return static_cast<type*>(this)->address();
    }

    const void* address() const
    {
        return static_cast<const type*>(this)->address();
    }
};





template <std::size_t size_, std::size_t alignment_>
struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> > : public true_type{};

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/aligned_storage.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/common_factor_ct.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/common_factor_ct.hpp" 3 4
namespace boost
{
namespace integer
{



namespace detail
{

    template < static_gcd_type Value1, static_gcd_type Value2 >
    struct static_gcd_helper_t
    {
    private:
        static const static_gcd_type new_value1 = Value2;
        static const static_gcd_type new_value2 = Value1 % Value2;
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/integer/common_factor_ct.hpp" 3 4
        typedef static_gcd_helper_t< static_cast<static_gcd_type>(new_value1),
         static_cast<static_gcd_type>(new_value2) > next_step_type;



    public:
        static const static_gcd_type value = next_step_type::value;
    };


    template < static_gcd_type Value1 >
    struct static_gcd_helper_t< Value1, 0UL >
    {
        static const static_gcd_type value = Value1;
    };


    template < static_gcd_type Value1, static_gcd_type Value2 >
    struct static_lcm_helper_t
    {
        typedef static_gcd_helper_t<Value1, Value2> gcd_type;

        static const static_gcd_type value = Value1 / gcd_type::value * Value2
                   ;
    };


    template < >
    struct static_lcm_helper_t< 0UL, 0UL >
    {
        static const static_gcd_type value = 0UL;
    };

}




template < static_gcd_type Value1, static_gcd_type Value2 > struct static_gcd
{
    static const static_gcd_type value = (detail::static_gcd_helper_t<Value1, Value2>::value);
};


template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_gcd< Value1, Value2 >::value;




template < static_gcd_type Value1, static_gcd_type Value2 > struct static_lcm
{
    static const static_gcd_type value = (detail::static_lcm_helper_t<Value1, Value2>::value);
};


template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_lcm< Value1, Value2 >::value;


}
}
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/empty.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/empty.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/empty_impl.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/empty_impl.hpp" 3 4
namespace boost { namespace mpl {




template< typename Tag >
struct empty_impl
{
    template< typename Sequence > struct apply
        : is_same<
              typename begin<Sequence>::type
            , typename end<Sequence>::type
            >
    {
    };
};

 template<> struct empty_impl<non_sequence_tag> {};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/empty.hpp" 2 3 4



namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct empty
    : empty_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct empty< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : empty< T1 > { }; }; template< typename Tag > struct lambda< empty< na > , Tag , int_<-1> > { typedef false_ is_le; typedef empty< na > result_; typedef empty< na > type; }; namespace aux { template< typename T1 > struct template_arity< empty< T1 > > : int_<1> { }; template<> struct template_arity< empty< na > > : int_<-1> { }; }

}}
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/find_if.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/find_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/find_if_pred.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/find_if_pred.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_apply.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_apply.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/find_if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/arg.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/find_if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iter_fold_if.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iter_fold_if.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iter_fold_if.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/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;
};
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
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;
};







}}}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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> { }; }

}}
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/front_impl.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/front_impl.hpp" 3 4
namespace boost { namespace mpl {




template< typename Tag >
struct front_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename begin<Sequence>::type iter_;
        typedef typename deref<iter_>::type type;
    };
};

 template<> struct front_impl<non_sequence_tag> {};

}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/front.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct front
    : front_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : front< T1 > { }; }; template< typename Tag > struct lambda< front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef front< na > result_; typedef front< na > type; }; namespace aux { template< typename T1 > struct template_arity< front< T1 > > : int_<1> { }; template<> struct template_arity< front< na > > : int_<-1> { }; }

}}
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_range.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_range.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_range_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_range_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct insert_range_impl;
template< typename Sequence, typename Pos, typename Range > struct insert_range;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_range.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/placeholders.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_fwd.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct insert_impl;
template< typename Sequence, typename Pos_or_T, typename T > struct insert;

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_impl.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_impl.hpp" 3 4
namespace boost { namespace mpl {




template< typename Tag >
struct insert_impl
{
    template<
          typename Sequence
        , typename Pos
        , typename T
        >
    struct apply
    {
        typedef iterator_range<
              typename begin<Sequence>::type
            , Pos
            > first_half_;

        typedef iterator_range<
              Pos
            , typename end<Sequence>::type
            > second_half_;

        typedef typename reverse_fold<
              second_half_
            , typename clear<Sequence>::type
            , push_front<_,_>
            >::type half_sequence_;

        typedef typename reverse_fold<
              first_half_
            , typename push_front<half_sequence_,T>::type
            , push_front<_,_>
            >::type type;
    };
};

 template<> struct insert_impl<non_sequence_tag> {};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert.hpp" 2 3 4



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename Pos_or_T = na
    , typename T = na
    >
struct insert
    : insert_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,Pos_or_T,T >
{
   
};

template<> struct insert< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : insert< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< insert< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef insert< na , na , na > result_; typedef insert< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< insert< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< insert< na , na , na > > : int_<-1> { }; }

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/joint_view.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/joint_view.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/joint_iter.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/joint_iter.hpp" 3 4
namespace boost { namespace mpl {



template<
      typename Iterator1
    , typename LastIterator1
    , typename Iterator2
    >
struct joint_iter
{
    typedef Iterator1 base;
    typedef forward_iterator_tag category;
};

template<
      typename LastIterator1
    , typename Iterator2
    >
struct joint_iter<LastIterator1,LastIterator1,Iterator2>
{
    typedef Iterator2 base;
    typedef forward_iterator_tag category;
};


template< typename I1, typename L1, typename I2 >
struct deref< joint_iter<I1,L1,I2> >
{
    typedef typename joint_iter<I1,L1,I2>::base base_;
    typedef typename deref<base_>::type type;
};

template< typename I1, typename L1, typename I2 >
struct next< joint_iter<I1,L1,I2> >
{
    typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > type;
};

template< typename L1, typename I2 >
struct next< joint_iter<L1,L1,I2> >
{
    typedef joint_iter< L1,L1,typename mpl::next<I2>::type > type;
};
# 116 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/joint_iter.hpp" 3 4
template< typename T1 , typename T2 , typename T3 , typename Tag > struct lambda< joint_iter< T1 , T2 , T3 > , Tag , int_<3> > { typedef false_ is_le; typedef joint_iter< T1 , T2 , T3 > result_; typedef result_ type; };

}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/joint_view.hpp" 2 3 4





namespace boost { namespace mpl {

namespace aux {
struct joint_view_tag;
}

template<>
struct size_impl< aux::joint_view_tag >
{
    template < typename JointView > struct apply
      : plus<
            size<typename JointView::sequence1_>
          , size<typename JointView::sequence2_>
          >
    {};
};

template<
      typename Sequence1_ = na
    , typename Sequence2_ = na
    >
struct joint_view
{
    typedef typename mpl::begin<Sequence1_>::type first1_;
    typedef typename mpl::end<Sequence1_>::type last1_;
    typedef typename mpl::begin<Sequence2_>::type first2_;
    typedef typename mpl::end<Sequence2_>::type last2_;


    typedef Sequence1_ sequence1_;
    typedef Sequence2_ sequence2_;

    typedef joint_view type;
    typedef aux::joint_view_tag tag;
    typedef joint_iter<first1_,last1_,first2_> begin;
    typedef joint_iter<last1_,last1_,last2_> end;
};

template<> struct joint_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : joint_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< joint_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef joint_view< na , na > result_; typedef joint_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< joint_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< joint_view< na , na > > : int_<-1> { }; }

}}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_push_front.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/iter_push_front.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template<
      typename Sequence
    , typename Iterator
    >
struct iter_push_front
{
    typedef typename push_front<
          Sequence
        , typename deref<Iterator>::type
        >::type type;
};

}}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/same_traits.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 2 3 4

namespace boost { namespace mpl {






template< typename Tag >
struct insert_range_impl
{
    template<
          typename Sequence
        , typename Pos
        , typename Range
        >
    struct apply

        : reverse_fold<
              joint_view<
                  iterator_range<typename begin<Sequence>::type,Pos>
                , joint_view<
                      Range
                    , iterator_range<Pos,typename end<Sequence>::type>
                    >
                >
            , typename clear<Sequence>::type
            , insert<_1, begin<_1>, _2>
            >
    {
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/insert_range_impl.hpp" 3 4
    };
};

 template<> struct insert_range_impl<non_sequence_tag> {};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/insert_range.hpp" 2 3 4



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename Pos = na
    , typename Range = na
    >
struct insert_range
    : insert_range_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence,Pos,Range >
{
   
};

template<> struct insert_range< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : insert_range< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< insert_range< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef insert_range< na , na , na > result_; typedef insert_range< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< insert_range< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< insert_range< na , na , na > > : int_<-1> { }; }

}}
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/max_element.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/max_element.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/max_element.hpp" 2 3 4



namespace boost { namespace mpl {



namespace aux {

template< typename Predicate >
struct select_max
{
    template< typename OldIterator, typename Iterator >
    struct apply
    {
        typedef typename apply2<
              Predicate
            , typename deref<OldIterator>::type
            , typename deref<Iterator>::type
            >::type condition_;

        typedef typename if_<
              condition_
            , Iterator
            , OldIterator
            >::type type;
    };
};

}


template<
      typename Sequence = na
    , typename Predicate = less<_,_>
    >
struct max_element
    : iter_fold<
          Sequence
        , typename begin<Sequence>::type
        , protect< aux::select_max<Predicate> >
        >
{
};

template<> struct max_element< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : max_element< T1 > { }; }; template< typename Tag > struct lambda< max_element< na > , Tag , int_<-1> > { typedef false_ is_le; typedef max_element< na > result_; typedef max_element< na > type; }; namespace aux { template< typename T1 > struct template_arity< max_element< T1 > > : int_<1> { }; template<> struct template_arity< max_element< na > > : int_<-1> { }; }

}}
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size_t.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size_t.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size_t_fwd.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size_t.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/size_t.hpp" 2 3 4
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/sizeof.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/sizeof.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename T = na
    >
struct sizeof_
    : mpl::size_t< sizeof(T) >
{
   
};

template<> struct sizeof_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sizeof_< T1 > { }; }; template< typename Tag > struct lambda< sizeof_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sizeof_< na > result_; typedef sizeof_< na > type; }; namespace aux { template< typename T1 > struct template_arity< sizeof_< T1 > > : int_<1> { }; template<> struct template_arity< sizeof_< na > > : int_<-1> { }; }

}}
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/transform.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/transform.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair_view.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair_view.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iterator_category.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/iterator_category.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Iterator = na
    >
struct iterator_category
{
    typedef typename Iterator::category type;
   
};

template<> struct iterator_category< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_category< T1 > { }; }; template< typename Tag > struct lambda< iterator_category< na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_category< na > result_; typedef iterator_category< na > type; }; namespace aux { template< typename T1 > struct template_arity< iterator_category< T1 > > : int_<1> { }; template<> struct template_arity< iterator_category< na > > : int_<-1> { }; }

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair_view.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/min_max.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/min_max.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename N1 = na
    , typename N2 = na
    >
struct min
    : if_< less<N1,N2>,N1,N2 >
{
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct max
    : if_< less<N1,N2>,N2,N1 >
{
};

template<> struct min< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : min< T1 , T2 > { }; }; template< typename Tag > struct lambda< min< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef min< na , na > result_; typedef min< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< min< T1 , T2 > > : int_<2> { }; template<> struct template_arity< min< na , na > > : int_<-1> { }; }
template<> struct max< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : max< T1 , T2 > { }; }; template< typename Tag > struct lambda< max< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef max< na , na > result_; typedef max< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< max< T1 , T2 > > : int_<2> { }; template<> struct template_arity< max< na , na > > : int_<-1> { }; }

}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair_view.hpp" 2 3 4





namespace boost { namespace mpl {

namespace aux {
struct pair_iter_tag;
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair_view.hpp" 3 4
}

template<
      typename Iter1
    , typename Iter2
    , typename Category
    >
struct pair_iter
{
    typedef aux::pair_iter_tag tag;
    typedef Category category;
    typedef Iter1 first;
    typedef Iter2 second;
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/pair_view.hpp" 3 4
};




template< typename Iter1, typename Iter2, typename C >
struct deref< pair_iter<Iter1,Iter2,C> >
{
    typedef pair<
          typename deref<Iter1>::type
        , typename deref<Iter2>::type
        > type;
};

template< typename Iter1, typename Iter2, typename C >
struct next< pair_iter<Iter1,Iter2,C> >
{
    typedef typename mpl::next<Iter1>::type i1_;
    typedef typename mpl::next<Iter2>::type i2_;
    typedef pair_iter<i1_,i2_,C> type;
};

template< typename Iter1, typename Iter2, typename C >
struct prior< pair_iter<Iter1,Iter2,C> >
{
    typedef typename mpl::prior<Iter1>::type i1_;
    typedef typename mpl::prior<Iter2>::type i2_;
    typedef pair_iter<i1_,i2_,C> type;
};




template<> struct advance_impl<aux::pair_iter_tag>
{
    template< typename Iter, typename D > struct apply
    {
        typedef typename mpl::advance< typename Iter::first,D >::type i1_;
        typedef typename mpl::advance< typename Iter::second,D >::type i2_;
        typedef pair_iter<i1_,i2_,typename Iter::category> type;
    };
};

template<> struct distance_impl<aux::pair_iter_tag>
{
    template< typename Iter1, typename Iter2 > struct apply
    {

        typedef typename mpl::distance<
              typename first<Iter1>::type
            , typename first<Iter2>::type
            >::type type;
    };
};


template<
      typename Sequence1 = na
    , typename Sequence2 = na
    >
struct pair_view
{
    typedef nested_begin_end_tag tag;

    typedef typename begin<Sequence1>::type iter1_;
    typedef typename begin<Sequence2>::type iter2_;
    typedef typename min<
          typename iterator_category<iter1_>::type
        , typename iterator_category<iter2_>::type
        >::type category_;

    typedef pair_iter<iter1_,iter2_,category_> begin;

    typedef pair_iter<
          typename end<Sequence1>::type
        , typename end<Sequence2>::type
        , category_
        > end;
};

template<> struct pair_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair_view< na , na > result_; typedef pair_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair_view< na , na > > : int_<-1> { }; }

}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/transform.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/transform.hpp" 2 3 4





namespace boost { namespace mpl {

namespace aux {

template<
      typename Seq
    , typename Op
    , typename In
    >
struct transform1_impl
    : fold<
          Seq
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind1< typename lambda<Op>::type, _2>
            >
        >
{
};

template<
      typename Seq
    , typename Op
    , typename In
    >
struct reverse_transform1_impl
    : reverse_fold<
          Seq
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind1< typename lambda<Op>::type, _2>
            >
        >
{
};

template<
      typename Seq1
    , typename Seq2
    , typename Op
    , typename In
    >
struct transform2_impl
    : fold<
          pair_view<Seq1,Seq2>
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind2<
                  typename lambda<Op>::type
                , bind1<first<>,_2>
                , bind1<second<>,_2>
                >
            >
        >
{
};

template<
      typename Seq1
    , typename Seq2
    , typename Op
    , typename In
    >
struct reverse_transform2_impl
    : reverse_fold<
          pair_view<Seq1,Seq2>
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind2< typename lambda< Op >::type
                , bind1<first<>,_2>
                , bind1<second<>,_2>
                >
            >
        >
{
};

}

 template< typename P1 = na , typename P2 = na , typename P3 = na > struct transform1 : aux::transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct transform1< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_transform1 : aux::reverse_transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_transform1< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform1< na , na , na > result_; typedef transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< transform1< na , na , na > > : int_<-1> { }; } template<> struct reverse_transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform1< na , na , na > result_; typedef reverse_transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_transform1< na , na , na > > : int_<-1> { }; }
 template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct transform2 : aux::transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct transform2< P1 , P2 , P3,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct reverse_transform2 : aux::reverse_transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct reverse_transform2< P1 , P2 , P3,na > : if_< has_push_back<P1> , aux::reverse_transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform2< na , na , na , na > result_; typedef transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform2< na , na , na , na > > : int_<-1> { }; } template<> struct reverse_transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform2< na , na , na , na > result_; typedef reverse_transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform2< na , na , na , na > > : int_<-1> { }; }
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/transform.hpp" 3 4
template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , transform1<Seq1,Seq2OrOperation,OperationOrInserter> , transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform< na , na , na , na > result_; typedef transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform< na , na , na , na > > : int_<-1> { }; }
template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct reverse_transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , reverse_transform1<Seq1,Seq2OrOperation,OperationOrInserter> , reverse_transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct reverse_transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform< na , na , na , na > result_; typedef reverse_transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform< na , na , na , na > > : int_<-1> { }; }



}}
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
namespace boost {

namespace detail { namespace variant {






template <typename Sequence, typename F>
struct max_value
{
private:

    typedef typename mpl::transform1<Sequence, F>::type transformed_;
    typedef typename mpl::max_element<transformed_

        >::type max_it;

public:

    typedef typename mpl::deref<max_it>::type
        type;

};

struct add_alignment
{
    template <typename State, typename Item>
    struct apply
        : mpl::size_t<
              ::boost::integer::static_lcm<
                  State::value
                , ::boost::alignment_of<Item>::value
                >::value
            >
    {};
};
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
class no_fallback_type;

struct find_fallback_type_pred
{
    template <typename Iterator>
    struct apply
    {
    private:
        typedef typename mpl::deref<Iterator>::type t_;

    public:
        typedef mpl::not_< has_nothrow_constructor<t_> > type;
    };
};

template <typename Types>
struct find_fallback_type
{
private:

    typedef typename mpl::end<Types>::type end_it;



    typedef typename mpl::iter_fold_if<
          Types
        , mpl::int_<0>, mpl::protect< mpl::next<> >
        , mpl::protect< find_fallback_type_pred >
        >::type first_result_;

    typedef typename first_result_::first first_result_index;
    typedef typename first_result_::second first_result_it;



    typedef typename mpl::iter_fold_if<
          mpl::iterator_range< first_result_it,end_it >
        , first_result_index, mpl::protect< mpl::next<> >
        , mpl::protect< mpl::not_same_as<boost::blank> >
        >::type second_result_;

    typedef typename second_result_::second second_result_it;

public:


    typedef typename mpl::eval_if<
          is_same< second_result_it,end_it >
        , mpl::if_<
              is_same< first_result_it,end_it >
            , mpl::pair< no_fallback_type,no_fallback_type >
            , first_result_
            >
        , mpl::identity< second_result_ >
        >::type type;

};







template <class Types>
struct is_variant_move_noexcept_constructible {
    typedef typename boost::mpl::find_if<
        Types, mpl::not_<boost::is_nothrow_move_constructible<boost::mpl::_1> >
    >::type iterator_t;

    typedef typename boost::mpl::end<Types>::type end_t;
    typedef typename boost::is_same<
        iterator_t, end_t
    >::type type;
};






template <class Types>
struct is_variant_move_noexcept_assignable {
    typedef typename boost::mpl::find_if<
        Types, mpl::not_<boost::is_nothrow_move_assignable<boost::mpl::_1> >
    >::type iterator_t;

    typedef typename boost::mpl::end<Types>::type end_t;
    typedef typename boost::is_same<
        iterator_t, end_t
    >::type type;
};







template <class T1, class T2>
struct is_constructible_ext:
    boost::mpl::or_<
        boost::is_constructible<
            T1,
            T2
        >,
        boost::is_constructible<
            T1,
            typename boost::add_lvalue_reference<T2>::type
        >
    >
{};

template <class T, class Types>
struct is_variant_constructible_from:
    boost::mpl::not_< boost::is_same<
        typename boost::mpl::find_if<
            Types,
            is_constructible_ext<boost::mpl::_1, T>
        >::type,
        typename boost::mpl::end<Types>::type
    > >
{};

template <typename T0, typename... TN, class Types>
struct is_variant_constructible_from< boost::variant<T0, TN...>, Types >:
    boost::is_same<
        typename boost::mpl::find_if<
            typename boost::variant<T0, TN...>::recursive_enabled_types,
            mpl::not_< is_variant_constructible_from< boost::mpl::_1, Types> >
        >::type,
        typename boost::mpl::end< typename boost::variant<T0, TN...>::recursive_enabled_types >::type
    >
{};

template <typename T0, typename... TN, class Types>
struct is_variant_constructible_from< const boost::variant<T0, TN...>& , Types >:
    is_variant_constructible_from<boost::variant<T0, TN...>, Types >
{};

template <typename T0, typename... TN, class Types>
struct is_variant_constructible_from< boost::variant<T0, TN...>& , Types >:
    is_variant_constructible_from<boost::variant<T0, TN...>, Types >
{};



template <typename T0, typename... TN, class Types>
struct is_variant_constructible_from< boost::variant<T0, TN...>&& , Types >:
    is_variant_constructible_from<boost::variant<T0, TN...>, Types >
{};

template <typename T0, typename... TN, class Types>
struct is_variant_constructible_from< boost::variant<T0, TN...> const && , Types >:
    is_variant_constructible_from<boost::variant<T0, TN...>, Types >
{};
# 333 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename Types, typename NeverUsesBackupFlag>
struct make_storage
{
private:

    typedef typename mpl::eval_if<
          NeverUsesBackupFlag
        , mpl::identity< Types >
        , mpl::push_front<
              Types, backup_holder<void*>
            >
        >::type types;

    typedef typename max_value<
          types, mpl::sizeof_<mpl::_1>
        >::type max_size;



    typedef typename mpl::fold<
          types
        , mpl::size_t<1>
        , add_alignment
        >::type max_alignment;
# 365 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
public:

    typedef ::boost::aligned_storage<
          max_size::value
        , max_alignment::value
        > type;
};






struct destroyer
    : public static_visitor<>
{
public:

    template <typename T>
        void
    internal_visit(T& operand, int) const noexcept
    {
        operand.~T();






        ;
    }

};
# 406 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename T>
class known_get
    : public static_visitor<T&>
{

public:

    T& operator()(T& operand) const noexcept
    {
        return operand;
    }

    template <typename U>
    T& operator()(U&) const
    {

        return ::boost::detail::variant::forced_return< T& >();
    }
};






class copy_into
    : public static_visitor<>
{
private:

    void* storage_;

public:

    explicit copy_into(void* storage) noexcept
        : storage_(storage)
    {
    }

public:

    template <typename T>
        void
    internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
    {
        new(storage_) T( operand.get() );
        ;
    }

    template <typename T>
        void
    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
    {
        new(storage_) T( operand.get() );
        ;
    }

    template <typename T>
        void
    internal_visit(const T& operand, int) const
    {
        new(storage_) T(operand);
        ;
    }

};







class move_into
    : public static_visitor<>
{
private:

    void* storage_;

public:

    explicit move_into(void* storage) noexcept
        : storage_(storage)
    {
    }

public:

    template <typename T>
        void
    internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
    {
        new(storage_) T( ::boost::detail::variant::move(operand.get()) );
        ;
    }

    template <typename T>
        void
    internal_visit(T& operand, int) const noexcept((noexcept((T(boost::declval<T>())))))
    {
        new(storage_) T(::boost::detail::variant::move(operand));
        ;
    }
};
# 519 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
struct assign_storage
    : public static_visitor<>
{
private:

    const void* rhs_storage_;

public:

    explicit assign_storage(const void* rhs_storage) noexcept
        : rhs_storage_(rhs_storage)
    {
    }

public:

    template <typename T>
        void
    internal_visit(backup_holder<T>& lhs_content, long) const
    {
        lhs_content.get()
            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
        ;
    }

    template <typename T>
        void
    internal_visit(const backup_holder<T>& lhs_content, long) const
    {
        lhs_content.get()
            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
        ;
    }

    template <typename T>
        void
    internal_visit(T& lhs_content, int) const
    {







        lhs_content = *static_cast< const T* >(rhs_storage_);
        ;
    }

};







struct move_storage
    : public static_visitor<>
{
private:

    void* rhs_storage_;

public:

    explicit move_storage(void* rhs_storage) noexcept
        : rhs_storage_(rhs_storage)
    {
    }

public:

    template <typename T>
        void
    internal_visit(backup_holder<T>& lhs_content, long) const
    {
        lhs_content.get()
            = ::boost::detail::variant::move(static_cast<backup_holder<T>* >(rhs_storage_)->get());
        ;
    }

    template <typename T>
        void
    internal_visit(const backup_holder<T>& lhs_content, long) const
    {
        lhs_content.get()
            = ::boost::detail::variant::move(static_cast<backup_holder<T>* >(rhs_storage_)->get());
        ;
    }

    template <typename T>
        void
    internal_visit(T& lhs_content, int) const
    {







        lhs_content = ::boost::detail::variant::move(*static_cast<T* >(rhs_storage_));
        ;
    }

};
# 634 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename T>
class direct_assigner
    : public static_visitor<bool>
{
private:

    const T& rhs_;

public:

    explicit direct_assigner(const T& rhs) noexcept
        : rhs_(rhs)
    {
    }

public:

    bool operator()(T& lhs)
    {
        lhs = rhs_;
        return true;
    }

    template <typename U>
    bool operator()(U&) noexcept
    {
        return false;
    }






};
# 677 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename T>
class direct_mover
    : public static_visitor<bool>
{
private:

    T& rhs_;

public:

    explicit direct_mover(T& rhs) noexcept
        : rhs_(rhs)
    {
    }

public:

    bool operator()(T& lhs)
    {
        lhs = ::boost::detail::variant::move(rhs_);
        return true;
    }

    template <typename U>
    bool operator()(U&) noexcept
    {
        return false;
    }






};
# 723 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename Variant>
class backup_assigner
    : public static_visitor<>
{
private:

    Variant& lhs_;
    int rhs_which_;
    const void* rhs_content_;
    void (*copy_rhs_content_)(void*, const void*);

public:

    template<class RhsT>
    backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content)
        : lhs_(lhs)
        , rhs_which_(rhs_which)
        , rhs_content_(&rhs_content)
        , copy_rhs_content_(&construct_impl<RhsT>)
    {
    }

private:

    template<class RhsT>
    static void construct_impl(void* addr, const void* obj)
    {
        new(addr) RhsT(*static_cast<const RhsT*>(obj));
    }

    template <typename LhsT>
    void backup_assign_impl(
          backup_holder<LhsT>& lhs_content
        , mpl::false_
        , long
        )
    {

        backup_holder<LhsT> backup_lhs_content(0);
        backup_lhs_content.swap(lhs_content);


        lhs_content.~backup_holder<LhsT>();

        { try
        {

            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
        }
        catch(...)
        {

            new(lhs_.storage_.address())
                    backup_holder<LhsT>( 0 );

            static_cast<backup_holder<LhsT>* >(lhs_.storage_.address())
                    ->swap(backup_lhs_content);


            throw;;
        }
        }


        lhs_.indicate_which(rhs_which_);
    }

    template <typename LhsT>
    void backup_assign_impl(
          LhsT& lhs_content
        , mpl::true_
        , int
        )
    {

        LhsT backup_lhs_content(
              ::boost::detail::variant::move(lhs_content)
            );


        lhs_content.~LhsT();

        { try
        {

            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
        }
        catch(...)
        {

            new(lhs_.storage_.address())
                LhsT(
                      ::boost::detail::variant::move(backup_lhs_content)
                    );


            throw;;
        }
        }


        lhs_.indicate_which(rhs_which_);
    }

    template <typename LhsT>
    void backup_assign_impl(
          LhsT& lhs_content
        , mpl::false_
        , int
        )
    {

        LhsT* backup_lhs_ptr = new LhsT(lhs_content);


        lhs_content.~LhsT();

        { try
        {

            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
        }
        catch(...)
        {

            new(lhs_.storage_.address())
                backup_holder<LhsT>( backup_lhs_ptr );


            lhs_.indicate_backup_which( lhs_.which() );


            throw;;
        }
        }


        lhs_.indicate_which(rhs_which_);


        delete backup_lhs_ptr;
    }

public:

    template <typename LhsT>
        void
    internal_visit(LhsT& lhs_content, int)
    {
        typedef typename is_nothrow_move_constructible<LhsT>::type
            nothrow_move;

        backup_assign_impl( lhs_content, nothrow_move(), 1L);

        ;
    }






};
# 894 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename Variant>
struct swap_with
    : public static_visitor<>
{
private:

    Variant& toswap_;

public:

    explicit swap_with(Variant& toswap) noexcept
        : toswap_(toswap)
    {
    }

public:

    template <typename T>
    void operator()(T& operand) const
    {

        known_get<T> getter;
        T& other = toswap_.apply_visitor(getter);


        ::boost::detail::variant::move_swap( operand, other );
    }

private:
    swap_with& operator=(const swap_with&);

};







class reflect
    : public static_visitor<const boost::typeindex::type_info&>
{
public:

    template <typename T>
    const boost::typeindex::type_info& operator()(const T&) const noexcept
    {
        return boost::typeindex::type_id<T>().type_info();
    }

};
# 954 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename Variant, typename Comp>
class comparer
    : public static_visitor<bool>
{
private:

    const Variant& lhs_;

public:

    explicit comparer(const Variant& lhs) noexcept
        : lhs_(lhs)
    {
    }

public:

    template <typename T>
    bool operator()(T& rhs_content) const
    {

        known_get<T> getter;
        const T& lhs_content = lhs_.apply_visitor(getter);


        return Comp()(lhs_content, rhs_content);
    }

private:
    comparer& operator=(const comparer&);

};






struct equal_comp
{
    template <typename T>
    bool operator()(const T& lhs, const T& rhs) const
    {
        return lhs == rhs;
    }
};






struct less_comp
{
    template <typename T>
    bool operator()(const T& lhs, const T& rhs) const
    {
        return lhs < rhs;
    }
};
# 1022 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
template <typename Visitor, bool MoveSemantics>
class invoke_visitor
{
private:

    Visitor& visitor_;

public:

    typedef typename Visitor::result_type
        result_type;

public:

    explicit invoke_visitor(Visitor& visitor) noexcept
        : visitor_(visitor)
    {
    }



public:




    template <typename T>
    typename enable_if_c<MoveSemantics && is_same<T, T>::value, result_type>::type internal_visit(T&& operand, int)
    {
        return visitor_(::boost::move<T>(operand));
    }


    template <typename T>
    typename disable_if_c<MoveSemantics && is_same<T, T>::value, result_type>::type internal_visit(T&& operand, int)
    {
        return visitor_(operand);
    }
# 1152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
public:

    template <typename T>
        result_type
    internal_visit(boost::recursive_wrapper<T>& operand, long)
    {
        return internal_visit( operand.get(), 1L );
    }

    template <typename T>
        result_type
    internal_visit(const boost::recursive_wrapper<T>& operand, long)
    {
        return internal_visit( operand.get(), 1L );
    }

    template <typename T>
        result_type
    internal_visit(boost::detail::reference_content<T>& operand, long)
    {
        return internal_visit( operand.get(), 1L );
    }

    template <typename T>
        result_type
    internal_visit(const boost::detail::reference_content<T>& operand, long)
    {
        return internal_visit( operand.get(), 1L );
    }

    template <typename T>
        result_type
    internal_visit(boost::detail::variant::backup_holder<T>& operand, long)
    {
        return internal_visit( operand.get(), 1L );
    }

    template <typename T>
        result_type
    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long)
    {
        return internal_visit( operand.get(), 1L );
    }






};

}}






template <
      typename T0_
    , typename... TN
    >
class variant
{
private:

    typedef variant wknd_self_t;

    struct is_recursive_
        : detail::variant::is_recursive_flag<T0_>
    {
    };

    typedef typename mpl::eval_if<
          is_recursive_
        , T0_
        , mpl::identity< T0_ >
        >::type unwrapped_T0_;

    struct is_sequence_based_
        : detail::variant::is_over_sequence<unwrapped_T0_>
    {
    };



private:

    typedef typename mpl::eval_if<
          is_sequence_based_
        , unwrapped_T0_
        , detail::variant::make_variant_list<
              unwrapped_T0_
            , TN...
            >
        >::type specified_types;

    static_assert(( ::boost::mpl::not_< mpl::empty<specified_types> >::value ), "( ::boost::mpl::not_< mpl::empty<specified_types> >::value )")

          ;

public:
    typedef typename mpl::eval_if<
          is_recursive_
        , mpl::transform<
              specified_types
            , mpl::protect<
                  detail::variant::quoted_enable_recursive<wknd_self_t>
                >
            >
        , mpl::identity< specified_types >
        >::type recursive_enabled_types;

    typedef typename mpl::transform<
          recursive_enabled_types
        , unwrap_recursive<mpl::_1>
        >::type types;

private:

    typedef typename mpl::transform<
          recursive_enabled_types
        , mpl::protect< detail::make_reference_content<> >
        >::type internal_types;

    typedef typename mpl::front<
          internal_types
        >::type internal_T0;
# 1357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
private:

    typedef typename detail::variant::find_fallback_type<
          internal_types
        >::type fallback_type_result_;

    typedef typename fallback_type_result_::first
        fallback_type_index_;
    typedef typename fallback_type_result_::second
        fallback_type_;

    struct has_fallback_type_
        : mpl::not_<
              is_same< fallback_type_, detail::variant::no_fallback_type >
            >
    {
    };

    typedef has_fallback_type_
        never_uses_backup_flag;

    typedef typename detail::variant::make_storage<
          internal_types, never_uses_backup_flag
        >::type storage_t;


    typedef typename detail::variant::is_variant_move_noexcept_constructible<
        internal_types
    > variant_move_noexcept_constructible;

    typedef typename detail::variant::is_variant_move_noexcept_assignable<
        internal_types
    > variant_move_noexcept_assignable;



private:
# 1404 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
    typedef int which_t;
# 1424 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
    private:




    which_t which_;
    storage_t storage_;

    void indicate_which(int which_arg) noexcept
    {
        which_ = static_cast<which_t>( which_arg );
    }

    void indicate_backup_which(int which_arg) noexcept
    {
        which_ = static_cast<which_t>( -(which_arg + 1) );
    }

private:

    bool using_backup() const noexcept
    {
        return which_ < 0;
    }

public:

    int which() const noexcept
    {

        if (using_backup())

            return -(which_ + 1);


        return which_;
    }

private:

    struct initializer
        : ::boost::mpl::iter_fold< recursive_enabled_types , ::boost::mpl::pair< ::boost::detail::variant::initializer_root , ::boost::mpl::int_<0> > , ::boost::mpl::protect< ::boost::detail::variant::make_initializer_node > >::type::first


    {
    };

    void destroy_content() noexcept
    {
        detail::variant::destroyer visitor;
        this->internal_apply_visitor(visitor);
    }

public:

    ~variant() noexcept
    {
        destroy_content();
    }

    variant()

              noexcept((boost::has_nothrow_constructor<internal_T0>::value))

    {
# 1499 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
        new( storage_.address() ) internal_T0();
        indicate_which(0);



    }

private:

    class convert_copy_into
        : public static_visitor<int>
    {
    private:

        void* storage_;

    public:

        explicit convert_copy_into(void* storage) noexcept
            : storage_(storage)
        {
        }

    public:

        template <typename T>
        int internal_visit(T& operand, int) const
        {





            return initializer::initialize(storage_, operand);
        }
# 1543 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
        template <typename T>
        int internal_visit(boost::detail::reference_content<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(const boost::detail::reference_content<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(boost::recursive_wrapper<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(const boost::recursive_wrapper<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

    };

    friend class convert_copy_into;


    class convert_move_into
        : public static_visitor<int>
    {
    private:

        void* storage_;

    public:

        explicit convert_move_into(void* storage) noexcept
            : storage_(storage)
        {
        }

    public:

        template <typename T>
        int internal_visit(T& operand, int) const
        {





            return initializer::initialize(storage_, detail::variant::move(operand) );
        }

        template <typename T>
        int internal_visit(boost::detail::reference_content<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(const boost::detail::reference_content<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(boost::recursive_wrapper<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }

        template <typename T>
        int internal_visit(const boost::recursive_wrapper<T>& operand, long) const
        {
            return internal_visit( operand.get(), 1L );
        }
    };

    friend class convert_move_into;


private:

    template <typename T>
    void convert_construct(
          T& operand
        , int
        , mpl::false_ = mpl::false_()
        )
    {





        indicate_which(
              initializer::initialize(
                  storage_.address()
                , operand
                )
            );
    }


    template <typename T>
    typename boost::enable_if<boost::is_rvalue_reference<T&&> >::type convert_construct(
          T&& operand
        , int
        , mpl::false_ = mpl::false_()
        )
    {





        indicate_which(
              initializer::initialize(
                  storage_.address()
                , detail::variant::move(operand)
                )
            );
    }


    template <typename Variant>
    void convert_construct(
          Variant& operand
        , long
        , mpl::true_
        )
    {
        convert_copy_into visitor(storage_.address());
        indicate_which(
              operand.internal_apply_visitor(visitor)
            );
    }


    template <typename Variant>
    typename boost::enable_if<boost::is_rvalue_reference<Variant&&> >::type convert_construct(
          Variant&& operand
        , long
        , mpl::true_
        )
    {
        convert_move_into visitor(storage_.address());
        indicate_which(
              operand.internal_apply_visitor(visitor)
            );
    }


    template <typename Variant>
    void convert_construct_variant(Variant& operand)
    {




        typedef typename mpl::find_if<
              types
            , is_same<
                  add_const<mpl::_1>
                , const Variant
                >
            >::type found_it;

        typedef typename mpl::end<types>::type not_found;
        typedef typename is_same<
              found_it, not_found
            >::type is_foreign_variant;


        convert_construct(
              operand, 1L
            , is_foreign_variant()
            );
    }


    template <typename Variant>
    typename boost::enable_if<boost::is_rvalue_reference<Variant&&> >::type convert_construct_variant(Variant&& operand)
    {




        typedef typename mpl::find_if<
              types
            , is_same<
                  add_const<mpl::_1>
                , const Variant
                >
            >::type found_it;

        typedef typename mpl::end<types>::type not_found;
        typedef typename is_same<
              found_it, not_found
            >::type is_foreign_variant;


        convert_construct(
              detail::variant::move(operand), 1L
            , is_foreign_variant()
            );
    }


    template <typename U0, typename... UN>
    typename boost::enable_if<mpl::or_<
        boost::is_same<boost::variant<U0, UN...>, variant>,
        boost::detail::variant::is_variant_constructible_from<boost::variant<U0, UN...>&, internal_types>
    > >::type convert_construct(
          boost::variant<U0, UN...>& operand
        , long
        )
    {
        convert_construct_variant(operand);
    }

    template <typename U0, typename... UN>
    typename boost::enable_if<mpl::or_<
        boost::is_same<boost::variant<U0, UN...>, variant>,
        boost::detail::variant::is_variant_constructible_from<const boost::variant<U0, UN...>&, internal_types>
    > >::type convert_construct(
          const boost::variant<U0, UN...>& operand
        , long
        )
    {
        convert_construct_variant(operand);
    }


    template <typename U0, typename... UN>
    typename boost::enable_if<mpl::or_<
        boost::is_same<boost::variant<U0, UN...>, variant>,
        boost::detail::variant::is_variant_constructible_from<boost::variant<U0, UN...>&&, internal_types>
    > >::type convert_construct(
          boost::variant<U0, UN...>&& operand
        , long
        )
    {
        convert_construct_variant( detail::variant::move(operand) );
    }


public:

    template <typename T>
    variant(const T& operand,
        typename boost::enable_if<mpl::or_<
            mpl::and_<
                mpl::not_< boost::is_same<T, variant> >,
                boost::detail::variant::is_variant_constructible_from<const T&, internal_types>
            >,
            boost::is_same<T, boost::recursive_variant_> > >::type* = 0)
    {
        convert_construct(operand, 1L);
    }

    template <typename T>
    variant(
          T& operand
        , typename boost::enable_if<mpl::or_<
            mpl::and_<
                mpl::not_< is_const<T> >,
                mpl::not_< boost::is_same<T, variant> >,
                boost::detail::variant::is_variant_constructible_from<T&, internal_types>
            >,
            boost::is_same<T, boost::recursive_variant_> > >::type* = 0
        )
    {
        convert_construct(operand, 1L);
    }


    template <class T>
    variant(T&& operand,
        typename boost::enable_if<mpl::or_<
            mpl::and_<
                boost::is_rvalue_reference<T&&>,
                mpl::not_< boost::is_const<T> >,
                mpl::not_< boost::is_same<T, variant> >,
                boost::detail::variant::is_variant_constructible_from<T&&, internal_types>
            >,
            boost::is_same<T, boost::recursive_variant_> > >::type* = 0)
    {
        convert_construct( detail::variant::move(operand), 1L);
    }


public:


    variant(const variant& operand)
    {

        detail::variant::copy_into visitor( storage_.address() );
        operand.internal_apply_visitor(visitor);


        indicate_which(operand.which());
    }


    variant(variant&& operand) noexcept((variant_move_noexcept_constructible::type::value))
    {

        detail::variant::move_into visitor( storage_.address() );
        operand.internal_apply_visitor(visitor);


        indicate_which(operand.which());
    }


private:


    template <typename Variant>
    friend class detail::variant::backup_assigner;
# 1900 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
    class assigner
        : public static_visitor<>
    {
    protected:

        variant& lhs_;
        const int rhs_which_;

    public:

        assigner(variant& lhs, int rhs_which) noexcept
            : lhs_(lhs)
            , rhs_which_(rhs_which)
        {
        }

    protected:

        template <typename RhsT, typename B1, typename B2>
        void assign_impl(
              const RhsT& rhs_content
            , mpl::true_
            , B1
            , B2
            ) const noexcept
        {

            lhs_.destroy_content();


            new(lhs_.storage_.address())
                RhsT( rhs_content );


            lhs_.indicate_which(rhs_which_);
        }

        template <typename RhsT, typename B>
        void assign_impl(
              const RhsT& rhs_content
            , mpl::false_
            , mpl::true_
            , B
            ) const
        {

            RhsT temp(rhs_content);


            lhs_.destroy_content();


            new(lhs_.storage_.address())
                RhsT( detail::variant::move(temp) );


            lhs_.indicate_which(rhs_which_);
        }

        void construct_fallback() const noexcept {

            new (lhs_.storage_.address())
                fallback_type_;


            lhs_.indicate_which(
                  fallback_type_index_::value
                );
        }

        template <typename RhsT>
        void assign_impl(
              const RhsT& rhs_content
            , mpl::false_
            , mpl::false_
            , mpl::true_
            ) const
        {

            lhs_.destroy_content();

            { try
            {

                new(lhs_.storage_.address())
                    RhsT( rhs_content );
            }
            catch(...)
            {
                construct_fallback();


                throw;;
            }
            }


            lhs_.indicate_which(rhs_which_);
        }

        template <typename RhsT>
        void assign_impl(
              const RhsT& rhs_content
            , mpl::false_
            , mpl::false_
            , mpl::false_
            ) const
        {
            detail::variant::backup_assigner<wknd_self_t>
                visitor(lhs_, rhs_which_, rhs_content);
            lhs_.internal_apply_visitor(visitor);
        }

    public:

        template <typename RhsT>
            void
        internal_visit(const RhsT& rhs_content, int) const
        {
            typedef typename has_nothrow_copy<RhsT>::type
                nothrow_copy;
            typedef typename mpl::or_<
                  nothrow_copy
                , is_nothrow_move_constructible<RhsT>
                >::type nothrow_move_constructor;

            assign_impl(
                  rhs_content
                , nothrow_copy()
                , nothrow_move_constructor()
                , has_fallback_type_()
                );

            ;
        }






    };

    friend class assigner;
# 2052 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 3 4
    class move_assigner
        : public assigner
    {
    public:

        move_assigner(variant& lhs, int rhs_which) noexcept
            : assigner(lhs, rhs_which)
        {
        }

    private:

        template <typename RhsT, typename B2>
        void assign_impl(
              RhsT& rhs_content
            , mpl::true_
            , mpl::false_
            , B2
            ) const noexcept
        {
            assigner::assign_impl(rhs_content, mpl::true_(), mpl::false_(), B2());
        }

        template <typename RhsT, typename B, typename B2>
        void assign_impl(
              RhsT& rhs_content
            , B
            , mpl::true_
            , B2
            ) const noexcept
        {

            assigner::lhs_.destroy_content();


            new(assigner::lhs_.storage_.address())
                RhsT( detail::variant::move(rhs_content) );


            assigner::lhs_.indicate_which(assigner::rhs_which_);
        }

        template <typename RhsT>
        void assign_impl(
              RhsT& rhs_content
            , mpl::false_
            , mpl::false_
            , mpl::true_
            ) const
        {

            assigner::lhs_.destroy_content();

            { try
            {

                new(assigner::lhs_.storage_.address())
                    RhsT( detail::variant::move(rhs_content) );
            }
            catch(...)
            {
                assigner::construct_fallback();


                throw;;
            }
            }


            assigner::lhs_.indicate_which(assigner::rhs_which_);
        }

        template <typename RhsT>
        void assign_impl(
              RhsT& rhs_content
            , mpl::false_
            , mpl::false_
            , mpl::false_
            ) const
        {
            assigner::assign_impl(rhs_content, mpl::false_(), mpl::false_(), mpl::false_());
        }

    public:

        template <typename RhsT>
            void
        internal_visit(RhsT& rhs_content, int) const
        {
            typedef typename is_nothrow_move_constructible<RhsT>::type
                nothrow_move_constructor;
            typedef typename mpl::or_<
                  nothrow_move_constructor
                , has_nothrow_copy<RhsT>
                >::type nothrow_copy;

            assign_impl(
                  rhs_content
                , nothrow_copy()
                , nothrow_move_constructor()
                , has_fallback_type_()
                );

            ;
        }






    };

    friend class move_assigner;


    void variant_assign(const variant& rhs)
    {

        if (which_ == rhs.which_)
        {

            detail::variant::assign_storage visitor(rhs.storage_.address());
            this->internal_apply_visitor(visitor);
        }
        else
        {

            assigner visitor(*this, rhs.which());
            rhs.internal_apply_visitor(visitor);
        }
    }


    void variant_assign(variant&& rhs)
    {

        if (which_ == rhs.which_)
        {

            detail::variant::move_storage visitor(rhs.storage_.address());
            this->internal_apply_visitor(visitor);
        }
        else
        {

            move_assigner visitor(*this, rhs.which());
            rhs.internal_apply_visitor(visitor);
        }
    }


private:

    template <typename T>
    void assign(const T& rhs)
    {

        detail::variant::direct_assigner<T> direct_assign(rhs);
        if (this->apply_visitor(direct_assign) == false)
        {






            variant temp(rhs);
            variant_assign( detail::variant::move(temp) );
        }
    }


    template <typename T>
    void move_assign(T&& rhs)
    {

        detail::variant::direct_mover<T> direct_move(rhs);
        if (this->apply_visitor(direct_move) == false)
        {






            variant temp( detail::variant::move(rhs) );
            variant_assign( detail::variant::move(temp) );
        }
    }


public:


    template <class T>
    typename boost::enable_if<
        boost::mpl::and_<
            boost::is_rvalue_reference<T&&>,
            mpl::not_< boost::is_const<T> >,
            boost::detail::variant::is_variant_constructible_from<T&&, internal_types>
        >,
        variant&
    >::type operator=(T&& rhs)
    {
        move_assign( detail::variant::move(rhs) );
        return *this;
    }


    template <typename T>
    typename boost::enable_if<
        mpl::or_<
            boost::is_same<T, variant>,
            boost::detail::variant::is_variant_constructible_from<const T&, internal_types>
        >,
        variant&
    >::type operator=(const T& rhs)
    {
        assign(rhs);
        return *this;
    }


    variant& operator=(const variant& rhs)
    {
        variant_assign(rhs);
        return *this;
    }


    variant& operator=(variant&& rhs)

        noexcept((variant_move_noexcept_constructible::type::value && variant_move_noexcept_assignable::type::value))

    {
        variant_assign( detail::variant::move(rhs) );
        return *this;
    }


    void swap(variant& rhs)
    {

        if (which() == rhs.which())
        {

            detail::variant::swap_with<variant> visitor(rhs);
            this->apply_visitor(visitor);
        }
        else
        {

            variant tmp( detail::variant::move(rhs) );
            rhs = detail::variant::move(*this);
            *this = detail::variant::move(tmp);
        }
    }

public:





    bool empty() const noexcept
    {
        return false;
    }

    const boost::typeindex::type_info& type() const
    {
        detail::variant::reflect visitor;
        return this->apply_visitor(visitor);
    }

public:

    template <typename U>
    void operator==(const U&) const
    {
        static_assert(false && sizeof(U), "false && sizeof(U)");
    }

    template <typename U>
    void operator<(const U&) const
    {
        static_assert(false && sizeof(U), "false && sizeof(U)");
    }

    template <typename U>
    void operator!=(const U&) const
    {
        static_assert(false && sizeof(U), "false && sizeof(U)");
    }

    template <typename U>
    void operator>(const U&) const
    {
        static_assert(false && sizeof(U), "false && sizeof(U)");
    }

    template <typename U>
    void operator<=(const U&) const
    {
        static_assert(false && sizeof(U), "false && sizeof(U)");
    }

    template <typename U>
    void operator>=(const U&) const
    {
        static_assert(false && sizeof(U), "false && sizeof(U)");
    }

public:



    bool operator==(const variant& rhs) const
    {
        if (this->which() != rhs.which())
            return false;

        detail::variant::comparer<
              variant, detail::variant::equal_comp
            > visitor(*this);
        return rhs.apply_visitor(visitor);
    }

    bool operator<(const variant& rhs) const
    {




        if (this->which() != rhs.which())
            return this->which() < rhs.which();

        detail::variant::comparer<
              variant, detail::variant::less_comp
            > visitor(*this);
        return rhs.apply_visitor(visitor);
    }



    inline bool operator!=(const variant& rhs) const
    {
        return !(*this == rhs);
    }

    inline bool operator>(const variant& rhs) const
    {
        return rhs < *this;
    }

    inline bool operator<=(const variant& rhs) const
    {
        return !(*this > rhs);
    }

    inline bool operator>=(const variant& rhs) const
    {
        return !(*this < rhs);
    }




    template < typename U0, typename... UN >
    friend class variant;

private:







    template <typename Visitor, typename VoidPtrCV>
    static
        typename Visitor::result_type


    internal_apply_visitor_impl(
          int internal_which
        , int logical_which
        , Visitor& visitor
        , VoidPtrCV storage
        )
    {
        typedef mpl::int_<0> first_which;
        typedef typename mpl::begin<internal_types>::type first_it;
        typedef typename mpl::end<internal_types>::type last_it;

        typedef detail::variant::visitation_impl_step<
              first_it, last_it
            > first_step;

        return detail::variant::visitation_impl(
              internal_which, logical_which
            , visitor, storage, mpl::false_()
            , never_uses_backup_flag()
            , static_cast<first_which*>(0), static_cast<first_step*>(0)
            );
    }

    template <typename Visitor>
        typename Visitor::result_type


    internal_apply_visitor(Visitor& visitor)
    {
        return internal_apply_visitor_impl(
              which_, which(), visitor, storage_.address()
            );
    }

    template <typename Visitor>
        typename Visitor::result_type


    internal_apply_visitor(Visitor& visitor) const
    {
        return internal_apply_visitor_impl(
              which_, which(), visitor, storage_.address()
            );
    }

public:



    template <typename Visitor>
        typename Visitor::result_type


    apply_visitor(Visitor& visitor) &&
    {
        detail::variant::invoke_visitor<Visitor, true> invoker(visitor);
        return this->internal_apply_visitor(invoker);
    }

    template <typename Visitor>
        typename Visitor::result_type


    apply_visitor(Visitor& visitor) const&&
    {
        detail::variant::invoke_visitor<Visitor, true> invoker(visitor);
        return this->internal_apply_visitor(invoker);
    }



    template <typename Visitor>
        typename Visitor::result_type


    apply_visitor(Visitor& visitor)

    &

    {
        detail::variant::invoke_visitor<Visitor, false> invoker(visitor);
        return this->internal_apply_visitor(invoker);
    }

    template <typename Visitor>
        typename Visitor::result_type


    apply_visitor(Visitor& visitor) const

    &

    {
        detail::variant::invoke_visitor<Visitor, false> invoker(visitor);
        return this->internal_apply_visitor(invoker);
    }

};






template <typename Types>
struct make_variant_over
{
private:

    static_assert(( ::boost::mpl::is_sequence<Types>::value ), "( ::boost::mpl::is_sequence<Types>::value )");
    typedef typename boost::mpl::insert_range<
      boost::mpl::list<>
    , boost::mpl::end< boost::mpl::list<> >::type
    , Types
    >::type copied_sequence_t;

public:

    typedef variant<
          detail::variant::over_sequence<copied_sequence_t>
        > type;

};






template < typename T0, typename... TN >
inline void swap(
      variant< T0, TN... >& lhs
    , variant< T0, TN... >& rhs
    )
{
    lhs.swap(rhs);
}

}




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/variant_io.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/variant_io.hpp" 3 4
namespace boost {
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/variant_io.hpp" 3 4
template <
      typename E , typename T
    ,
      typename U0, typename... UN
    >
inline std::basic_ostream< E , T >& operator<<(
      std::basic_ostream< E , T >& out
    , const variant< U0, UN... >& rhs
    );

namespace detail { namespace variant {

template <typename OStream>
class printer
    : public boost::static_visitor<>
{
private:

    OStream& out_;

public:

    explicit printer(OStream& out)
        : out_( out )
    {
    }

public:

    template <typename T>
    void operator()(const T& operand) const
    {
        out_ << operand;
    }

private:
    printer& operator=(const printer&);

};

}}

template <
      typename E , typename T
    ,
      typename U0, typename... UN
    >
inline std::basic_ostream< E , T >& operator<<(
      std::basic_ostream< E , T >& out
    , const variant< U0, UN... >& rhs
    )
{
    detail::variant::printer<
          std::basic_ostream< E , T >
        > visitor(out);

    rhs.apply_visitor(visitor);

    return out;
}

}
# 2581 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/variant.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute.hpp" 3 4
namespace boost {
namespace detail { namespace variant {
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute.hpp" 3 4
template <
      typename T, typename Dest, typename Source
      , typename Arity


    >
struct substitute
{
    typedef T type;
};
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute.hpp" 3 4
template <typename Dest, typename Source> struct substitute< Source , Dest , Source , mpl::int_<-1> > { typedef Dest type; };
template <typename Dest, typename Source> struct substitute< const Source , Dest , Source , mpl::int_<-1> > { typedef const Dest type; };
template <typename Dest, typename Source> struct substitute< volatile Source , Dest , Source , mpl::int_<-1> > { typedef volatile Dest type; };
template <typename Dest, typename Source> struct substitute< const volatile Source , Dest , Source , mpl::int_<-1> > { typedef const volatile Dest type; };
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute.hpp" 3 4
template <typename T, typename Dest, typename Source> struct substitute< T * , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * type; };
template <typename T, typename Dest, typename Source> struct substitute< T * const , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * const type; };
template <typename T, typename Dest, typename Source> struct substitute< T * volatile , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * volatile type; };
template <typename T, typename Dest, typename Source> struct substitute< T * const volatile , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * const volatile type; };






template <typename T, typename Dest, typename Source>
struct substitute<
      T&
    , Dest
    , Source
      , mpl::int_<-1>
    >
{
    typedef typename substitute<
          T, Dest, Source
        >::type & type;
};






template <
      template <typename...> class F
    , typename... Ts
    , typename Dest
    , typename Source
      , typename Arity
    >
struct substitute<
      F<Ts...>
    , Dest
    , Source
      , Arity
    >
{
    typedef F<typename substitute<
          Ts, Dest, Source
        >::type...> type;
};




template <
      typename R
    , typename... A
    , typename Dest
    , typename Source
    >
struct substitute<
      R (*)(A...)
    , Dest
    , Source
      , mpl::int_<-1>
    >
{
private:
    typedef typename substitute< R, Dest, Source >::type r;

public:
    typedef r (*type)(typename substitute<
          A, Dest, Source
        >::type...);
};
# 195 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/substitute.hpp" 3 4
}}
}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_wrapper.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_wrapper.hpp" 3 4
namespace boost {







template <typename T>
class recursive_wrapper
{
public:

    typedef T type;

private:

    T* p_;

public:

    ~recursive_wrapper();
    recursive_wrapper();

    recursive_wrapper(const recursive_wrapper& operand);
    recursive_wrapper(const T& operand);


    recursive_wrapper(recursive_wrapper&& operand);
    recursive_wrapper(T&& operand);


private:

    void assign(const T& rhs);

public:

    recursive_wrapper& operator=(const recursive_wrapper& rhs)
    {
        assign( rhs.get() );
        return *this;
    }

    recursive_wrapper& operator=(const T& rhs)
    {
        assign( rhs );
        return *this;
    }

    void swap(recursive_wrapper& operand) noexcept
    {
        T* temp = operand.p_;
        operand.p_ = p_;
        p_ = temp;
    }



    recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
    {
        swap(rhs);
        return *this;
    }

    recursive_wrapper& operator=(T&& rhs)
    {
        get() = detail::variant::move(rhs);
        return *this;
    }


public:

    T& get() { return *get_pointer(); }
    const T& get() const { return *get_pointer(); }

    T* get_pointer() { return p_; }
    const T* get_pointer() const { return p_; }

};

template <typename T>
recursive_wrapper<T>::~recursive_wrapper()
{
    boost::checked_delete(p_);
}

template <typename T>
recursive_wrapper<T>::recursive_wrapper()
    : p_(new T)
{
}

template <typename T>
recursive_wrapper<T>::recursive_wrapper(const recursive_wrapper& operand)
    : p_(new T( operand.get() ))
{
}

template <typename T>
recursive_wrapper<T>::recursive_wrapper(const T& operand)
    : p_(new T(operand))
{
}


template <typename T>
recursive_wrapper<T>::recursive_wrapper(recursive_wrapper&& operand)
    : p_(new T( detail::variant::move(operand.get()) ))
{
}

template <typename T>
recursive_wrapper<T>::recursive_wrapper(T&& operand)
    : p_(new T( detail::variant::move(operand) ))
{
}


template <typename T>
void recursive_wrapper<T>::assign(const T& rhs)
{
    this->get() = rhs;
}





template <typename T>
inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
{
    lhs.swap(rhs);
}

}
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive.hpp" 2 3 4

namespace boost {
namespace detail { namespace variant {
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/enable_recursive.hpp" 3 4
template <typename T, typename RecursiveVariant, typename NoWrapper>
struct enable_recursive
    : substitute< T , RecursiveVariant , ::boost::recursive_variant_ >


{
};

template <typename T, typename RecursiveVariant>
struct enable_recursive< T,RecursiveVariant,mpl::false_ >
{
private:

    typedef typename substitute< T , RecursiveVariant , ::boost::recursive_variant_ >

         ::type t_;

public:


    typedef typename mpl::if_<
          mpl::or_<
              is_same< t_,T >
            , is_reference<t_>
            , is_pointer<t_>
            >
        , t_
        , boost::recursive_wrapper<t_>
        >::type type;

};







template <typename RecursiveVariant, typename NoWrapper>
struct quoted_enable_recursive
{
    template <typename T>
    struct apply
        : enable_recursive<T, RecursiveVariant, NoWrapper>
    {
    };
};

}}
}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/equal.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/equal.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/bind.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/equal.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/equal.hpp" 2 3 4







namespace boost { namespace mpl {

namespace aux {

template<
      typename Predicate
    , typename LastIterator1
    , typename LastIterator2
    >
struct equal_pred
{
    template<
          typename Iterator2
        , typename Iterator1
        >
    struct apply
    {
        typedef typename and_<
              not_< is_same<Iterator1,LastIterator1> >
            , not_< is_same<Iterator2,LastIterator2> >
            , aux::iter_apply2<Predicate,Iterator1,Iterator2>
            >::type type;
    };
};

template<
      typename Sequence1
    , typename Sequence2
    , typename Predicate
    >
struct equal_impl
{
    typedef typename begin<Sequence1>::type first1_;
    typedef typename begin<Sequence2>::type first2_;
    typedef typename end<Sequence1>::type last1_;
    typedef typename end<Sequence2>::type last2_;

    typedef aux::iter_fold_if_impl<
          first1_
        , first2_
        , next<>
        , protect< aux::equal_pred<Predicate,last1_,last2_> >
        , void_
        , always<false_>
        > fold_;

    typedef typename fold_::iterator iter1_;
    typedef typename fold_::state iter2_;
    typedef and_<
          is_same<iter1_,last1_>
        , is_same<iter2_,last2_>
        > result_;

    typedef typename result_::type type;
};


}


template<
      typename Sequence1 = na
    , typename Sequence2 = na
    , typename Predicate = is_same<_,_>
    >
struct equal
    : aux::msvc_eti_base<
          typename aux::equal_impl<Sequence1,Sequence2,Predicate>::type
        >::type
{
   
};

template<> struct equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal< na , na > result_; typedef equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal< na , na > > : int_<-1> { }; }

}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 3 4
namespace boost {

namespace detail { namespace variant {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 3 4
template <
      typename T0, typename... TN
    , typename RecursiveVariant
      , typename Arity
    >
struct substitute<
      ::boost::variant<
          recursive_flag< T0 >
        , TN...
        >
    , RecursiveVariant
    , ::boost::recursive_variant_
      , Arity
    >
{
    typedef ::boost::variant<
          recursive_flag< T0 >
        , TN...
        > type;
};

template <
      typename T0, typename... TN
    , typename RecursiveVariant
      , typename Arity
    >
struct substitute<
      ::boost::variant<
          ::boost::detail::variant::over_sequence< T0 >
        , TN...
        >
    , RecursiveVariant
    , ::boost::recursive_variant_
      , Arity
    >
{
private:

    typedef T0 initial_types;

    typedef typename mpl::transform<
          initial_types
        , mpl::protect< quoted_enable_recursive<RecursiveVariant,mpl::true_> >
        >::type types;

public:

    typedef typename mpl::if_<
          mpl::equal<initial_types, types, ::boost::is_same<mpl::_1, mpl::_2> >
        , ::boost::variant<
              ::boost::detail::variant::over_sequence< T0 >
            , TN...
            >
        , ::boost::variant< over_sequence<types> >
        >::type type;
};

template <
      typename T0, typename... TN
    , typename RecursiveVariant
      , typename Arity
    >
struct substitute<
      ::boost::variant< T0, TN... >
    , RecursiveVariant
    , ::boost::recursive_variant_
      , Arity
    >
{


    typedef ::boost::variant<
        typename enable_recursive<
              T0
            , RecursiveVariant
            , mpl::true_
        >::type,
        typename enable_recursive<
              TN
            , RecursiveVariant
            , mpl::true_
        >::type...
    > type;
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 3 4
};
# 168 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/recursive_variant.hpp" 3 4
}}






template < typename T0, typename... TN >
struct make_recursive_variant
{
public:

    typedef boost::variant<
          detail::variant::recursive_flag< T0 >
        , TN...
        > type;

};






template <typename Types>
struct make_recursive_variant_over
{
private:

    static_assert(( ::boost::mpl::is_sequence<Types>::value ), "( ::boost::mpl::is_sequence<Types>::value )");

public:

    typedef typename make_recursive_variant<
          detail::variant::over_sequence< Types >
        >::type type;

};

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/element_index.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/detail/element_index.hpp" 3 4
namespace boost { namespace detail { namespace variant {

template <class VariantElement, class T>
struct variant_element_functor :
    boost::mpl::or_<
        boost::is_same<VariantElement, T>,
        boost::is_same<VariantElement, boost::recursive_wrapper<T> >,
        boost::is_same<VariantElement, T& >
    >
{};

template <class Types, class T>
struct element_iterator_impl :
    boost::mpl::find_if<
        Types,
        boost::mpl::or_<
            variant_element_functor<boost::mpl::_1, T>,
            variant_element_functor<boost::mpl::_1, typename boost::remove_cv<T>::type >
        >
    >
{};

template <class Variant, class T>
struct element_iterator :
    element_iterator_impl< typename Variant::types, typename boost::remove_reference<T>::type >
{};

template <class Variant, class T>
struct holds_element :
    boost::mpl::not_<
        boost::is_same<
            typename boost::mpl::end<typename Variant::types>::type,
            typename element_iterator<Variant, T>::type
        >
    >
{};


}}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 2 3 4






namespace boost {
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 3 4
class __attribute__((__visibility__("default"))) bad_get
    : public std::exception
{
public:

    virtual const char * what() const noexcept
    {
        return "boost::bad_get: "
               "failed value get using boost::get";
    }

};
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 3 4
namespace detail { namespace variant {






template <typename T>
struct get_visitor
{
private:

    typedef typename add_pointer<T>::type pointer;
    typedef typename add_reference<T>::type reference;

public:

    typedef pointer result_type;

public:

    pointer operator()(reference operand) const noexcept
    {
        return boost::addressof(operand);
    }

    template <typename U>
    pointer operator()(const U&) const noexcept
    {
        return static_cast<pointer>(0);
    }
};

}}
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 3 4
template <typename U, typename T0, typename... TN >
inline
    typename add_pointer<U>::type
relaxed_get(
      boost::variant< T0, TN... >* operand
     
    ) noexcept
{
    typedef typename add_pointer<U>::type U_ptr;
    if (!operand) return static_cast<U_ptr>(0);

    detail::variant::get_visitor<U> v;
    return operand->apply_visitor(v);
}

template <typename U, typename T0, typename... TN >
inline
    typename add_pointer<const U>::type
relaxed_get(
      const boost::variant< T0, TN... >* operand
     
    ) noexcept
{
    typedef typename add_pointer<const U>::type U_ptr;
    if (!operand) return static_cast<U_ptr>(0);

    detail::variant::get_visitor<const U> v;
    return operand->apply_visitor(v);
}

template <typename U, typename T0, typename... TN >
inline
    typename add_reference<U>::type
relaxed_get(
      boost::variant< T0, TN... >& operand
     
    )
{
    typedef typename add_pointer<U>::type U_ptr;
    U_ptr result = relaxed_get<U>(boost::addressof(operand));

    if (!result)
        boost::throw_exception(bad_get());
    return *result;
}

template <typename U, typename T0, typename... TN >
inline
    typename add_reference<const U>::type
relaxed_get(
      const boost::variant< T0, TN... >& operand
     
    )
{
    typedef typename add_pointer<const U>::type U_ptr;
    U_ptr result = relaxed_get<const U>(boost::addressof(operand));

    if (!result)
        boost::throw_exception(bad_get());
    return *result;
}
# 182 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 3 4
template <typename U, typename T0, typename... TN >
inline
    U&&
relaxed_get(
      boost::variant< T0, TN... >&& operand
     
    )
{
    typedef typename add_pointer<U>::type U_ptr;
    U_ptr result = relaxed_get<U>(boost::addressof(operand));

    if (!result)
        boost::throw_exception(bad_get());
    return static_cast<U&&>(*result);
}
# 207 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/get.hpp" 3 4
template <typename U, typename T0, typename... TN >
inline
    typename add_pointer<U>::type
strict_get(
      boost::variant< T0, TN... >* operand
     
    ) noexcept
{
    static_assert((boost::detail::variant::holds_element<boost::variant< T0, TN... >, U >::value), "boost::variant does not contain specified type U, " "call to boost::get<U>(boost::variant<T...>*) will always return NULL")



     ;

    return relaxed_get<U>(operand);
}

template <typename U, typename T0, typename... TN >
inline
    typename add_pointer<const U>::type
strict_get(
      const boost::variant< T0, TN... >* operand
     
    ) noexcept
{
    static_assert((boost::detail::variant::holds_element<boost::variant< T0, TN... >, const U >::value), "boost::variant does not contain specified type U, " "call to boost::get<U>(const boost::variant<T...>*) will always return NULL")



     ;

    return relaxed_get<U>(operand);
}

template <typename U, typename T0, typename... TN >
inline
    typename add_reference<U>::type
strict_get(
      boost::variant< T0, TN... >& operand
     
    )
{
    static_assert((boost::detail::variant::holds_element<boost::variant< T0, TN... >, U >::value), "boost::variant does not contain specified type U, " "call to boost::get<U>(boost::variant<T...>&) will always throw boost::bad_get exception")



     ;

    return relaxed_get<U>(operand);
}

template <typename U, typename T0, typename... TN >
inline
    typename add_reference<const U>::type
strict_get(
      const boost::variant< T0, TN... >& operand
     
    )
{
    static_assert((boost::detail::variant::holds_element<boost::variant< T0, TN... >, const U >::value), "boost::variant does not contain specified type U, " "call to boost::get<U>(const boost::variant<T...>&) will always throw boost::bad_get exception")



     ;

    return relaxed_get<U>(operand);
}


template <typename U, typename T0, typename... TN >
inline
    U&&
strict_get(
      boost::variant< T0, TN... >&& operand
     
    )
{
    static_assert((!boost::is_lvalue_reference<U>::value), "remove ampersand '&' from template type U in boost::get<U>(boost::variant<T...>&&) ")


     ;

    static_assert((boost::detail::variant::holds_element<boost::variant< T0, TN... >, U >::value), "boost::variant does not contain specified type U, " "call to boost::get<U>(const boost::variant<T...>&) will always throw boost::bad_get exception")



     ;

    return relaxed_get<U>(detail::variant::move(operand));
}






template <typename U, typename T0, typename... TN >
inline
    typename add_pointer<U>::type
get(
      boost::variant< T0, TN... >* operand
     
    ) noexcept
{



    return strict_get<U>(operand);


}

template <typename U, typename T0, typename... TN >
inline
    typename add_pointer<const U>::type
get(
      const boost::variant< T0, TN... >* operand
     
    ) noexcept
{



    return strict_get<U>(operand);

}

template <typename U, typename T0, typename... TN >
inline
    typename add_reference<U>::type
get(
      boost::variant< T0, TN... >& operand
     
    )
{



    return strict_get<U>(operand);

}

template <typename U, typename T0, typename... TN >
inline
    typename add_reference<const U>::type
get(
      const boost::variant< T0, TN... >& operand
     
    )
{



    return strict_get<U>(operand);

}


template <typename U, typename T0, typename... TN >
inline
    U&&
get(
      boost::variant< T0, TN... >&& operand
     
    )
{



    return strict_get<U>(detail::variant::move(operand));

}


}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/visitor_ptr.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/visitor_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/bad_visit.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/bad_visit.hpp" 3 4
namespace boost {







struct bad_visit
    : std::exception
{
public:

    virtual const char * what() const noexcept
    {
        return "boost::bad_visit: "
               "failed visitation using boost::apply_visitor";
    }

};

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/visitor_ptr.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/visitor_ptr.hpp" 3 4
namespace boost {







template <typename T, typename R>
class visitor_ptr_t
    : public static_visitor<R>
{
private:

    typedef R (*visitor_t)(T);

    visitor_t visitor_;

public:

    typedef R result_type;

private:

    typedef typename mpl::eval_if<
          is_reference<T>
        , mpl::identity<T>
        , add_reference<const T>
        >::type argument_fwd_type;

public:

    explicit visitor_ptr_t(visitor_t visitor) noexcept
      : visitor_(visitor)
    {
    }

public:

    template <typename U>
    result_type operator()(const U&) const
    {
        boost::throw_exception(bad_visit());
    }



public:

    result_type operator()(argument_fwd_type operand) const
    {
        return visitor_(operand);
    }
# 107 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant/visitor_ptr.hpp" 3 4
};

template <typename R, typename T>
inline visitor_ptr_t<T,R> visitor_ptr(R (*visitor)(T))
{
    return visitor_ptr_t<T,R>(visitor);
}

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/variant.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 2








# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
namespace json_spirit
{
    enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type };

    struct Null{};

    template< class Config >

    class Value_impl
    {
    public:

        typedef Config Config_type;
        typedef typename Config::String_type String_type;
        typedef typename Config::Object_type Object;
        typedef typename Config::Array_type Array;
        typedef typename String_type::const_pointer Const_str_ptr;

        Value_impl();
        Value_impl( Const_str_ptr value );
        Value_impl( const String_type& value );
        Value_impl( const Object& value );
        Value_impl( const Array& value );
        Value_impl( bool value );
        Value_impl( int value );
        Value_impl( boost::int64_t value );
        Value_impl( boost::uint64_t value );
        Value_impl( double value );

        template< class Iter >
        Value_impl( Iter first, Iter last );

        template< typename T0
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 3 4
                 , typename... 
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
                 TN >
        Value_impl( const boost::variant< T0
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 3 4
                                         , 
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
                                         TN
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 3 4
                                         ... 
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
                                                                      >& variant );

        Value_impl( const Value_impl& other );

        bool operator==( const Value_impl& lhs ) const;

        Value_impl& operator=( const Value_impl& lhs );

        Value_type type() const;

        bool is_uint64() const;
        bool is_null() const;

        const String_type& get_str() const;
        const Object& get_obj() const;
        const Array& get_array() const;
        bool get_bool() const;
        int get_int() const;
        boost::int64_t get_int64() const;
        boost::uint64_t get_uint64() const;
        double get_real() const;

        Object& get_obj();
        Array& get_array();

        template< typename T > T get_value() const;


        static const Value_impl null;

    private:

        void check_type( const Value_type vtype ) const;

        typedef boost::variant< boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >,
                                String_type, bool, boost::int64_t, double, Null, boost::uint64_t > Variant;

        Variant v_;

        class Variant_converter_visitor : public boost::static_visitor< Variant >
        {
        public:

              template< typename T, typename A, template< typename, typename > class Cont >
              Variant operator()( const Cont< T, A >& cont ) const
              {
                  return Array( cont.begin(), cont.end() );
              }

              Variant operator()( int i ) const
              {
                  return static_cast< boost::int64_t >( i );
              }

              template<class T>
              Variant operator()( const T& t ) const
              {
                  return t;
              }
        };
    };



    template< class Config >
    struct Pair_impl
    {
        typedef typename Config::String_type String_type;
        typedef typename Config::Value_type Value_type;

        Pair_impl()
        {
        }

        Pair_impl( const String_type& name, const Value_type& value );

        bool operator==( const Pair_impl& lhs ) const;

        String_type name_;
        Value_type value_;
    };


    template< class String >
    struct Config_vector
    {
        typedef String String_type;
        typedef Value_impl< Config_vector > Value_type;
        typedef Pair_impl < Config_vector > Pair_type;
        typedef std::vector< Value_type > Array_type;
        typedef std::vector< Pair_type > Object_type;

        static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
        {
            obj.push_back( Pair_type( name , value ) );

            return obj.back().value_;
        }

        static String_type get_name( const Pair_type& pair )
        {
            return pair.name_;
        }

        static Value_type get_value( const Pair_type& pair )
        {
            return pair.value_;
        }
    };





    typedef Config_vector< std::string > Config;

    typedef Config::Value_type Value;
    typedef Config::Pair_type Pair;
    typedef Config::Object_type Object;
    typedef Config::Array_type Array;
# 198 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
    template< class String >
    struct Config_map
    {
        typedef String String_type;
        typedef Value_impl< Config_map > Value_type;
        typedef std::vector< Value_type > Array_type;
        typedef std::map< String_type, Value_type > Object_type;
        typedef std::pair< String_type, Value_type > Pair_type;

        static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
        {
            return obj[ name ] = value;
        }

        static String_type get_name( const Pair_type& pair )
        {
            return pair.first;
        }

        static Value_type get_value( const Pair_type& pair )
        {
            return pair.second;
        }
    };





    typedef Config_map< std::string > mConfig;

    typedef mConfig::Value_type mValue;
    typedef mConfig::Object_type mObject;
    typedef mConfig::Array_type mArray;
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
    inline bool operator==( const Null&, const Null& )
    {
        return true;
    }

    template< class Config >
    const Value_impl< Config > Value_impl< Config >::null;

    template< class Config >
    Value_impl< Config >::Value_impl()
    : v_( Null() )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( const Const_str_ptr value )
    : v_( String_type( value ) )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( const String_type& value )
    : v_( value )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( const Object& value )
    : v_( value )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( const Array& value )
    : v_( value )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( bool value )
    : v_( value )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( int value )
    : v_( static_cast< boost::int64_t >( value ) )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( boost::int64_t value )
    : v_( value )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( boost::uint64_t value )
    : v_( value )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( double value )
    : v_( value )
    {
    }

    template< class Config >
    Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
    : v_( other.v_ )
    {
    }

    template< class Config >
    template< class Iter >
    Value_impl< Config >::Value_impl( Iter first, Iter last )
    : v_( Array( first, last ) )
    {
    }

    template< class Config >
    template< typename T0
# 330 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 3 4
             , typename... 
# 330 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
             TN >
    Value_impl< Config >::Value_impl( const boost::variant< T0
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 3 4
                                                           , 
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
                                                           TN
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h" 3 4
                                                           ... 
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_value.h"
                                                                                        >& variant )
    : v_( boost::apply_visitor( Variant_converter_visitor(), variant) )
    {
    }

    template< class Config >
    Value_impl< Config >& Value_impl< Config >::operator=( const Value_impl& lhs )
    {
        Value_impl tmp( lhs );

        std::swap( v_, tmp.v_ );

        return *this;
    }

    template< class Config >
    bool Value_impl< Config >::operator==( const Value_impl& lhs ) const
    {
        if( this == &lhs ) return true;

        if( type() != lhs.type() ) return false;

        return v_ == lhs.v_;
    }

    template< class Config >
    Value_type Value_impl< Config >::type() const
    {
        if( is_uint64() )
        {
            return int_type;
        }

        return static_cast< Value_type >( v_.which() );
    }

    template< class Config >
    bool Value_impl< Config >::is_uint64() const
    {
        return v_.which() == null_type + 1;
    }

    template< class Config >
    bool Value_impl< Config >::is_null() const
    {
        return type() == null_type;
    }

    template< class Config >
    void Value_impl< Config >::check_type( const Value_type vtype ) const
    {
        if( type() != vtype )
        {
            std::ostringstream os;

            os << "value type is " << type() << " not " << vtype;

            throw std::runtime_error( os.str() );
        }
    }

    template< class Config >
    const typename Config::String_type& Value_impl< Config >::get_str() const
    {
        check_type( str_type );

        return *boost::get< String_type >( &v_ );
    }

    template< class Config >
    const typename Value_impl< Config >::Object& Value_impl< Config >::get_obj() const
    {
        check_type( obj_type );

        return *boost::get< Object >( &v_ );
    }

    template< class Config >
    const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const
    {
        check_type( array_type );

        return *boost::get< Array >( &v_ );
    }

    template< class Config >
    bool Value_impl< Config >::get_bool() const
    {
        check_type( bool_type );

        return boost::get< bool >( v_ );
    }

    template< class Config >
    int Value_impl< Config >::get_int() const
    {
        check_type( int_type );

        return static_cast< int >( get_int64() );
    }

    template< class Config >
    boost::int64_t Value_impl< Config >::get_int64() const
    {
        check_type( int_type );

        if( is_uint64() )
        {
            return static_cast< boost::int64_t >( get_uint64() );
        }

        return boost::get< boost::int64_t >( v_ );
    }

    template< class Config >
    boost::uint64_t Value_impl< Config >::get_uint64() const
    {
        check_type( int_type );

        if( !is_uint64() )
        {
            return static_cast< boost::uint64_t >( get_int64() );
        }

        return boost::get< boost::uint64_t >( v_ );
    }

    template< class Config >
    double Value_impl< Config >::get_real() const
    {
        if( type() == int_type )
        {
            return is_uint64() ? static_cast< double >( get_uint64() )
                               : static_cast< double >( get_int64() );
        }

        check_type( real_type );

        return boost::get< double >( v_ );
    }

    template< class Config >
    typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
    {
        check_type( obj_type );

        return *boost::get< Object >( &v_ );
    }

    template< class Config >
    typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
    {
        check_type( array_type );

        return *boost::get< Array >( &v_ );
    }

    template< class Config >
    Pair_impl< Config >::Pair_impl( const String_type& name, const Value_type& value )
    : name_( name )
    , value_( value )
    {
    }

    template< class Config >
    bool Pair_impl< Config >::operator==( const Pair_impl< Config >& lhs ) const
    {
        if( this == &lhs ) return true;

        return ( name_ == lhs.name_ ) && ( value_ == lhs.value_ );
    }



    template < class String_type >
    String_type to_str( const char* c_str )
    {
        String_type result;

        for( const char* p = c_str; *p != 0; ++p )
        {
            result += *p;
        }

        return result;
    }



    namespace internal_
    {
        template< typename T >
        struct Type_to_type
        {
        };

        template< class Value >
        int get_value( const Value& value, Type_to_type< int > )
        {
            return value.get_int();
        }

        template< class Value >
        boost::int64_t get_value( const Value& value, Type_to_type< boost::int64_t > )
        {
            return value.get_int64();
        }

        template< class Value >
        boost::uint64_t get_value( const Value& value, Type_to_type< boost::uint64_t > )
        {
            return value.get_uint64();
        }

        template< class Value >
        double get_value( const Value& value, Type_to_type< double > )
        {
            return value.get_real();
        }

        template< class Value >
        typename Value::String_type get_value( const Value& value, Type_to_type< typename Value::String_type > )
        {
            return value.get_str();
        }

        template< class Value >
        typename Value::Array get_value( const Value& value, Type_to_type< typename Value::Array > )
        {
            return value.get_array();
        }

        template< class Value >
        typename Value::Object get_value( const Value& value, Type_to_type< typename Value::Object > )
        {
            return value.get_obj();
        }

        template< class Value >
        bool get_value( const Value& value, Type_to_type< bool > )
        {
            return value.get_bool();
        }
    }

    template< class Config >
    template< typename T >
    T Value_impl< Config >::get_value() const
    {
        return internal_::get_value( *this, internal_::Type_to_type< T >() );
    }
}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_reader.h" 1
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_reader.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_error_position.h" 1
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_error_position.h"
namespace json_spirit
{




    struct Error_position
    {
        Error_position();
        Error_position( unsigned int line, unsigned int column, const std::string& reason );
        bool operator==( const Error_position& lhs ) const;
        unsigned int line_;
        unsigned int column_;
        std::string reason_;
    };

    inline Error_position::Error_position()
    : line_( 0 )
    , column_( 0 )
    {
    }

    inline Error_position::Error_position( unsigned int line, unsigned int column, const std::string& reason )
    : line_( line )
    , column_( column )
    , reason_( reason )
    {
    }

    inline bool Error_position::operator==( const Error_position& lhs ) const
    {
        if( this == &lhs ) return true;

        return ( reason_ == lhs.reason_ ) &&
               ( line_ == lhs.line_ ) &&
               ( column_ == lhs.column_ );
    }
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_reader.h" 2


namespace json_spirit
{



    bool read( const std::string& s, Value& value );
    bool read( std::istream& is, Value& value );
    bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );

    void read_or_throw( const std::string& s, Value& value );
    void read_or_throw( std::istream& is, Value& value );
    void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_reader.h"
    bool read( const std::string& s, mValue& value );
    bool read( std::istream& is, mValue& value );
    bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );

    void read_or_throw( const std::string& s, mValue& value );
    void read_or_throw( std::istream& is, mValue& value );
    void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_reader.h"
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_writer.h" 1
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_writer.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_writer_options.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_writer_options.h"
namespace json_spirit
{
    enum Output_options{ pretty_print = 0x01,

                         raw_utf8 = 0x02,




                         remove_trailing_zeros = 0x04,

                         single_line_arrays = 0x08,


                       };
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_writer.h" 2


namespace json_spirit
{



    void write( const Value& value, std::ostream& os, unsigned int options = 0 );
    std::string write( const Value& value, unsigned int options = 0 );



    void write( const mValue& value, std::ostream& os, unsigned int options = 0 );
    std::string write( const mValue& value, unsigned int options = 0 );
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_writer.h"
    void write_formatted( const Value& value, std::ostream& os );
    std::string write_formatted( const Value& value );


    void write_formatted( const mValue& value, std::ostream& os );
    std::string write_formatted( const mValue& value );
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_writer.h"
}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_utils.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit_utils.h"
namespace json_spirit
{
    template< class Obj_t, class Map_t >
    void obj_to_map( const Obj_t& obj, Map_t& mp_obj )
    {
        mp_obj.clear();

        for( typename Obj_t::const_iterator i = obj.begin(); i != obj.end(); ++i )
        {
            mp_obj[ i->name_ ] = i->value_;
        }
    }

    template< class Obj_t, class Map_t >
    void map_to_obj( const Map_t& mp_obj, Obj_t& obj )
    {
        obj.clear();

        for( typename Map_t::const_iterator i = mp_obj.begin(); i != mp_obj.end(); ++i )
        {
            obj.push_back( typename Obj_t::value_type( i->first, i->second ) );
        }
    }


    typedef std::map< std::string, Value > Mapped_obj;






    template< class Object_type, class String_type >
    const typename Object_type::value_type::Value_type& find_value( const Object_type& obj, const String_type& name )
    {
        for( typename Object_type::const_iterator i = obj.begin(); i != obj.end(); ++i )
        {
            if( i->name_ == name )
            {
                return i->value_;
            }
        }

        return Object_type::value_type::Value_type::null;
    }
}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/json_spirit/json_spirit.h" 2
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 2



       


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Formatter.h" 1






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer_fwd.h" 1
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Formatter.h" 2




# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stdarg.h" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Formatter.h" 2



namespace ceph {

  struct FormatterAttrs {
    std::list< std::pair<std::string, std::string> > attrs;

    FormatterAttrs(const char *attr, ...);
  };

  class Formatter {
  public:
    class ObjectSection {
      Formatter& formatter;

    public:
      ObjectSection(Formatter& f, const char *name) : formatter(f) {
        formatter.open_object_section(name);
      }
      ObjectSection(Formatter& f, const char *name, const char *ns) : formatter(f) {
        formatter.open_object_section_in_ns(name, ns);
      }
      ~ObjectSection() {
        formatter.close_section();
      }
    };
    class ArraySection {
      Formatter& formatter;

    public:
      ArraySection(Formatter& f, const char *name) : formatter(f) {
        formatter.open_array_section(name);
      }
      ArraySection(Formatter& f, const char *name, const char *ns) : formatter(f) {
        formatter.open_array_section_in_ns(name, ns);
      }
      ~ArraySection() {
        formatter.close_section();
      }
    };

    static Formatter *create(std::string_view type,
        std::string_view default_type,
        std::string_view fallback);
    static Formatter *create(std::string_view type,
        std::string_view default_type) {
      return create(type, default_type, "");
    }
    static Formatter *create(std::string_view type) {
      return create(type, "json-pretty", "");
    }

    Formatter();
    virtual ~Formatter();

    virtual void enable_line_break() = 0;
    virtual void flush(std::ostream& os) = 0;
    void flush(bufferlist &bl);
    virtual void reset() = 0;

    virtual void set_status(int status, const char* status_name) = 0;
    virtual void output_header() = 0;
    virtual void output_footer() = 0;

    virtual void open_array_section(const char *name) = 0;
    virtual void open_array_section_in_ns(const char *name, const char *ns) = 0;
    virtual void open_object_section(const char *name) = 0;
    virtual void open_object_section_in_ns(const char *name, const char *ns) = 0;
    virtual void close_section() = 0;
    virtual void dump_unsigned(const char *name, uint64_t u) = 0;
    virtual void dump_int(const char *name, int64_t s) = 0;
    virtual void dump_float(const char *name, double d) = 0;
    virtual void dump_string(const char *name, std::string_view s) = 0;
    virtual void dump_bool(const char *name, bool b)
    {
      dump_format_unquoted(name, "%s", (b ? "true" : "false"));
    }
    template<typename T>
    void dump_object(const char *name, const T& foo) {
      open_object_section(name);
      foo.dump(this);
      close_section();
    }
    virtual std::ostream& dump_stream(const char *name) = 0;
    virtual void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) = 0;
    virtual void dump_format(const char *name, const char *fmt, ...);
    virtual void dump_format_ns(const char *name, const char *ns, const char *fmt, ...);
    virtual void dump_format_unquoted(const char *name, const char *fmt, ...);
    virtual int get_len() const = 0;
    virtual void write_raw_data(const char *data) = 0;

    virtual void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs)
    {
      open_array_section(name);
    }
    virtual void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs)
    {
      open_object_section(name);
    }
    virtual void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs)
    {
      dump_string(name, s);
    }
  };

  class copyable_sstream : public std::stringstream {
  public:
    copyable_sstream() {}
    copyable_sstream(const copyable_sstream& rhs) {
      str(rhs.str());
    }
    copyable_sstream& operator=(const copyable_sstream& rhs) {
      str(rhs.str());
      return *this;
    }
  };

  class JSONFormatter : public Formatter {
  public:
    explicit JSONFormatter(bool p = false);

    void set_status(int status, const char* status_name) override {};
    void output_header() override {};
    void output_footer() override {};
    void enable_line_break() override { m_line_break_enabled = true; }
    void flush(std::ostream& os) override;
    using Formatter::flush;
    void reset() override;
    void open_array_section(const char *name) override;
    void open_array_section_in_ns(const char *name, const char *ns) override;
    void open_object_section(const char *name) override;
    void open_object_section_in_ns(const char *name, const char *ns) override;
    void close_section() override;
    void dump_unsigned(const char *name, uint64_t u) override;
    void dump_int(const char *name, int64_t s) override;
    void dump_float(const char *name, double d) override;
    void dump_string(const char *name, std::string_view s) override;
    std::ostream& dump_stream(const char *name) override;
    void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
    int get_len() const override;
    void write_raw_data(const char *data) override;

  protected:
    virtual bool handle_value(const char *name, std::string_view s, bool quoted) {
      return false;
    }

    virtual bool handle_open_section(const char *name, const char *ns, bool is_array) {
      return false;
    }

    virtual bool handle_close_section() {
      return false;
    }

  private:

    struct json_formatter_stack_entry_d {
      int size;
      bool is_array;
      json_formatter_stack_entry_d() : size(0), is_array(false) { }
    };

    bool m_pretty;
    void open_section(const char *name, const char *ns, bool is_array);
    void print_quoted_string(std::string_view s);
    void print_name(const char *name);
    void print_comma(json_formatter_stack_entry_d& entry);
    void finish_pending_string();

    template <class T>
    void add_value(const char *name, T val);
    void add_value(const char *name, std::string_view val, bool quoted);

    copyable_sstream m_ss;
    copyable_sstream m_pending_string;
    std::string m_pending_name;
    std::list<json_formatter_stack_entry_d> m_stack;
    bool m_is_pending_string;
    bool m_line_break_enabled = false;
  };

  template <class T>
  void add_value(const char *name, T val);

  class XMLFormatter : public Formatter {
  public:
    static const char *XML_1_DTD;
    XMLFormatter(bool pretty = false, bool lowercased = false, bool underscored = true);

    void set_status(int status, const char* status_name) override {}
    void output_header() override;
    void output_footer() override;

    void enable_line_break() override { m_line_break_enabled = true; }
    void flush(std::ostream& os) override;
    using Formatter::flush;
    void reset() override;
    void open_array_section(const char *name) override;
    void open_array_section_in_ns(const char *name, const char *ns) override;
    void open_object_section(const char *name) override;
    void open_object_section_in_ns(const char *name, const char *ns) override;
    void close_section() override;
    void dump_unsigned(const char *name, uint64_t u) override;
    void dump_int(const char *name, int64_t s) override;
    void dump_float(const char *name, double d) override;
    void dump_string(const char *name, std::string_view s) override;
    std::ostream& dump_stream(const char *name) override;
    void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
    int get_len() const override;
    void write_raw_data(const char *data) override;


    void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
    void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
    void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs) override;

  protected:
    void open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs);
    void finish_pending_string();
    void print_spaces();
    void get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str);
    char to_lower_underscore(char c) const;

    std::stringstream m_ss, m_pending_string;
    std::deque<std::string> m_sections;
    const bool m_pretty;
    const bool m_lowercased;
    const bool m_underscored;
    std::string m_pending_string_name;
    bool m_header_done;
    bool m_line_break_enabled = false;
  private:
    template <class T>
    void add_value(const char *name, T val);
  };

  class TableFormatter : public Formatter {
  public:
    explicit TableFormatter(bool keyval = false);

    void set_status(int status, const char* status_name) override {};
    void output_header() override {};
    void output_footer() override {};
    void enable_line_break() override {};
    void flush(std::ostream& os) override;
    using Formatter::flush;
    void reset() override;
    void open_array_section(const char *name) override;
    void open_array_section_in_ns(const char *name, const char *ns) override;
    void open_object_section(const char *name) override;
    void open_object_section_in_ns(const char *name, const char *ns) override;

    void open_array_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;
    void open_object_section_with_attrs(const char *name, const FormatterAttrs& attrs) override;

    void close_section() override;
    void dump_unsigned(const char *name, uint64_t u) override;
    void dump_int(const char *name, int64_t s) override;
    void dump_float(const char *name, double d) override;
    void dump_string(const char *name, std::string_view s) override;
    void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
    void dump_string_with_attrs(const char *name, std::string_view s, const FormatterAttrs& attrs) override;
    std::ostream& dump_stream(const char *name) override;

    int get_len() const override;
    void write_raw_data(const char *data) override;
    void get_attrs_str(const FormatterAttrs *attrs, std::string& attrs_str);

  private:
    template <class T>
    void add_value(const char *name, T val);
    void open_section_in_ns(const char *name, const char *ns, const FormatterAttrs *attrs);
    std::vector< std::vector<std::pair<std::string, std::string> > > m_vec;
    std::stringstream m_ss;
    size_t m_vec_index(const char* name);
    std::string get_section_name(const char* name);
    void finish_pending_string();
    std::string m_pending_name;
    bool m_keyval;

    int m_section_open;
    std::vector< std::string > m_section;
    std::map<std::string, int> m_section_cnt;
    std::vector<size_t> m_column_size;
    std::vector< std::string > m_column_name;
  };

  std::string fixed_to_string(int64_t num, int scale);
  std::string fixed_u_to_string(uint64_t num, int scale);
}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 2

using namespace json_spirit;


class JSONObj;

class JSONObjIter {
  typedef map<string, JSONObj *>::iterator map_iter_t;
  map_iter_t cur;
  map_iter_t last;

public:
  JSONObjIter();
  ~JSONObjIter();
  void set(const JSONObjIter::map_iter_t &_cur, const JSONObjIter::map_iter_t &_end);

  void operator++();
  JSONObj *operator*();

  bool end() const {
    return (cur == last);
  }
};

class JSONObj
{
  JSONObj *parent;
public:
  struct data_val {
    string str;
    bool quoted{false};

    void set(std::string_view s, bool q) {
      str = s;
      quoted = q;
    }
  };
protected:
  string name;
  Value data;
  struct data_val val;
  bool data_quoted{false};
  multimap<string, JSONObj *> children;
  map<string, data_val> attr_map;
  void handle_value(Value v);

public:

  JSONObj() : parent(
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 3 4
                    __null
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h"
                        ){}

  virtual ~JSONObj();

  void init(JSONObj *p, Value v, string n);

  string& get_name() { return name; }
  data_val& get_data_val() { return val; }
  const string& get_data() { return val.str; }
  bool get_data(const string& key, data_val *dest);
  JSONObj *get_parent();
  void add_child(string el, JSONObj *child);
  bool get_attr(string name, data_val& attr);
  JSONObjIter find(const string& name);
  JSONObjIter find_first();
  JSONObjIter find_first(const string& name);
  JSONObj *find_obj(const string& name);

  friend ostream& operator<<(ostream &out,
        const JSONObj &obj);

  bool is_array();
  bool is_object();
  vector<string> get_array_elements();
};

static inline ostream& operator<<(ostream &out, const JSONObj::data_val& dv) {
  const char *q = (dv.quoted ? "\"" : "");
   out << q << dv.str << q;
   return out;
}

class JSONParser : public JSONObj
{
  int buf_len;
  string json_buffer;
  bool success;
public:
  JSONParser();
  ~JSONParser() override;
  void handle_data(const char *s, int len);

  bool parse(const char *buf_, int len);
  bool parse(int len);
  bool parse();
  bool parse(const char *file_name);

  const char *get_json() { return json_buffer.c_str(); }
  void set_failure() { success = false; }
};

void encode_json(const char *name, const JSONObj::data_val& v, Formatter *f);

class JSONDecoder {
public:
  struct err {
    string message;

    err(const string& m) : message(m) {}
  };

  JSONParser parser;

  JSONDecoder(bufferlist& bl) {
    if (!parser.parse(bl.c_str(), bl.length())) {
      cout << "JSONDecoder::err()" << std::endl;
      throw JSONDecoder::err("failed to parse JSON input");
    }
  }

  template<class T>
  static bool decode_json(const char *name, T& val, JSONObj *obj, bool mandatory = false);

  template<class C>
  static bool decode_json(const char *name, C& container, void (*cb)(C&, JSONObj *obj), JSONObj *obj, bool mandatory = false);

  template<class T>
  static void decode_json(const char *name, T& val, const T& default_val, JSONObj *obj);

  template<class T>
  static bool decode_json(const char *name, boost::optional<T>& val, JSONObj *obj, bool mandatory = false);

};

template<class T>
void decode_json_obj(T& val, JSONObj *obj)
{
  val.decode_json(obj);
}

static inline void decode_json_obj(string& val, JSONObj *obj)
{
  val = obj->get_data();
}

static inline void decode_json_obj(JSONObj::data_val& val, JSONObj *obj)
{
  val = obj->get_data_val();
}

void decode_json_obj(unsigned long long& val, JSONObj *obj);
void decode_json_obj(long long& val, JSONObj *obj);
void decode_json_obj(unsigned long& val, JSONObj *obj);
void decode_json_obj(long& val, JSONObj *obj);
void decode_json_obj(unsigned& val, JSONObj *obj);
void decode_json_obj(int& val, JSONObj *obj);
void decode_json_obj(bool& val, JSONObj *obj);
void decode_json_obj(bufferlist& val, JSONObj *obj);
class utime_t;
void decode_json_obj(utime_t& val, JSONObj *obj);

template<class T>
void decode_json_obj(list<T>& l, JSONObj *obj)
{
  l.clear();

  JSONObjIter iter = obj->find_first();

  for (; !iter.end(); ++iter) {
    T val;
    JSONObj *o = *iter;
    decode_json_obj(val, o);
    l.push_back(val);
  }
}

template<class T>
void decode_json_obj(deque<T>& l, JSONObj *obj)
{
  l.clear();

  JSONObjIter iter = obj->find_first();

  for (; !iter.end(); ++iter) {
    T val;
    JSONObj *o = *iter;
    decode_json_obj(val, o);
    l.push_back(val);
  }
}

template<class T>
void decode_json_obj(set<T>& l, JSONObj *obj)
{
  l.clear();

  JSONObjIter iter = obj->find_first();

  for (; !iter.end(); ++iter) {
    T val;
    JSONObj *o = *iter;
    decode_json_obj(val, o);
    l.insert(val);
  }
}

template<class T>
void decode_json_obj(vector<T>& l, JSONObj *obj)
{
  l.clear();

  JSONObjIter iter = obj->find_first();

  for (; !iter.end(); ++iter) {
    T val;
    JSONObj *o = *iter;
    decode_json_obj(val, o);
    l.push_back(val);
  }
}

template<class K, class V, class C = std::less<K> >
void decode_json_obj(map<K, V, C>& m, JSONObj *obj)
{
  m.clear();

  JSONObjIter iter = obj->find_first();

  for (; !iter.end(); ++iter) {
    K key;
    V val;
    JSONObj *o = *iter;
    JSONDecoder::decode_json("key", key, o);
    JSONDecoder::decode_json("val", val, o);
    m[key] = val;
  }
}

template<class K, class V>
void decode_json_obj(multimap<K, V>& m, JSONObj *obj)
{
  m.clear();

  JSONObjIter iter = obj->find_first();

  for (; !iter.end(); ++iter) {
    K key;
    V val;
    JSONObj *o = *iter;
    JSONDecoder::decode_json("key", key, o);
    JSONDecoder::decode_json("val", val, o);
    m.insert(make_pair(key, val));
  }
}

template<class C>
void decode_json_obj(C& container, void (*cb)(C&, JSONObj *obj), JSONObj *obj)
{
  container.clear();

  JSONObjIter iter = obj->find_first();

  for (; !iter.end(); ++iter) {
    JSONObj *o = *iter;
    cb(container, o);
  }
}

template<class T>
bool JSONDecoder::decode_json(const char *name, T& val, JSONObj *obj, bool mandatory)
{
  JSONObjIter iter = obj->find_first(name);
  if (iter.end()) {
    if (mandatory) {
      string s = "missing mandatory field " + string(name);
      throw err(s);
    }
    val = T();
    return false;
  }

  try {
    decode_json_obj(val, *iter);
  } catch (err& e) {
    string s = string(name) + ": ";
    s.append(e.message);
    throw err(s);
  }

  return true;
}

template<class C>
bool JSONDecoder::decode_json(const char *name, C& container, void (*cb)(C&, JSONObj *), JSONObj *obj, bool mandatory)
{
  container.clear();

  JSONObjIter iter = obj->find_first(name);
  if (iter.end()) {
    if (mandatory) {
      string s = "missing mandatory field " + string(name);
      throw err(s);
    }
    return false;
  }

  try {
    decode_json_obj(container, cb, *iter);
  } catch (err& e) {
    string s = string(name) + ": ";
    s.append(e.message);
    throw err(s);
  }

  return true;
}

template<class T>
void JSONDecoder::decode_json(const char *name, T& val, const T& default_val, JSONObj *obj)
{
  JSONObjIter iter = obj->find_first(name);
  if (iter.end()) {
    val = default_val;
    return;
  }

  try {
    decode_json_obj(val, *iter);
  } catch (err& e) {
    val = default_val;
    string s = string(name) + ": ";
    s.append(e.message);
    throw err(s);
  }
}

template<class T>
bool JSONDecoder::decode_json(const char *name, boost::optional<T>& val, JSONObj *obj, bool mandatory)
{
  JSONObjIter iter = obj->find_first(name);
  if (iter.end()) {
    if (mandatory) {
      string s = "missing mandatory field " + string(name);
      throw err(s);
    }
    val = boost::none;
    return false;
  }

  try {
    val.reset(T());
    decode_json_obj(val.get(), *iter);
  } catch (err& e) {
    val.reset();
    string s = string(name) + ": ";
    s.append(e.message);
    throw err(s);
  }

  return true;
}

template<class T>
static void encode_json(const char *name, const T& val, ceph::Formatter *f)
{
  f->open_object_section(name);
  val.dump(f);
  f->close_section();
}

class utime_t;

void encode_json(const char *name, const string& val, ceph::Formatter *f);
void encode_json(const char *name, const char *val, ceph::Formatter *f);
void encode_json(const char *name, bool val, ceph::Formatter *f);
void encode_json(const char *name, int val, ceph::Formatter *f);
void encode_json(const char *name, unsigned val, ceph::Formatter *f);
void encode_json(const char *name, long val, ceph::Formatter *f);
void encode_json(const char *name, unsigned long val, ceph::Formatter *f);
void encode_json(const char *name, long long val, ceph::Formatter *f);
void encode_json(const char *name, const utime_t& val, ceph::Formatter *f);
void encode_json(const char *name, const bufferlist& bl, ceph::Formatter *f);
void encode_json(const char *name, long long unsigned val, ceph::Formatter *f);

template<class T>
static void encode_json(const char *name, const std::list<T>& l, ceph::Formatter *f)
{
  f->open_array_section(name);
  for (typename std::list<T>::const_iterator iter = l.begin(); iter != l.end(); ++iter) {
    encode_json("obj", *iter, f);
  }
  f->close_section();
}
template<class T>
static void encode_json(const char *name, const std::deque<T>& l, ceph::Formatter *f)
{
  f->open_array_section(name);
  for (typename std::deque<T>::const_iterator iter = l.begin(); iter != l.end(); ++iter) {
    encode_json("obj", *iter, f);
  }
  f->close_section();
}
template<class T, class Compare = std::less<T> >
static void encode_json(const char *name, const std::set<T, Compare>& l, ceph::Formatter *f)
{
  f->open_array_section(name);
  for (typename std::set<T, Compare>::const_iterator iter = l.begin(); iter != l.end(); ++iter) {
    encode_json("obj", *iter, f);
  }
  f->close_section();
}

template<class T>
static void encode_json(const char *name, const std::vector<T>& l, ceph::Formatter *f)
{
  f->open_array_section(name);
  for (typename std::vector<T>::const_iterator iter = l.begin(); iter != l.end(); ++iter) {
    encode_json("obj", *iter, f);
  }
  f->close_section();
}

template<class K, class V, class C = std::less<K> >
static void encode_json(const char *name, const std::map<K, V, C>& m, ceph::Formatter *f)
{
  f->open_array_section(name);
  for (typename std::map<K, V, C>::const_iterator i = m.begin(); i != m.end(); ++i) {
    f->open_object_section("entry");
    encode_json("key", i->first, f);
    encode_json("val", i->second, f);
    f->close_section();
  }
  f->close_section();
}

template<class K, class V>
static void encode_json(const char *name, const std::multimap<K, V>& m, ceph::Formatter *f)
{
  f->open_array_section(name);
  for (typename std::multimap<K, V>::const_iterator i = m.begin(); i != m.end(); ++i) {
    f->open_object_section("entry");
    encode_json("key", i->first, f);
    encode_json("val", i->second, f);
    f->close_section();
  }
  f->close_section();
}
template<class K, class V>
void encode_json_map(const char *name, const map<K, V>& m, ceph::Formatter *f)
{
  f->open_array_section(name);
  typename map<K,V>::const_iterator iter;
  for (iter = m.begin(); iter != m.end(); ++iter) {
    encode_json("obj", iter->second, f);
  }
  f->close_section();
}


template<class K, class V>
void encode_json_map(const char *name, const char *index_name,
                     const char *object_name, const char *value_name,
                     void (*cb)(const char *, const V&, ceph::Formatter *, void *), void *parent,
                     const map<K, V>& m, ceph::Formatter *f)
{
  f->open_array_section(name);
  typename map<K,V>::const_iterator iter;
  for (iter = m.begin(); iter != m.end(); ++iter) {
    if (index_name) {
      f->open_object_section("key_value");
      f->dump_string(index_name, iter->first);
    }

    if (object_name) {
      f->open_object_section(object_name);
    }

    if (cb) {
      cb(value_name, iter->second, f, parent);
    } else {
      encode_json(value_name, iter->second, f);
    }

    if (object_name) {
      f->close_section();
    }
    if (index_name) {
      f->close_section();
    }
  }
  f->close_section();
}

template<class K, class V>
void encode_json_map(const char *name, const char *index_name,
                     const char *object_name, const char *value_name,
                     const map<K, V>& m, ceph::Formatter *f)
{
  encode_json_map<K, V>(name, index_name, object_name, value_name, 
# 515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 3 4
                                                                  __null
# 515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h"
                                                                      , 
# 515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 3 4
                                                                        __null
# 515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h"
                                                                            , m, f);
}

template<class K, class V>
void encode_json_map(const char *name, const char *index_name, const char *value_name,
                     const map<K, V>& m, ceph::Formatter *f)
{
  encode_json_map<K, V>(name, index_name, 
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 3 4
                                         __null
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h"
                                             , value_name, 
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 3 4
                                                           __null
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h"
                                                               , 
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h" 3 4
                                                                 __null
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_json.h"
                                                                     , m, f);
}

class JSONFormattable : public ceph::JSONFormatter {
  JSONObj::data_val value;
  vector<JSONFormattable> arr;
  map<std::string, JSONFormattable> obj;

  vector<JSONFormattable *> enc_stack;
  JSONFormattable *cur_enc;

protected:
  bool handle_value(const char *name, std::string_view s, bool quoted) override;
  bool handle_open_section(const char *name, const char *ns, bool section_is_array) override;
  bool handle_close_section() override;

public:
  JSONFormattable(bool p = false) : JSONFormatter(p) {
    cur_enc = this;
    enc_stack.push_back(cur_enc);
  }

  enum Type {
    FMT_NONE,
    FMT_VALUE,
    FMT_ARRAY,
    FMT_OBJ,
  } type{FMT_NONE};

  void set_type(Type t) {
    type = t;
  }

  void decode_json(JSONObj *jo) {
    if (jo->is_array()) {
      set_type(JSONFormattable::FMT_ARRAY);
      decode_json_obj(arr, jo);
    } else if (jo->is_object()) {
      set_type(JSONFormattable::FMT_OBJ);
      auto iter = jo->find_first();
      for (;!iter.end(); ++iter) {
        JSONObj *field = *iter;
        decode_json_obj(obj[field->get_name()], field);
      }
    } else {
      set_type(JSONFormattable::FMT_VALUE);
      decode_json_obj(value, jo);
    }
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode((uint8_t)type, bl);
    encode(value.str, bl);
    encode(arr, bl);
    encode(obj, bl);
    encode(value.quoted, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    uint8_t t;
    decode(t, bl);
    type = (Type)t;
    decode(value.str, bl);
    decode(arr, bl);
    decode(obj, bl);
    if (struct_v >= 2) {
      decode(value.quoted, bl);
    } else {
      value.quoted = true;
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  const std::string& val() const {
    return value.str;
  }

  int val_int() const;
  long val_long() const;
  long long val_long_long() const;
  bool val_bool() const;

  const map<std::string, JSONFormattable> object() const {
    return obj;
  }

  const vector<JSONFormattable>& array() const {
    return arr;
  }

  const JSONFormattable& operator[](const std::string& name) const;
  const JSONFormattable& operator[](size_t index) const;

  JSONFormattable& operator[](const std::string& name);
  JSONFormattable& operator[](size_t index);

  operator std::string() const {
    return value.str;
  }

  explicit operator int() const {
    return val_int();
  }

  explicit operator long() const {
    return val_long();
  }

  explicit operator long long() const {
    return val_long_long();
  }

  explicit operator bool() const {
    return val_bool();
  }

  template<class T>
  T operator[](const std::string& name) const {
    return this->operator[](name)(T());
  }

  template<class T>
  T operator[](const std::string& name) {
    return this->operator[](name)(T());
  }

  string operator ()(const char *def_val) const {
    return def(string(def_val));
  }

  int operator()(int def_val) const {
    return def(def_val);
  }

  bool operator()(bool def_val) const {
    return def(def_val);
  }

  bool exists(const string& name) const;
  bool exists(size_t index) const;

  std::string def(const std::string& def_val) const;
  int def(int def_val) const;
  bool def(bool def_val) const;

  bool find(const std::string& name, std::string *val) const;

  std::string get(const std::string& name, const std::string& def_val) const;

  int get_int(const std::string& name, int def_val) const;
  bool get_bool(const std::string& name, bool def_val) const;

  int set(const string& name, const string& val);
  int erase(const string& name);

  void derive_from(const JSONFormattable& jf);

  void encode_json(const char *name, Formatter *f) const;

  bool is_array() const {
    return (type == FMT_ARRAY);
  }
};
inline void encode(const JSONFormattable &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(JSONFormattable &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

void encode_json(const char *name, const JSONFormattable& v, Formatter *f);
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h"
# 1 "/usr/include/nss3/nss.h" 1
# 34 "/usr/include/nss3/nss.h"
# 1 "/usr/include/nss3/seccomon.h" 1
# 16 "/usr/include/nss3/seccomon.h"
# 1 "/usr/include/nss3/utilrename.h" 1
# 17 "/usr/include/nss3/seccomon.h" 2
# 1 "/usr/include/nspr4/prtypes.h" 1
# 26 "/usr/include/nspr4/prtypes.h"
# 1 "/usr/include/nspr4/prcpucfg.h" 1
# 27 "/usr/include/nspr4/prtypes.h" 2


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 30 "/usr/include/nspr4/prtypes.h" 2
# 169 "/usr/include/nspr4/prtypes.h"
extern "C" {
# 209 "/usr/include/nspr4/prtypes.h"
typedef unsigned char PRUint8;
# 231 "/usr/include/nspr4/prtypes.h"
typedef signed char PRInt8;
# 256 "/usr/include/nspr4/prtypes.h"
typedef unsigned short PRUint16;
typedef short PRInt16;
# 281 "/usr/include/nspr4/prtypes.h"
typedef unsigned int PRUint32;
typedef int PRInt32;
# 336 "/usr/include/nspr4/prtypes.h"
typedef long PRInt64;
typedef unsigned long PRUint64;
# 381 "/usr/include/nspr4/prtypes.h"
typedef int PRIntn;
typedef unsigned int PRUintn;
# 392 "/usr/include/nspr4/prtypes.h"
typedef double PRFloat64;






typedef size_t PRSize;







typedef PRInt32 PROffset32;
typedef PRInt64 PROffset64;







typedef ptrdiff_t PRPtrdiff;
# 427 "/usr/include/nspr4/prtypes.h"
typedef unsigned long PRUptrdiff;
# 438 "/usr/include/nspr4/prtypes.h"
typedef PRIntn PRBool;
# 448 "/usr/include/nspr4/prtypes.h"
typedef PRUint8 PRPackedBool;





typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus;






typedef PRUint16 PRUnichar;
# 480 "/usr/include/nspr4/prtypes.h"
typedef long PRWord;
typedef unsigned long PRUword;
# 545 "/usr/include/nspr4/prtypes.h"
# 1 "/usr/include/nspr4/obsolete/protypes.h" 1
# 16 "/usr/include/nspr4/obsolete/protypes.h"
typedef PRUintn uintn;

typedef PRIntn intn;
# 59 "/usr/include/nspr4/obsolete/protypes.h"
typedef PRUint64 uint64;






typedef PRUint32 uint32;
# 75 "/usr/include/nspr4/obsolete/protypes.h"
typedef PRUint16 uint16;





typedef PRUint8 uint8;






typedef PRInt64 int64;
# 98 "/usr/include/nspr4/obsolete/protypes.h"
typedef PRInt32 int32;
# 110 "/usr/include/nspr4/obsolete/protypes.h"
typedef PRInt16 int16;
# 119 "/usr/include/nspr4/obsolete/protypes.h"
typedef PRInt8 int8;


typedef PRFloat64 float64;
typedef PRUptrdiff uptrdiff_t;
typedef PRUword uprword_t;
typedef PRWord prword_t;
# 546 "/usr/include/nspr4/prtypes.h" 2
# 558 "/usr/include/nspr4/prtypes.h"
}
# 18 "/usr/include/nss3/seccomon.h" 2
# 27 "/usr/include/nss3/seccomon.h"
# 1 "/usr/include/nss3/secport.h" 1
# 13 "/usr/include/nss3/secport.h"
# 1 "/usr/include/nspr4/prlink.h" 1
# 12 "/usr/include/nspr4/prlink.h"
# 1 "/usr/include/nspr4/prtypes.h" 1
# 13 "/usr/include/nspr4/prlink.h" 2

extern "C" {

typedef struct PRLibrary PRLibrary;

typedef struct PRStaticLinkTable {
    const char *name;
    void (*fp)(void);
} PRStaticLinkTable;
# 30 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) PRStatus PR_SetLibraryPath(const char *path);
# 40 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) char* PR_GetLibraryPath(void);
# 53 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) char* PR_GetLibraryName(const char *dir, const char *lib);





extern __attribute__((visibility("default"))) void PR_FreeLibraryName(char *mem);
# 73 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) PRLibrary* PR_LoadLibrary(const char *name);
# 94 "/usr/include/nspr4/prlink.h"
typedef enum PRLibSpecType {
    PR_LibSpec_Pathname,
    PR_LibSpec_MacNamedFragment,
    PR_LibSpec_MacIndexedFragment,
    PR_LibSpec_PathnameU
} PRLibSpecType;

struct FSSpec;

typedef struct PRLibSpec {
    PRLibSpecType type;
    union {

        const char *pathname;


        struct {
            const struct FSSpec *fsspec;
            const char *name;
        } mac_named_fragment;


        struct {
            const struct FSSpec *fsspec;
            PRUint32 index;
        } mac_indexed_fragment;


        const PRUnichar *pathname_u;
    } value;
} PRLibSpec;
# 144 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) PRLibrary *
PR_LoadLibraryWithFlags(
    PRLibSpec libSpec,
    PRIntn flags
);
# 159 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) PRStatus PR_UnloadLibrary(PRLibrary *lib);
# 169 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) void* PR_FindSymbol(PRLibrary *lib, const char *name);
# 179 "/usr/include/nspr4/prlink.h"
typedef void (*PRFuncPtr)(void);
extern __attribute__((visibility("default"))) PRFuncPtr PR_FindFunctionSymbol(PRLibrary *lib, const char *name);
# 192 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) void* PR_FindSymbolAndLibrary(const char *name,
                                        PRLibrary* *lib);
# 203 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) PRFuncPtr PR_FindFunctionSymbolAndLibrary(const char *name,
        PRLibrary* *lib);
# 217 "/usr/include/nspr4/prlink.h"
extern __attribute__((visibility("default"))) PRLibrary* PR_LoadStaticLibrary(
    const char *name, const PRStaticLinkTable *table);







extern __attribute__((visibility("default"))) char * PR_GetLibraryFilePathname(const char *name, PRFuncPtr addr);

}
# 14 "/usr/include/nss3/secport.h" 2
# 46 "/usr/include/nss3/secport.h"
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 47 "/usr/include/nss3/secport.h" 2
# 1 "/usr/include/c++/10/stdlib.h" 1 3
# 48 "/usr/include/nss3/secport.h" 2


# 1 "/usr/include/nspr4/prlog.h" 1
# 11 "/usr/include/nspr4/prlog.h"
extern "C" {
# 106 "/usr/include/nspr4/prlog.h"
typedef enum PRLogModuleLevel {
    PR_LOG_NONE = 0,
    PR_LOG_ALWAYS = 1,
    PR_LOG_ERROR = 2,
    PR_LOG_WARNING = 3,
    PR_LOG_DEBUG = 4,

    PR_LOG_NOTICE = PR_LOG_DEBUG,
    PR_LOG_WARN = PR_LOG_WARNING,
    PR_LOG_MIN = PR_LOG_DEBUG,
    PR_LOG_MAX = PR_LOG_DEBUG
} PRLogModuleLevel;






typedef struct PRLogModuleInfo {
    const char *name;
    PRLogModuleLevel level;
    struct PRLogModuleInfo *next;
} PRLogModuleInfo;




extern __attribute__((visibility("default"))) PRLogModuleInfo* PR_NewLogModule(const char *name);





extern __attribute__((visibility("default"))) PRBool PR_SetLogFile(const char *name);





extern __attribute__((visibility("default"))) void PR_SetLogBuffering(PRIntn buffer_size);







extern __attribute__((visibility("default"))) void PR_LogPrint(const char *fmt, ...);




extern __attribute__((visibility("default"))) void PR_LogFlush(void);

extern __attribute__((visibility("default"))) void PR_Assert(const char *s, const char *file, PRIntn ln)
;
# 224 "/usr/include/nspr4/prlog.h"
}
# 51 "/usr/include/nss3/secport.h" 2
# 1 "/usr/include/nspr4/plarena.h" 1
# 17 "/usr/include/nspr4/plarena.h"
extern "C" {

typedef struct PLArena PLArena;

struct PLArena {
    PLArena *next;
    PRUword base;
    PRUword limit;
    PRUword avail;
};
# 49 "/usr/include/nspr4/plarena.h"
typedef struct PLArenaPool PLArenaPool;

struct PLArenaPool {
    PLArena first;
    PLArena *current;
    PRUint32 arenasize;
    PRUword mask;



};
# 249 "/usr/include/nspr4/plarena.h"
extern __attribute__((visibility("default"))) void PL_InitArenaPool(
    PLArenaPool *pool, const char *name, PRUint32 size, PRUint32 align);






extern __attribute__((visibility("default"))) void PL_ArenaFinish(void);






extern __attribute__((visibility("default"))) void PL_FreeArenaPool(PLArenaPool *pool);




extern __attribute__((visibility("default"))) void PL_FinishArenaPool(PLArenaPool *pool);





extern __attribute__((visibility("default"))) void PL_CompactArenaPool(PLArenaPool *pool);







extern __attribute__((visibility("default"))) void * PL_ArenaAllocate(PLArenaPool *pool, PRUint32 nb);

extern __attribute__((visibility("default"))) void * PL_ArenaGrow(
    PLArenaPool *pool, void *p, PRUint32 size, PRUint32 incr);

extern __attribute__((visibility("default"))) void PL_ArenaRelease(PLArenaPool *pool, char *mark);




extern __attribute__((visibility("default"))) void PL_ClearArenaPool(PLArenaPool *pool, PRInt32 pattern);





typedef size_t (*PLMallocSizeFn)(const void *ptr);





extern __attribute__((visibility("default"))) size_t PL_SizeOfArenaPoolExcludingPool(
    const PLArenaPool *pool, PLMallocSizeFn mallocSizeOf);
# 336 "/usr/include/nspr4/plarena.h"
}
# 52 "/usr/include/nss3/secport.h" 2
# 1 "/usr/include/nspr4/plstr.h" 1
# 31 "/usr/include/nspr4/plstr.h"
extern "C" {






extern __attribute__((visibility("default"))) PRUint32
PL_strlen(const char *str);
# 49 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) PRUint32
PL_strnlen(const char *str, PRUint32 max);
# 60 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strcpy(char *dest, const char *src);
# 73 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strncpy(char *dest, const char *src, PRUint32 max);
# 96 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strncpyz(char *dest, const char *src, PRUint32 max);
# 110 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strdup(const char *s);







extern __attribute__((visibility("default"))) void
PL_strfree(char *s);
# 134 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strndup(const char *s, PRUint32 max);
# 146 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strcat(char *dst, const char *src);
# 161 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strncat(char *dst, const char *src, PRUint32 max);
# 175 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strcatn(char *dst, PRUint32 max, const char *src);
# 187 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) PRIntn
PL_strcmp(const char *a, const char *b);
# 201 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) PRIntn
PL_strncmp(const char *a, const char *b, PRUint32 max);
# 213 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) PRIntn
PL_strcasecmp(const char *a, const char *b);
# 225 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) PRIntn
PL_strncasecmp(const char *a, const char *b, PRUint32 max);
# 236 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strchr(const char *s, char c);
# 247 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strrchr(const char *s, char c);
# 259 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strnchr(const char *s, char c, PRUint32 n);
# 271 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strnrchr(const char *s, char c, PRUint32 n);
# 287 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strpbrk(const char *s, const char *list);
# 298 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strprbrk(const char *s, const char *list);
# 309 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strnpbrk(const char *s, const char *list, PRUint32 n);
# 320 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strnprbrk(const char *s, const char *list, PRUint32 n);
# 330 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strstr(const char *big, const char *little);
# 340 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strrstr(const char *big, const char *little);
# 351 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strnstr(const char *big, const char *little, PRUint32 n);
# 362 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strnrstr(const char *big, const char *little, PRUint32 max);
# 372 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strcasestr(const char *big, const char *little);
# 382 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strcaserstr(const char *big, const char *little);
# 393 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strncasestr(const char *big, const char *little, PRUint32 max);
# 404 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strncaserstr(const char *big, const char *little, PRUint32 max);
# 426 "/usr/include/nspr4/plstr.h"
extern __attribute__((visibility("default"))) char *
PL_strtok_r(char *s1, const char *s2, char **lasts);







}
# 53 "/usr/include/nss3/secport.h" 2
# 82 "/usr/include/nss3/secport.h"
typedef struct PORTCheapArenaPool_str {
    PLArenaPool arena;
    PRUint32 magic;
} PORTCheapArenaPool;

extern "C" {

extern void *PORT_Alloc(size_t len);
extern void *PORT_Realloc(void *old, size_t len);
extern void *PORT_ZAlloc(size_t len);
extern void *PORT_ZAllocAligned(size_t bytes, size_t alignment, void **mem);
extern void *PORT_ZAllocAlignedOffset(size_t bytes, size_t alignment,
                                      size_t offset);
extern void PORT_Free(void *ptr);
extern void PORT_ZFree(void *ptr, size_t len);
extern char *PORT_Strdup(const char *s);
extern void PORT_SetError(int value);
extern int PORT_GetError(void);


extern PLArenaPool *PORT_NewArena(unsigned long chunksize);
extern void PORT_FreeArena(PLArenaPool *arena, PRBool zero);


extern void PORT_InitCheapArena(PORTCheapArenaPool *arena,
                                unsigned long chunksize);
extern void PORT_DestroyCheapArena(PORTCheapArenaPool *arena);


extern void *PORT_ArenaAlloc(PLArenaPool *arena, size_t size);
extern void *PORT_ArenaZAlloc(PLArenaPool *arena, size_t size);
extern void *PORT_ArenaGrow(PLArenaPool *arena, void *ptr,
                            size_t oldsize, size_t newsize);
extern void *PORT_ArenaMark(PLArenaPool *arena);
extern void PORT_ArenaRelease(PLArenaPool *arena, void *mark);
extern void PORT_ArenaZRelease(PLArenaPool *arena, void *mark);
extern void PORT_ArenaUnmark(PLArenaPool *arena, void *mark);
extern char *PORT_ArenaStrdup(PLArenaPool *arena, const char *str);

}
# 199 "/usr/include/nss3/secport.h"
typedef PRBool( *PORTCharConversionWSwapFunc)(PRBool toUnicode,
                                                         unsigned char *inBuf, unsigned int inBufLen,
                                                         unsigned char *outBuf, unsigned int maxOutBufLen,
                                                         unsigned int *outBufLen, PRBool swapBytes);

typedef PRBool( *PORTCharConversionFunc)(PRBool toUnicode,
                                                    unsigned char *inBuf, unsigned int inBufLen,
                                                    unsigned char *outBuf, unsigned int maxOutBufLen,
                                                    unsigned int *outBufLen);

extern "C" {

void PORT_SetUCS4_UTF8ConversionFunction(PORTCharConversionFunc convFunc);
void PORT_SetUCS2_ASCIIConversionFunction(PORTCharConversionWSwapFunc convFunc);
PRBool PORT_UCS4_UTF8Conversion(PRBool toUnicode, unsigned char *inBuf,
                                unsigned int inBufLen, unsigned char *outBuf,
                                unsigned int maxOutBufLen, unsigned int *outBufLen);
PRBool PORT_UCS2_ASCIIConversion(PRBool toUnicode, unsigned char *inBuf,
                                 unsigned int inBufLen, unsigned char *outBuf,
                                 unsigned int maxOutBufLen, unsigned int *outBufLen,
                                 PRBool swapBytes);
void PORT_SetUCS2_UTF8ConversionFunction(PORTCharConversionFunc convFunc);
PRBool PORT_UCS2_UTF8Conversion(PRBool toUnicode, unsigned char *inBuf,
                                unsigned int inBufLen, unsigned char *outBuf,
                                unsigned int maxOutBufLen, unsigned int *outBufLen);


PRBool PORT_ISO88591_UTF8Conversion(const unsigned char *inBuf,
                                    unsigned int inBufLen, unsigned char *outBuf,
                                    unsigned int maxOutBufLen, unsigned int *outBufLen);

extern PRBool
sec_port_ucs4_utf8_conversion_function(
    PRBool toUnicode,
    unsigned char *inBuf,
    unsigned int inBufLen,
    unsigned char *outBuf,
    unsigned int maxOutBufLen,
    unsigned int *outBufLen);

extern PRBool
sec_port_ucs2_utf8_conversion_function(
    PRBool toUnicode,
    unsigned char *inBuf,
    unsigned int inBufLen,
    unsigned char *outBuf,
    unsigned int maxOutBufLen,
    unsigned int *outBufLen);


extern PRBool
sec_port_iso88591_utf8_conversion_function(
    const unsigned char *inBuf,
    unsigned int inBufLen,
    unsigned char *outBuf,
    unsigned int maxOutBufLen,
    unsigned int *outBufLen);

extern int NSS_PutEnv(const char *envVarName, const char *envValue);

extern int NSS_SecureMemcmp(const void *a, const void *b, size_t n);
extern unsigned int NSS_SecureMemcmpZero(const void *mem, size_t n);
# 292 "/usr/include/nss3/secport.h"
PRLibrary *
PORT_LoadLibraryFromOrigin(const char *existingShLibName,
                           PRFuncPtr staticShLibFunc,
                           const char *newShLibName);

}
# 28 "/usr/include/nss3/seccomon.h" 2

typedef enum {
    siBuffer = 0,
    siClearDataBuffer = 1,
    siCipherDataBuffer = 2,
    siDERCertBuffer = 3,
    siEncodedCertBuffer = 4,
    siDERNameBuffer = 5,
    siEncodedNameBuffer = 6,
    siAsciiNameString = 7,
    siAsciiString = 8,
    siDEROID = 9,
    siUnsignedInteger = 10,
    siUTCTime = 11,
    siGeneralizedTime = 12,
    siVisibleString = 13,
    siUTF8String = 14,
    siBMPString = 15
} SECItemType;

typedef struct SECItemStr SECItem;

struct SECItemStr {
    SECItemType type;
    unsigned char *data;
    unsigned int len;
};

typedef struct SECItemArrayStr SECItemArray;

struct SECItemArrayStr {
    SECItem *items;
    unsigned int len;
};
# 74 "/usr/include/nss3/seccomon.h"
typedef enum _SECStatus {
    SECWouldBlock = -2,
    SECFailure = -1,
    SECSuccess = 0
} SECStatus;






typedef enum _SECComparison {
    SECLessThan = -1,
    SECEqual = 0,
    SECGreaterThan = 1
} SECComparison;
# 35 "/usr/include/nss3/nss.h" 2

typedef struct NSSInitParametersStr NSSInitParameters;
# 94 "/usr/include/nss3/nss.h"
struct NSSInitParametersStr {
    unsigned int length;

    PRBool passwordRequired;
    int minPWLen;
    char *manufactureID;
    char *libraryDescription;
    char *cryptoTokenDescription;
    char *dbTokenDescription;
    char *FIPSTokenDescription;
    char *cryptoSlotDescription;
    char *dbSlotDescription;
    char *FIPSSlotDescription;
};

extern "C" {
# 120 "/usr/include/nss3/nss.h"
extern PRBool NSS_VersionCheck(const char *importedVersion);




extern const char *NSS_GetVersion(void);







extern SECStatus NSS_Init(const char *configdir);




extern PRBool NSS_IsInitialized(void);







extern SECStatus NSS_InitReadWrite(const char *configdir);
# 227 "/usr/include/nss3/nss.h"
typedef struct NSSInitContextStr NSSInitContext;

extern SECStatus NSS_Initialize(const char *configdir,
                                const char *certPrefix, const char *keyPrefix,
                                const char *secmodName, PRUint32 flags);

extern NSSInitContext *NSS_InitContext(const char *configdir,
                                       const char *certPrefix, const char *keyPrefix,
                                       const char *secmodName, NSSInitParameters *initParams, PRUint32 flags);

extern SECStatus NSS_ShutdownContext(NSSInitContext *);
# 249 "/usr/include/nss3/nss.h"
extern SECStatus NSS_InitWithMerge(const char *configdir,
                                   const char *certPrefix, const char *keyPrefix, const char *secmodName,
                                   const char *updatedir, const char *updCertPrefix,
                                   const char *updKeyPrefix, const char *updateID,
                                   const char *updateName, PRUint32 flags);



SECStatus NSS_NoDB_Init(const char *configdir);
# 271 "/usr/include/nss3/nss.h"
typedef SECStatus (*NSS_ShutdownFunc)(void *appData, void *nssData);




SECStatus NSS_RegisterShutdown(NSS_ShutdownFunc sFunc, void *appData);





SECStatus NSS_UnregisterShutdown(NSS_ShutdownFunc sFunc, void *appData);
# 306 "/usr/include/nss3/nss.h"
SECStatus NSS_OptionSet(PRInt32 which, PRInt32 value);
SECStatus NSS_OptionGet(PRInt32 which, PRInt32 *value);




extern SECStatus NSS_Shutdown(void);




void PK11_ConfigurePKCS11(const char *man, const char *libdesc,
                          const char *tokdesc, const char *ptokdesc, const char *slotdesc,
                          const char *pslotdesc, const char *fslotdesc, const char *fpslotdesc,
                          int minPwd, int pwRequired);





void nss_DumpCertificateCacheInfo(void);

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 2
# 1 "/usr/include/nss3/pk11pub.h" 1







# 1 "/usr/include/nss3/secoidt.h" 1
# 14 "/usr/include/nss3/secoidt.h"
# 1 "/usr/include/nss3/secitem.h" 1
# 16 "/usr/include/nss3/secitem.h"
# 1 "/usr/include/nspr4/plhash.h" 1
# 14 "/usr/include/nspr4/plhash.h"
extern "C" {

typedef struct PLHashEntry PLHashEntry;
typedef struct PLHashTable PLHashTable;
typedef PRUint32 PLHashNumber;

typedef PLHashNumber ( *PLHashFunction)(const void *key);
typedef PRIntn ( *PLHashComparator)(const void *v1, const void *v2);

typedef PRIntn ( *PLHashEnumerator)(PLHashEntry *he, PRIntn i, void *arg);







typedef struct PLHashAllocOps {
    void * ( *allocTable)(void *pool, PRSize size);
    void ( *freeTable)(void *pool, void *item);
    PLHashEntry * ( *allocEntry)(void *pool, const void *key);
    void ( *freeEntry)(void *pool, PLHashEntry *he, PRUintn flag);
} PLHashAllocOps;




struct PLHashEntry {
    PLHashEntry *next;
    PLHashNumber keyHash;
    const void *key;
    void *value;
};

struct PLHashTable {
    PLHashEntry **buckets;
    PRUint32 nentries;
    PRUint32 shift;
    PLHashFunction keyHash;
    PLHashComparator keyCompare;
    PLHashComparator valueCompare;
    const PLHashAllocOps *allocOps;
    void *allocPriv;






};





extern __attribute__((visibility("default"))) PLHashTable *
PL_NewHashTable(PRUint32 numBuckets, PLHashFunction keyHash,
                PLHashComparator keyCompare, PLHashComparator valueCompare,
                const PLHashAllocOps *allocOps, void *allocPriv);

extern __attribute__((visibility("default"))) void
PL_HashTableDestroy(PLHashTable *ht);


extern __attribute__((visibility("default"))) PLHashEntry *
PL_HashTableAdd(PLHashTable *ht, const void *key, void *value);

extern __attribute__((visibility("default"))) PRBool
PL_HashTableRemove(PLHashTable *ht, const void *key);

extern __attribute__((visibility("default"))) void *
PL_HashTableLookup(PLHashTable *ht, const void *key);

extern __attribute__((visibility("default"))) void *
PL_HashTableLookupConst(PLHashTable *ht, const void *key);

extern __attribute__((visibility("default"))) PRIntn
PL_HashTableEnumerateEntries(PLHashTable *ht, PLHashEnumerator f, void *arg);


extern __attribute__((visibility("default"))) PLHashNumber
PL_HashString(const void *key);


extern __attribute__((visibility("default"))) PRIntn
PL_CompareStrings(const void *v1, const void *v2);


extern __attribute__((visibility("default"))) PRIntn
PL_CompareValues(const void *v1, const void *v2);


extern __attribute__((visibility("default"))) PLHashEntry **
PL_HashTableRawLookup(PLHashTable *ht, PLHashNumber keyHash, const void *key);

extern __attribute__((visibility("default"))) PLHashEntry **
PL_HashTableRawLookupConst(PLHashTable *ht, PLHashNumber keyHash,
                           const void *key);

extern __attribute__((visibility("default"))) PLHashEntry *
PL_HashTableRawAdd(PLHashTable *ht, PLHashEntry **hep, PLHashNumber keyHash,
                   const void *key, void *value);

extern __attribute__((visibility("default"))) void
PL_HashTableRawRemove(PLHashTable *ht, PLHashEntry **hep, PLHashEntry *he);


extern __attribute__((visibility("default"))) PRIntn
PL_HashTableDump(PLHashTable *ht, PLHashEnumerator dump, FILE *fp);

}
# 17 "/usr/include/nss3/secitem.h" 2


extern "C" {
# 35 "/usr/include/nss3/secitem.h"
extern SECItem *SECITEM_AllocItem(PLArenaPool *arena, SECItem *item,
                                  unsigned int len);






extern SECStatus SECITEM_MakeItem(PLArenaPool *arena, SECItem *dest,
                                  const unsigned char *data, unsigned int len);
# 59 "/usr/include/nss3/secitem.h"
extern SECStatus SECITEM_ReallocItem(
                                     PLArenaPool *arena, SECItem *item,
                                     unsigned int oldlen, unsigned int newlen);
# 71 "/usr/include/nss3/secitem.h"
extern SECStatus SECITEM_ReallocItemV2(PLArenaPool *arena, SECItem *item,
                                       unsigned int newlen);




extern SECComparison SECITEM_CompareItem(const SECItem *a, const SECItem *b);




extern PRBool SECITEM_ItemsAreEqual(const SECItem *a, const SECItem *b);




extern SECStatus SECITEM_CopyItem(PLArenaPool *arena, SECItem *to,
                                  const SECItem *from);




extern SECItem *SECITEM_DupItem(const SECItem *from);






extern SECItem *SECITEM_ArenaDupItem(PLArenaPool *arena, const SECItem *from);




extern void SECITEM_FreeItem(SECItem *zap, PRBool freeit);




extern void SECITEM_ZfreeItem(SECItem *zap, PRBool freeit);

PLHashNumber SECITEM_Hash(const void *key);

PRIntn SECITEM_HashCompare(const void *k1, const void *k2);

extern SECItemArray *SECITEM_AllocArray(PLArenaPool *arena,
                                        SECItemArray *array,
                                        unsigned int len);
extern SECItemArray *SECITEM_DupArray(PLArenaPool *arena,
                                      const SECItemArray *from);
extern void SECITEM_FreeArray(SECItemArray *array, PRBool freeit);
extern void SECITEM_ZfreeArray(SECItemArray *array, PRBool freeit);

}
# 15 "/usr/include/nss3/secoidt.h" 2

typedef struct SECOidDataStr SECOidData;
typedef struct SECAlgorithmIDStr SECAlgorithmID;




struct SECAlgorithmIDStr {
    SECItem algorithm;
    SECItem parameters;
};
# 34 "/usr/include/nss3/secoidt.h"
typedef enum {
    SEC_OID_UNKNOWN = 0,
    SEC_OID_MD2 = 1,
    SEC_OID_MD4 = 2,
    SEC_OID_MD5 = 3,
    SEC_OID_SHA1 = 4,
    SEC_OID_RC2_CBC = 5,
    SEC_OID_RC4 = 6,
    SEC_OID_DES_EDE3_CBC = 7,
    SEC_OID_RC5_CBC_PAD = 8,
    SEC_OID_DES_ECB = 9,
    SEC_OID_DES_CBC = 10,
    SEC_OID_DES_OFB = 11,
    SEC_OID_DES_CFB = 12,
    SEC_OID_DES_MAC = 13,
    SEC_OID_DES_EDE = 14,
    SEC_OID_ISO_SHA_WITH_RSA_SIGNATURE = 15,
    SEC_OID_PKCS1_RSA_ENCRYPTION = 16,
    SEC_OID_PKCS1_MD2_WITH_RSA_ENCRYPTION = 17,
    SEC_OID_PKCS1_MD4_WITH_RSA_ENCRYPTION = 18,
    SEC_OID_PKCS1_MD5_WITH_RSA_ENCRYPTION = 19,
    SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION = 20,
    SEC_OID_PKCS5_PBE_WITH_MD2_AND_DES_CBC = 21,
    SEC_OID_PKCS5_PBE_WITH_MD5_AND_DES_CBC = 22,
    SEC_OID_PKCS5_PBE_WITH_SHA1_AND_DES_CBC = 23,
    SEC_OID_PKCS7 = 24,
    SEC_OID_PKCS7_DATA = 25,
    SEC_OID_PKCS7_SIGNED_DATA = 26,
    SEC_OID_PKCS7_ENVELOPED_DATA = 27,
    SEC_OID_PKCS7_SIGNED_ENVELOPED_DATA = 28,
    SEC_OID_PKCS7_DIGESTED_DATA = 29,
    SEC_OID_PKCS7_ENCRYPTED_DATA = 30,
    SEC_OID_PKCS9_EMAIL_ADDRESS = 31,
    SEC_OID_PKCS9_UNSTRUCTURED_NAME = 32,
    SEC_OID_PKCS9_CONTENT_TYPE = 33,
    SEC_OID_PKCS9_MESSAGE_DIGEST = 34,
    SEC_OID_PKCS9_SIGNING_TIME = 35,
    SEC_OID_PKCS9_COUNTER_SIGNATURE = 36,
    SEC_OID_PKCS9_CHALLENGE_PASSWORD = 37,
    SEC_OID_PKCS9_UNSTRUCTURED_ADDRESS = 38,
    SEC_OID_PKCS9_EXTENDED_CERTIFICATE_ATTRIBUTES = 39,
    SEC_OID_PKCS9_SMIME_CAPABILITIES = 40,
    SEC_OID_AVA_COMMON_NAME = 41,
    SEC_OID_AVA_COUNTRY_NAME = 42,
    SEC_OID_AVA_LOCALITY = 43,
    SEC_OID_AVA_STATE_OR_PROVINCE = 44,
    SEC_OID_AVA_ORGANIZATION_NAME = 45,
    SEC_OID_AVA_ORGANIZATIONAL_UNIT_NAME = 46,
    SEC_OID_AVA_DN_QUALIFIER = 47,
    SEC_OID_AVA_DC = 48,

    SEC_OID_NS_TYPE_GIF = 49,
    SEC_OID_NS_TYPE_JPEG = 50,
    SEC_OID_NS_TYPE_URL = 51,
    SEC_OID_NS_TYPE_HTML = 52,
    SEC_OID_NS_TYPE_CERT_SEQUENCE = 53,
    SEC_OID_MISSI_KEA_DSS_OLD = 54,
    SEC_OID_MISSI_DSS_OLD = 55,
    SEC_OID_MISSI_KEA_DSS = 56,
    SEC_OID_MISSI_DSS = 57,
    SEC_OID_MISSI_KEA = 58,
    SEC_OID_MISSI_ALT_KEA = 59,


    SEC_OID_NS_CERT_EXT_NETSCAPE_OK = 60,
    SEC_OID_NS_CERT_EXT_ISSUER_LOGO = 61,
    SEC_OID_NS_CERT_EXT_SUBJECT_LOGO = 62,
    SEC_OID_NS_CERT_EXT_CERT_TYPE = 63,
    SEC_OID_NS_CERT_EXT_BASE_URL = 64,
    SEC_OID_NS_CERT_EXT_REVOCATION_URL = 65,
    SEC_OID_NS_CERT_EXT_CA_REVOCATION_URL = 66,
    SEC_OID_NS_CERT_EXT_CA_CRL_URL = 67,
    SEC_OID_NS_CERT_EXT_CA_CERT_URL = 68,
    SEC_OID_NS_CERT_EXT_CERT_RENEWAL_URL = 69,
    SEC_OID_NS_CERT_EXT_CA_POLICY_URL = 70,
    SEC_OID_NS_CERT_EXT_HOMEPAGE_URL = 71,
    SEC_OID_NS_CERT_EXT_ENTITY_LOGO = 72,
    SEC_OID_NS_CERT_EXT_USER_PICTURE = 73,
    SEC_OID_NS_CERT_EXT_SSL_SERVER_NAME = 74,
    SEC_OID_NS_CERT_EXT_COMMENT = 75,
    SEC_OID_NS_CERT_EXT_LOST_PASSWORD_URL = 76,
    SEC_OID_NS_CERT_EXT_CERT_RENEWAL_TIME = 77,
    SEC_OID_NS_KEY_USAGE_GOVT_APPROVED = 78,


    SEC_OID_X509_SUBJECT_DIRECTORY_ATTR = 79,
    SEC_OID_X509_SUBJECT_KEY_ID = 80,
    SEC_OID_X509_KEY_USAGE = 81,
    SEC_OID_X509_PRIVATE_KEY_USAGE_PERIOD = 82,
    SEC_OID_X509_SUBJECT_ALT_NAME = 83,
    SEC_OID_X509_ISSUER_ALT_NAME = 84,
    SEC_OID_X509_BASIC_CONSTRAINTS = 85,
    SEC_OID_X509_NAME_CONSTRAINTS = 86,
    SEC_OID_X509_CRL_DIST_POINTS = 87,
    SEC_OID_X509_CERTIFICATE_POLICIES = 88,
    SEC_OID_X509_POLICY_MAPPINGS = 89,
    SEC_OID_X509_POLICY_CONSTRAINTS = 90,
    SEC_OID_X509_AUTH_KEY_ID = 91,
    SEC_OID_X509_EXT_KEY_USAGE = 92,
    SEC_OID_X509_AUTH_INFO_ACCESS = 93,

    SEC_OID_X509_CRL_NUMBER = 94,
    SEC_OID_X509_REASON_CODE = 95,
    SEC_OID_X509_INVALID_DATE = 96,


    SEC_OID_X500_RSA_ENCRYPTION = 97,


    SEC_OID_RFC1274_UID = 98,
    SEC_OID_RFC1274_MAIL = 99,


    SEC_OID_PKCS12 = 100,
    SEC_OID_PKCS12_MODE_IDS = 101,
    SEC_OID_PKCS12_ESPVK_IDS = 102,
    SEC_OID_PKCS12_BAG_IDS = 103,
    SEC_OID_PKCS12_CERT_BAG_IDS = 104,
    SEC_OID_PKCS12_OIDS = 105,
    SEC_OID_PKCS12_PBE_IDS = 106,
    SEC_OID_PKCS12_SIGNATURE_IDS = 107,
    SEC_OID_PKCS12_ENVELOPING_IDS = 108,


    SEC_OID_PKCS12_PKCS8_KEY_SHROUDING = 109,
    SEC_OID_PKCS12_KEY_BAG_ID = 110,
    SEC_OID_PKCS12_CERT_AND_CRL_BAG_ID = 111,
    SEC_OID_PKCS12_SECRET_BAG_ID = 112,
    SEC_OID_PKCS12_X509_CERT_CRL_BAG = 113,
    SEC_OID_PKCS12_SDSI_CERT_BAG = 114,
    SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC4 = 115,
    SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC4 = 116,
    SEC_OID_PKCS12_PBE_WITH_SHA1_AND_TRIPLE_DES_CBC = 117,
    SEC_OID_PKCS12_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC = 118,
    SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC = 119,
    SEC_OID_PKCS12_RSA_ENCRYPTION_WITH_128_BIT_RC4 = 120,
    SEC_OID_PKCS12_RSA_ENCRYPTION_WITH_40_BIT_RC4 = 121,
    SEC_OID_PKCS12_RSA_ENCRYPTION_WITH_TRIPLE_DES = 122,
    SEC_OID_PKCS12_RSA_SIGNATURE_WITH_SHA1_DIGEST = 123,



    SEC_OID_ANSIX9_DSA_SIGNATURE = 124,
    SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST = 125,
    SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST = 126,


    SEC_OID_VERISIGN_USER_NOTICES = 127,


    SEC_OID_PKIX_CPS_POINTER_QUALIFIER = 128,
    SEC_OID_PKIX_USER_NOTICE_QUALIFIER = 129,
    SEC_OID_PKIX_OCSP = 130,
    SEC_OID_PKIX_OCSP_BASIC_RESPONSE = 131,
    SEC_OID_PKIX_OCSP_NONCE = 132,
    SEC_OID_PKIX_OCSP_CRL = 133,
    SEC_OID_PKIX_OCSP_RESPONSE = 134,
    SEC_OID_PKIX_OCSP_NO_CHECK = 135,
    SEC_OID_PKIX_OCSP_ARCHIVE_CUTOFF = 136,
    SEC_OID_PKIX_OCSP_SERVICE_LOCATOR = 137,
    SEC_OID_PKIX_REGCTRL_REGTOKEN = 138,
    SEC_OID_PKIX_REGCTRL_AUTHENTICATOR = 139,
    SEC_OID_PKIX_REGCTRL_PKIPUBINFO = 140,
    SEC_OID_PKIX_REGCTRL_PKI_ARCH_OPTIONS = 141,
    SEC_OID_PKIX_REGCTRL_OLD_CERT_ID = 142,
    SEC_OID_PKIX_REGCTRL_PROTOCOL_ENC_KEY = 143,
    SEC_OID_PKIX_REGINFO_UTF8_PAIRS = 144,
    SEC_OID_PKIX_REGINFO_CERT_REQUEST = 145,
    SEC_OID_EXT_KEY_USAGE_SERVER_AUTH = 146,
    SEC_OID_EXT_KEY_USAGE_CLIENT_AUTH = 147,
    SEC_OID_EXT_KEY_USAGE_CODE_SIGN = 148,
    SEC_OID_EXT_KEY_USAGE_EMAIL_PROTECT = 149,
    SEC_OID_EXT_KEY_USAGE_TIME_STAMP = 150,
    SEC_OID_OCSP_RESPONDER = 151,


    SEC_OID_NETSCAPE_SMIME_KEA = 152,


    SEC_OID_FORTEZZA_SKIPJACK = 153,


    SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC4 = 154,
    SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC4 = 155,
    SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC = 156,
    SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_2KEY_TRIPLE_DES_CBC = 157,
    SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_128_BIT_RC2_CBC = 158,
    SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC = 159,
    SEC_OID_PKCS12_SAFE_CONTENTS_ID = 160,
    SEC_OID_PKCS12_PKCS8_SHROUDED_KEY_BAG_ID = 161,

    SEC_OID_PKCS12_V1_KEY_BAG_ID = 162,
    SEC_OID_PKCS12_V1_PKCS8_SHROUDED_KEY_BAG_ID = 163,
    SEC_OID_PKCS12_V1_CERT_BAG_ID = 164,
    SEC_OID_PKCS12_V1_CRL_BAG_ID = 165,
    SEC_OID_PKCS12_V1_SECRET_BAG_ID = 166,
    SEC_OID_PKCS12_V1_SAFE_CONTENTS_BAG_ID = 167,
    SEC_OID_PKCS9_X509_CERT = 168,
    SEC_OID_PKCS9_SDSI_CERT = 169,
    SEC_OID_PKCS9_X509_CRL = 170,
    SEC_OID_PKCS9_FRIENDLY_NAME = 171,
    SEC_OID_PKCS9_LOCAL_KEY_ID = 172,
    SEC_OID_BOGUS_KEY_USAGE = 173,


    SEC_OID_X942_DIFFIE_HELMAN_KEY = 174,





    SEC_OID_NETSCAPE_NICKNAME = 175,


    SEC_OID_NETSCAPE_RECOVERY_REQUEST = 176,


    SEC_OID_CERT_RENEWAL_LOCATOR = 177,
    SEC_OID_NS_CERT_EXT_SCOPE_OF_USE = 178,


    SEC_OID_CMS_EPHEMERAL_STATIC_DIFFIE_HELLMAN = 179,
    SEC_OID_CMS_3DES_KEY_WRAP = 180,
    SEC_OID_CMS_RC2_KEY_WRAP = 181,


    SEC_OID_SMIME_ENCRYPTION_KEY_PREFERENCE = 182,


    SEC_OID_AES_128_ECB = 183,
    SEC_OID_AES_128_CBC = 184,
    SEC_OID_AES_192_ECB = 185,
    SEC_OID_AES_192_CBC = 186,
    SEC_OID_AES_256_ECB = 187,
    SEC_OID_AES_256_CBC = 188,

    SEC_OID_SDN702_DSA_SIGNATURE = 189,

    SEC_OID_MS_SMIME_ENCRYPTION_KEY_PREFERENCE = 190,

    SEC_OID_SHA256 = 191,
    SEC_OID_SHA384 = 192,
    SEC_OID_SHA512 = 193,

    SEC_OID_PKCS1_SHA256_WITH_RSA_ENCRYPTION = 194,
    SEC_OID_PKCS1_SHA384_WITH_RSA_ENCRYPTION = 195,
    SEC_OID_PKCS1_SHA512_WITH_RSA_ENCRYPTION = 196,

    SEC_OID_AES_128_KEY_WRAP = 197,
    SEC_OID_AES_192_KEY_WRAP = 198,
    SEC_OID_AES_256_KEY_WRAP = 199,


    SEC_OID_ANSIX962_EC_PUBLIC_KEY = 200,
    SEC_OID_ANSIX962_ECDSA_SHA1_SIGNATURE = 201,





    SEC_OID_ANSIX962_EC_PRIME192V1 = 202,
    SEC_OID_ANSIX962_EC_PRIME192V2 = 203,
    SEC_OID_ANSIX962_EC_PRIME192V3 = 204,
    SEC_OID_ANSIX962_EC_PRIME239V1 = 205,
    SEC_OID_ANSIX962_EC_PRIME239V2 = 206,
    SEC_OID_ANSIX962_EC_PRIME239V3 = 207,
    SEC_OID_ANSIX962_EC_PRIME256V1 = 208,


    SEC_OID_SECG_EC_SECP112R1 = 209,
    SEC_OID_SECG_EC_SECP112R2 = 210,
    SEC_OID_SECG_EC_SECP128R1 = 211,
    SEC_OID_SECG_EC_SECP128R2 = 212,
    SEC_OID_SECG_EC_SECP160K1 = 213,
    SEC_OID_SECG_EC_SECP160R1 = 214,
    SEC_OID_SECG_EC_SECP160R2 = 215,
    SEC_OID_SECG_EC_SECP192K1 = 216,

    SEC_OID_SECG_EC_SECP224K1 = 217,
    SEC_OID_SECG_EC_SECP224R1 = 218,
    SEC_OID_SECG_EC_SECP256K1 = 219,

    SEC_OID_SECG_EC_SECP384R1 = 220,
    SEC_OID_SECG_EC_SECP521R1 = 221,


    SEC_OID_ANSIX962_EC_C2PNB163V1 = 222,
    SEC_OID_ANSIX962_EC_C2PNB163V2 = 223,
    SEC_OID_ANSIX962_EC_C2PNB163V3 = 224,
    SEC_OID_ANSIX962_EC_C2PNB176V1 = 225,
    SEC_OID_ANSIX962_EC_C2TNB191V1 = 226,
    SEC_OID_ANSIX962_EC_C2TNB191V2 = 227,
    SEC_OID_ANSIX962_EC_C2TNB191V3 = 228,
    SEC_OID_ANSIX962_EC_C2ONB191V4 = 229,
    SEC_OID_ANSIX962_EC_C2ONB191V5 = 230,
    SEC_OID_ANSIX962_EC_C2PNB208W1 = 231,
    SEC_OID_ANSIX962_EC_C2TNB239V1 = 232,
    SEC_OID_ANSIX962_EC_C2TNB239V2 = 233,
    SEC_OID_ANSIX962_EC_C2TNB239V3 = 234,
    SEC_OID_ANSIX962_EC_C2ONB239V4 = 235,
    SEC_OID_ANSIX962_EC_C2ONB239V5 = 236,
    SEC_OID_ANSIX962_EC_C2PNB272W1 = 237,
    SEC_OID_ANSIX962_EC_C2PNB304W1 = 238,
    SEC_OID_ANSIX962_EC_C2TNB359V1 = 239,
    SEC_OID_ANSIX962_EC_C2PNB368W1 = 240,
    SEC_OID_ANSIX962_EC_C2TNB431R1 = 241,


    SEC_OID_SECG_EC_SECT113R1 = 242,
    SEC_OID_SECG_EC_SECT113R2 = 243,
    SEC_OID_SECG_EC_SECT131R1 = 244,
    SEC_OID_SECG_EC_SECT131R2 = 245,
    SEC_OID_SECG_EC_SECT163K1 = 246,
    SEC_OID_SECG_EC_SECT163R1 = 247,
    SEC_OID_SECG_EC_SECT163R2 = 248,
    SEC_OID_SECG_EC_SECT193R1 = 249,
    SEC_OID_SECG_EC_SECT193R2 = 250,
    SEC_OID_SECG_EC_SECT233K1 = 251,
    SEC_OID_SECG_EC_SECT233R1 = 252,
    SEC_OID_SECG_EC_SECT239K1 = 253,
    SEC_OID_SECG_EC_SECT283K1 = 254,
    SEC_OID_SECG_EC_SECT283R1 = 255,
    SEC_OID_SECG_EC_SECT409K1 = 256,
    SEC_OID_SECG_EC_SECT409R1 = 257,
    SEC_OID_SECG_EC_SECT571K1 = 258,
    SEC_OID_SECG_EC_SECT571R1 = 259,

    SEC_OID_NETSCAPE_AOLSCREENNAME = 260,

    SEC_OID_AVA_SURNAME = 261,
    SEC_OID_AVA_SERIAL_NUMBER = 262,
    SEC_OID_AVA_STREET_ADDRESS = 263,
    SEC_OID_AVA_TITLE = 264,
    SEC_OID_AVA_POSTAL_ADDRESS = 265,
    SEC_OID_AVA_POSTAL_CODE = 266,
    SEC_OID_AVA_POST_OFFICE_BOX = 267,
    SEC_OID_AVA_GIVEN_NAME = 268,
    SEC_OID_AVA_INITIALS = 269,
    SEC_OID_AVA_GENERATION_QUALIFIER = 270,
    SEC_OID_AVA_HOUSE_IDENTIFIER = 271,
    SEC_OID_AVA_PSEUDONYM = 272,


    SEC_OID_PKIX_CA_ISSUERS = 273,
    SEC_OID_PKCS9_EXTENSION_REQUEST = 274,


    SEC_OID_ANSIX962_ECDSA_SIGNATURE_RECOMMENDED_DIGEST = 275,
    SEC_OID_ANSIX962_ECDSA_SIGNATURE_SPECIFIED_DIGEST = 276,
    SEC_OID_ANSIX962_ECDSA_SHA224_SIGNATURE = 277,
    SEC_OID_ANSIX962_ECDSA_SHA256_SIGNATURE = 278,
    SEC_OID_ANSIX962_ECDSA_SHA384_SIGNATURE = 279,
    SEC_OID_ANSIX962_ECDSA_SHA512_SIGNATURE = 280,


    SEC_OID_X509_HOLD_INSTRUCTION_CODE = 281,
    SEC_OID_X509_DELTA_CRL_INDICATOR = 282,
    SEC_OID_X509_ISSUING_DISTRIBUTION_POINT = 283,
    SEC_OID_X509_CERT_ISSUER = 284,
    SEC_OID_X509_FRESHEST_CRL = 285,
    SEC_OID_X509_INHIBIT_ANY_POLICY = 286,
    SEC_OID_X509_SUBJECT_INFO_ACCESS = 287,


    SEC_OID_CAMELLIA_128_CBC = 288,
    SEC_OID_CAMELLIA_192_CBC = 289,
    SEC_OID_CAMELLIA_256_CBC = 290,


    SEC_OID_PKCS5_PBKDF2 = 291,
    SEC_OID_PKCS5_PBES2 = 292,
    SEC_OID_PKCS5_PBMAC1 = 293,
    SEC_OID_HMAC_SHA1 = 294,
    SEC_OID_HMAC_SHA224 = 295,
    SEC_OID_HMAC_SHA256 = 296,
    SEC_OID_HMAC_SHA384 = 297,
    SEC_OID_HMAC_SHA512 = 298,

    SEC_OID_PKIX_TIMESTAMPING = 299,
    SEC_OID_PKIX_CA_REPOSITORY = 300,

    SEC_OID_ISO_SHA1_WITH_RSA_SIGNATURE = 301,

    SEC_OID_SEED_CBC = 302,

    SEC_OID_X509_ANY_POLICY = 303,

    SEC_OID_PKCS1_RSA_OAEP_ENCRYPTION = 304,
    SEC_OID_PKCS1_MGF1 = 305,
    SEC_OID_PKCS1_PSPECIFIED = 306,
    SEC_OID_PKCS1_RSA_PSS_SIGNATURE = 307,
    SEC_OID_PKCS1_SHA224_WITH_RSA_ENCRYPTION = 308,

    SEC_OID_SHA224 = 309,

    SEC_OID_EV_INCORPORATION_LOCALITY = 310,
    SEC_OID_EV_INCORPORATION_STATE = 311,
    SEC_OID_EV_INCORPORATION_COUNTRY = 312,
    SEC_OID_BUSINESS_CATEGORY = 313,

    SEC_OID_NIST_DSA_SIGNATURE_WITH_SHA224_DIGEST = 314,
    SEC_OID_NIST_DSA_SIGNATURE_WITH_SHA256_DIGEST = 315,





    SEC_OID_MS_EXT_KEY_USAGE_CTL_SIGNING = 316,


    SEC_OID_AVA_NAME = 317,

    SEC_OID_AES_128_GCM = 318,
    SEC_OID_AES_192_GCM = 319,
    SEC_OID_AES_256_GCM = 320,
    SEC_OID_IDEA_CBC = 321,



    SEC_OID_RC2_40_CBC = 322,
    SEC_OID_DES_40_CBC = 323,
    SEC_OID_RC4_40 = 324,
    SEC_OID_RC4_56 = 325,
    SEC_OID_NULL_CIPHER = 326,

    SEC_OID_HMAC_MD5 = 327,

    SEC_OID_TLS_RSA = 328,
    SEC_OID_TLS_DHE_RSA = 329,
    SEC_OID_TLS_DHE_DSS = 330,
    SEC_OID_TLS_DH_RSA = 331,
    SEC_OID_TLS_DH_DSS = 332,
    SEC_OID_TLS_DH_ANON = 333,
    SEC_OID_TLS_ECDHE_ECDSA = 334,
    SEC_OID_TLS_ECDHE_RSA = 335,
    SEC_OID_TLS_ECDH_ECDSA = 336,
    SEC_OID_TLS_ECDH_RSA = 337,
    SEC_OID_TLS_ECDH_ANON = 338,
    SEC_OID_TLS_RSA_EXPORT = 339,

    SEC_OID_TLS_DHE_RSA_EXPORT = 340,
    SEC_OID_TLS_DHE_DSS_EXPORT = 341,
    SEC_OID_TLS_DH_RSA_EXPORT = 342,
    SEC_OID_TLS_DH_DSS_EXPORT = 343,
    SEC_OID_TLS_DH_ANON_EXPORT = 344,
    SEC_OID_APPLY_SSL_POLICY = 345,

    SEC_OID_CHACHA20_POLY1305 = 346,

    SEC_OID_TLS_ECDHE_PSK = 347,
    SEC_OID_TLS_DHE_PSK = 348,

    SEC_OID_TLS_FFDHE_2048 = 349,
    SEC_OID_TLS_FFDHE_3072 = 350,
    SEC_OID_TLS_FFDHE_4096 = 351,
    SEC_OID_TLS_FFDHE_6144 = 352,
    SEC_OID_TLS_FFDHE_8192 = 353,
    SEC_OID_TLS_DHE_CUSTOM = 354,

    SEC_OID_CURVE25519 = 355,

    SEC_OID_TLS13_KEA_ANY = 356,

    SEC_OID_X509_ANY_EXT_KEY_USAGE = 357,
    SEC_OID_EXT_KEY_USAGE_IPSEC_IKE = 358,
    SEC_OID_IPSEC_IKE_END = 359,
    SEC_OID_IPSEC_IKE_INTERMEDIATE = 360,
    SEC_OID_EXT_KEY_USAGE_IPSEC_END = 361,
    SEC_OID_EXT_KEY_USAGE_IPSEC_TUNNEL = 362,
    SEC_OID_EXT_KEY_USAGE_IPSEC_USER = 363,

    SEC_OID_TOTAL
} SECOidTag;
# 515 "/usr/include/nss3/secoidt.h"
typedef enum {
    INVALID_CERT_EXTENSION = 0,
    UNSUPPORTED_CERT_EXTENSION = 1,
    SUPPORTED_CERT_EXTENSION = 2
} SECSupportExtenTag;

struct SECOidDataStr {
    SECItem oid;
    SECOidTag offset;
    const char* desc;
    unsigned long mechanism;
    SECSupportExtenTag supportedExtension;



};
# 9 "/usr/include/nss3/pk11pub.h" 2
# 1 "/usr/include/nss3/secdert.h" 1
# 15 "/usr/include/nss3/secdert.h"
typedef struct DERTemplateStr DERTemplate;
# 25 "/usr/include/nss3/secdert.h"
struct DERTemplateStr {



    unsigned long kind;





    unsigned int offset;





    DERTemplate *sub;
# 54 "/usr/include/nss3/secdert.h"
    unsigned long arg;
};
# 10 "/usr/include/nss3/pk11pub.h" 2
# 1 "/usr/include/nss3/keythi.h" 1






# 1 "/usr/include/nss3/eccutil.h" 1
# 9 "/usr/include/nss3/eccutil.h"
typedef enum {
    ECPoint_Uncompressed,
    ECPoint_XOnly,
    ECPoint_Undefined
} ECPointEncoding;
# 8 "/usr/include/nss3/keythi.h" 2

# 1 "/usr/include/nss3/pkcs11t.h" 1
# 36 "/usr/include/nss3/pkcs11t.h"
typedef unsigned char CK_BYTE;


typedef CK_BYTE CK_CHAR;


typedef CK_BYTE CK_UTF8CHAR;


typedef CK_BYTE CK_BBOOL;


typedef unsigned long int CK_ULONG;



typedef long int CK_LONG;


typedef CK_ULONG CK_FLAGS;





typedef CK_BYTE * CK_BYTE_PTR;
typedef CK_CHAR * CK_CHAR_PTR;
typedef CK_UTF8CHAR * CK_UTF8CHAR_PTR;
typedef CK_ULONG * CK_ULONG_PTR;
typedef void * CK_VOID_PTR;


typedef CK_VOID_PTR * CK_VOID_PTR_PTR;






# 1 "/usr/include/nss3/pkcs11p.h" 1
# 76 "/usr/include/nss3/pkcs11t.h" 2

typedef struct CK_VERSION {
    CK_BYTE major;
    CK_BYTE minor;
} CK_VERSION;

typedef CK_VERSION * CK_VERSION_PTR;

typedef struct CK_INFO {


    CK_VERSION cryptokiVersion;
    CK_UTF8CHAR manufacturerID[32];
    CK_FLAGS flags;


    CK_UTF8CHAR libraryDescription[32];
    CK_VERSION libraryVersion;
} CK_INFO;

typedef CK_INFO * CK_INFO_PTR;





typedef CK_ULONG CK_NOTIFICATION;


typedef CK_ULONG CK_SLOT_ID;

typedef CK_SLOT_ID * CK_SLOT_ID_PTR;


typedef struct CK_SLOT_INFO {


    CK_UTF8CHAR slotDescription[64];
    CK_UTF8CHAR manufacturerID[32];
    CK_FLAGS flags;


    CK_VERSION hardwareVersion;
    CK_VERSION firmwareVersion;
} CK_SLOT_INFO;
# 129 "/usr/include/nss3/pkcs11t.h"
typedef CK_SLOT_INFO * CK_SLOT_INFO_PTR;


typedef struct CK_TOKEN_INFO {


    CK_UTF8CHAR label[32];
    CK_UTF8CHAR manufacturerID[32];
    CK_UTF8CHAR model[16];
    CK_CHAR serialNumber[16];
    CK_FLAGS flags;




    CK_ULONG ulMaxSessionCount;
    CK_ULONG ulSessionCount;
    CK_ULONG ulMaxRwSessionCount;
    CK_ULONG ulRwSessionCount;
    CK_ULONG ulMaxPinLen;
    CK_ULONG ulMinPinLen;
    CK_ULONG ulTotalPublicMemory;
    CK_ULONG ulFreePublicMemory;
    CK_ULONG ulTotalPrivateMemory;
    CK_ULONG ulFreePrivateMemory;



    CK_VERSION hardwareVersion;
    CK_VERSION firmwareVersion;
    CK_CHAR utcTime[16];
} CK_TOKEN_INFO;
# 251 "/usr/include/nss3/pkcs11t.h"
typedef CK_TOKEN_INFO * CK_TOKEN_INFO_PTR;



typedef CK_ULONG CK_SESSION_HANDLE;

typedef CK_SESSION_HANDLE * CK_SESSION_HANDLE_PTR;




typedef CK_ULONG CK_USER_TYPE;
# 273 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_STATE;







typedef struct CK_SESSION_INFO {
    CK_SLOT_ID slotID;
    CK_STATE state;
    CK_FLAGS flags;



    CK_ULONG ulDeviceError;
} CK_SESSION_INFO;







typedef CK_SESSION_INFO * CK_SESSION_INFO_PTR;



typedef CK_ULONG CK_OBJECT_HANDLE;

typedef CK_OBJECT_HANDLE * CK_OBJECT_HANDLE_PTR;






typedef CK_ULONG CK_OBJECT_CLASS;
# 328 "/usr/include/nss3/pkcs11t.h"
typedef CK_OBJECT_CLASS * CK_OBJECT_CLASS_PTR;



typedef CK_ULONG CK_PROFILE_ID;
# 345 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_HW_FEATURE_TYPE;
# 356 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_KEY_TYPE;
# 406 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_CERTIFICATE_TYPE;
# 420 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_ATTRIBUTE_TYPE;
# 559 "/usr/include/nss3/pkcs11t.h"
typedef struct CK_ATTRIBUTE {
    CK_ATTRIBUTE_TYPE type;
    CK_VOID_PTR pValue;


    CK_ULONG ulValueLen;
} CK_ATTRIBUTE;

typedef CK_ATTRIBUTE * CK_ATTRIBUTE_PTR;


typedef struct CK_DATE {
    CK_CHAR year[4];
    CK_CHAR month[2];
    CK_CHAR day[2];
} CK_DATE;





typedef CK_ULONG CK_MECHANISM_TYPE;
# 945 "/usr/include/nss3/pkcs11t.h"
typedef CK_MECHANISM_TYPE * CK_MECHANISM_TYPE_PTR;



typedef struct CK_MECHANISM {
    CK_MECHANISM_TYPE mechanism;
    CK_VOID_PTR pParameter;



    CK_ULONG ulParameterLen;
} CK_MECHANISM;

typedef CK_MECHANISM * CK_MECHANISM_PTR;



typedef struct CK_MECHANISM_INFO {
    CK_ULONG ulMinKeySize;
    CK_ULONG ulMaxKeySize;
    CK_FLAGS flags;
} CK_MECHANISM_INFO;
# 1003 "/usr/include/nss3/pkcs11t.h"
typedef CK_MECHANISM_INFO * CK_MECHANISM_INFO_PTR;




typedef CK_ULONG CK_RV;
# 1143 "/usr/include/nss3/pkcs11t.h"
typedef CK_RV( *CK_NOTIFY)(
    CK_SESSION_HANDLE hSession,
    CK_NOTIFICATION event,
    CK_VOID_PTR pApplication
    );





typedef struct CK_FUNCTION_LIST CK_FUNCTION_LIST;

typedef CK_FUNCTION_LIST * CK_FUNCTION_LIST_PTR;

typedef CK_FUNCTION_LIST_PTR * CK_FUNCTION_LIST_PTR_PTR;



typedef CK_RV( *CK_CREATEMUTEX)(
    CK_VOID_PTR_PTR ppMutex
    );



typedef CK_RV( *CK_DESTROYMUTEX)(
    CK_VOID_PTR pMutex
    );


typedef CK_RV( *CK_LOCKMUTEX)(
    CK_VOID_PTR pMutex
    );



typedef CK_RV( *CK_UNLOCKMUTEX)(
    CK_VOID_PTR pMutex
    );



typedef struct CK_C_INITIALIZE_ARGS {
    CK_CREATEMUTEX CreateMutex;
    CK_DESTROYMUTEX DestroyMutex;
    CK_LOCKMUTEX LockMutex;
    CK_UNLOCKMUTEX UnlockMutex;
    CK_FLAGS flags;
# 1198 "/usr/include/nss3/pkcs11t.h"
    CK_CHAR_PTR *LibraryParameters;


    CK_VOID_PTR pReserved;
} CK_C_INITIALIZE_ARGS;







typedef CK_C_INITIALIZE_ARGS * CK_C_INITIALIZE_ARGS_PTR;
# 1222 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_RSA_PKCS_MGF_TYPE;

typedef CK_RSA_PKCS_MGF_TYPE * CK_RSA_PKCS_MGF_TYPE_PTR;
# 1241 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_RSA_PKCS_OAEP_SOURCE_TYPE;

typedef CK_RSA_PKCS_OAEP_SOURCE_TYPE * CK_RSA_PKCS_OAEP_SOURCE_TYPE_PTR;







typedef struct CK_RSA_PKCS_OAEP_PARAMS {
    CK_MECHANISM_TYPE hashAlg;
    CK_RSA_PKCS_MGF_TYPE mgf;
    CK_RSA_PKCS_OAEP_SOURCE_TYPE source;
    CK_VOID_PTR pSourceData;
    CK_ULONG ulSourceDataLen;
} CK_RSA_PKCS_OAEP_PARAMS;

typedef CK_RSA_PKCS_OAEP_PARAMS * CK_RSA_PKCS_OAEP_PARAMS_PTR;




typedef struct CK_RSA_PKCS_PSS_PARAMS {
    CK_MECHANISM_TYPE hashAlg;
    CK_RSA_PKCS_MGF_TYPE mgf;
    CK_ULONG sLen;
} CK_RSA_PKCS_PSS_PARAMS;

typedef CK_RSA_PKCS_PSS_PARAMS * CK_RSA_PKCS_PSS_PARAMS_PTR;


typedef CK_ULONG CK_EC_KDF_TYPE;
# 1288 "/usr/include/nss3/pkcs11t.h"
typedef struct CK_ECDH1_DERIVE_PARAMS {
    CK_EC_KDF_TYPE kdf;
    CK_ULONG ulSharedDataLen;
    CK_BYTE_PTR pSharedData;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
} CK_ECDH1_DERIVE_PARAMS;

typedef CK_ECDH1_DERIVE_PARAMS * CK_ECDH1_DERIVE_PARAMS_PTR;




typedef struct CK_ECDH2_DERIVE_PARAMS {
    CK_EC_KDF_TYPE kdf;
    CK_ULONG ulSharedDataLen;
    CK_BYTE_PTR pSharedData;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
    CK_ULONG ulPrivateDataLen;
    CK_OBJECT_HANDLE hPrivateData;
    CK_ULONG ulPublicDataLen2;
    CK_BYTE_PTR pPublicData2;
} CK_ECDH2_DERIVE_PARAMS;

typedef CK_ECDH2_DERIVE_PARAMS * CK_ECDH2_DERIVE_PARAMS_PTR;

typedef struct CK_ECMQV_DERIVE_PARAMS {
    CK_EC_KDF_TYPE kdf;
    CK_ULONG ulSharedDataLen;
    CK_BYTE_PTR pSharedData;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
    CK_ULONG ulPrivateDataLen;
    CK_OBJECT_HANDLE hPrivateData;
    CK_ULONG ulPublicDataLen2;
    CK_BYTE_PTR pPublicData2;
    CK_OBJECT_HANDLE publicKey;
} CK_ECMQV_DERIVE_PARAMS;

typedef CK_ECMQV_DERIVE_PARAMS * CK_ECMQV_DERIVE_PARAMS_PTR;



typedef CK_ULONG CK_X9_42_DH_KDF_TYPE;
typedef CK_X9_42_DH_KDF_TYPE * CK_X9_42_DH_KDF_TYPE_PTR;
# 1344 "/usr/include/nss3/pkcs11t.h"
typedef struct CK_X9_42_DH1_DERIVE_PARAMS {
    CK_X9_42_DH_KDF_TYPE kdf;
    CK_ULONG ulOtherInfoLen;
    CK_BYTE_PTR pOtherInfo;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
} CK_X9_42_DH1_DERIVE_PARAMS;

typedef struct CK_X9_42_DH1_DERIVE_PARAMS * CK_X9_42_DH1_DERIVE_PARAMS_PTR;





typedef struct CK_X9_42_DH2_DERIVE_PARAMS {
    CK_X9_42_DH_KDF_TYPE kdf;
    CK_ULONG ulOtherInfoLen;
    CK_BYTE_PTR pOtherInfo;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
    CK_ULONG ulPrivateDataLen;
    CK_OBJECT_HANDLE hPrivateData;
    CK_ULONG ulPublicDataLen2;
    CK_BYTE_PTR pPublicData2;
} CK_X9_42_DH2_DERIVE_PARAMS;

typedef CK_X9_42_DH2_DERIVE_PARAMS * CK_X9_42_DH2_DERIVE_PARAMS_PTR;

typedef struct CK_X9_42_MQV_DERIVE_PARAMS {
    CK_X9_42_DH_KDF_TYPE kdf;
    CK_ULONG ulOtherInfoLen;
    CK_BYTE_PTR pOtherInfo;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
    CK_ULONG ulPrivateDataLen;
    CK_OBJECT_HANDLE hPrivateData;
    CK_ULONG ulPublicDataLen2;
    CK_BYTE_PTR pPublicData2;
    CK_OBJECT_HANDLE publicKey;
} CK_X9_42_MQV_DERIVE_PARAMS;

typedef CK_X9_42_MQV_DERIVE_PARAMS * CK_X9_42_MQV_DERIVE_PARAMS_PTR;




typedef struct CK_KEA_DERIVE_PARAMS {
    CK_BBOOL isSender;
    CK_ULONG ulRandomLen;
    CK_BYTE_PTR pRandomA;
    CK_BYTE_PTR pRandomB;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
} CK_KEA_DERIVE_PARAMS;

typedef CK_KEA_DERIVE_PARAMS * CK_KEA_DERIVE_PARAMS_PTR;




typedef CK_ULONG CK_RC2_PARAMS;

typedef CK_RC2_PARAMS * CK_RC2_PARAMS_PTR;



typedef struct CK_RC2_CBC_PARAMS {


    CK_ULONG ulEffectiveBits;

    CK_BYTE iv[8];
} CK_RC2_CBC_PARAMS;

typedef CK_RC2_CBC_PARAMS * CK_RC2_CBC_PARAMS_PTR;




typedef struct CK_RC2_MAC_GENERAL_PARAMS {
    CK_ULONG ulEffectiveBits;
    CK_ULONG ulMacLength;
} CK_RC2_MAC_GENERAL_PARAMS;

typedef CK_RC2_MAC_GENERAL_PARAMS *
    CK_RC2_MAC_GENERAL_PARAMS_PTR;




typedef struct CK_RC5_PARAMS {
    CK_ULONG ulWordsize;
    CK_ULONG ulRounds;
} CK_RC5_PARAMS;

typedef CK_RC5_PARAMS * CK_RC5_PARAMS_PTR;




typedef struct CK_RC5_CBC_PARAMS {
    CK_ULONG ulWordsize;
    CK_ULONG ulRounds;
    CK_BYTE_PTR pIv;
    CK_ULONG ulIvLen;
} CK_RC5_CBC_PARAMS;

typedef CK_RC5_CBC_PARAMS * CK_RC5_CBC_PARAMS_PTR;




typedef struct CK_RC5_MAC_GENERAL_PARAMS {
    CK_ULONG ulWordsize;
    CK_ULONG ulRounds;
    CK_ULONG ulMacLength;
} CK_RC5_MAC_GENERAL_PARAMS;

typedef CK_RC5_MAC_GENERAL_PARAMS *
    CK_RC5_MAC_GENERAL_PARAMS_PTR;





typedef CK_ULONG CK_MAC_GENERAL_PARAMS;

typedef CK_MAC_GENERAL_PARAMS * CK_MAC_GENERAL_PARAMS_PTR;


typedef struct CK_DES_CBC_ENCRYPT_DATA_PARAMS {
    CK_BYTE iv[8];
    CK_BYTE_PTR pData;
    CK_ULONG length;
} CK_DES_CBC_ENCRYPT_DATA_PARAMS;

typedef CK_DES_CBC_ENCRYPT_DATA_PARAMS * CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR;

typedef struct CK_AES_CBC_ENCRYPT_DATA_PARAMS {
    CK_BYTE iv[16];
    CK_BYTE_PTR pData;
    CK_ULONG length;
} CK_AES_CBC_ENCRYPT_DATA_PARAMS;

typedef CK_AES_CBC_ENCRYPT_DATA_PARAMS * CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR;


typedef struct CK_AES_CTR_PARAMS {
    CK_ULONG ulCounterBits;
    CK_BYTE cb[16];
} CK_AES_CTR_PARAMS;

typedef CK_AES_CTR_PARAMS * CK_AES_CTR_PARAMS_PTR;


typedef struct CK_GCM_PARAMS {
    CK_BYTE_PTR pIv;
    CK_ULONG ulIvLen;
    CK_BYTE_PTR pAAD;
    CK_ULONG ulAADLen;
    CK_ULONG ulTagBits;
} CK_GCM_PARAMS;

typedef CK_GCM_PARAMS * CK_GCM_PARAMS_PTR;


typedef struct CK_CCM_PARAMS {
    CK_ULONG ulDataLen;
    CK_BYTE_PTR pNonce;
    CK_ULONG ulNonceLen;
    CK_BYTE_PTR pAAD;
    CK_ULONG ulAADLen;
    CK_ULONG ulMACLen;
} CK_CCM_PARAMS;

typedef CK_CCM_PARAMS * CK_CCM_PARAMS_PTR;




typedef struct CK_SKIPJACK_PRIVATE_WRAP_PARAMS {
    CK_ULONG ulPasswordLen;
    CK_BYTE_PTR pPassword;
    CK_ULONG ulPublicDataLen;
    CK_BYTE_PTR pPublicData;
    CK_ULONG ulPAndGLen;
    CK_ULONG ulQLen;
    CK_ULONG ulRandomLen;
    CK_BYTE_PTR pRandomA;
    CK_BYTE_PTR pPrimeP;
    CK_BYTE_PTR pBaseG;
    CK_BYTE_PTR pSubprimeQ;
} CK_SKIPJACK_PRIVATE_WRAP_PARAMS;

typedef CK_SKIPJACK_PRIVATE_WRAP_PARAMS *
    CK_SKIPJACK_PRIVATE_WRAP_PTR;




typedef struct CK_SKIPJACK_RELAYX_PARAMS {
    CK_ULONG ulOldWrappedXLen;
    CK_BYTE_PTR pOldWrappedX;
    CK_ULONG ulOldPasswordLen;
    CK_BYTE_PTR pOldPassword;
    CK_ULONG ulOldPublicDataLen;
    CK_BYTE_PTR pOldPublicData;
    CK_ULONG ulOldRandomLen;
    CK_BYTE_PTR pOldRandomA;
    CK_ULONG ulNewPasswordLen;
    CK_BYTE_PTR pNewPassword;
    CK_ULONG ulNewPublicDataLen;
    CK_BYTE_PTR pNewPublicData;
    CK_ULONG ulNewRandomLen;
    CK_BYTE_PTR pNewRandomA;
} CK_SKIPJACK_RELAYX_PARAMS;

typedef CK_SKIPJACK_RELAYX_PARAMS *
    CK_SKIPJACK_RELAYX_PARAMS_PTR;

typedef struct CK_PBE_PARAMS {
    CK_BYTE_PTR pInitVector;
    CK_UTF8CHAR_PTR pPassword;
    CK_ULONG ulPasswordLen;
    CK_BYTE_PTR pSalt;
    CK_ULONG ulSaltLen;
    CK_ULONG ulIteration;
} CK_PBE_PARAMS;

typedef CK_PBE_PARAMS * CK_PBE_PARAMS_PTR;




typedef struct CK_KEY_WRAP_SET_OAEP_PARAMS {
    CK_BYTE bBC;
    CK_BYTE_PTR pX;
    CK_ULONG ulXLen;
} CK_KEY_WRAP_SET_OAEP_PARAMS;

typedef CK_KEY_WRAP_SET_OAEP_PARAMS *
    CK_KEY_WRAP_SET_OAEP_PARAMS_PTR;

typedef struct CK_SSL3_RANDOM_DATA {
    CK_BYTE_PTR pClientRandom;
    CK_ULONG ulClientRandomLen;
    CK_BYTE_PTR pServerRandom;
    CK_ULONG ulServerRandomLen;
} CK_SSL3_RANDOM_DATA;

typedef struct CK_SSL3_MASTER_KEY_DERIVE_PARAMS {
    CK_SSL3_RANDOM_DATA RandomInfo;
    CK_VERSION_PTR pVersion;
} CK_SSL3_MASTER_KEY_DERIVE_PARAMS;

typedef struct CK_SSL3_MASTER_KEY_DERIVE_PARAMS *
    CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR;

typedef struct CK_SSL3_KEY_MAT_OUT {
    CK_OBJECT_HANDLE hClientMacSecret;
    CK_OBJECT_HANDLE hServerMacSecret;
    CK_OBJECT_HANDLE hClientKey;
    CK_OBJECT_HANDLE hServerKey;
    CK_BYTE_PTR pIVClient;
    CK_BYTE_PTR pIVServer;
} CK_SSL3_KEY_MAT_OUT;

typedef CK_SSL3_KEY_MAT_OUT * CK_SSL3_KEY_MAT_OUT_PTR;

typedef struct CK_SSL3_KEY_MAT_PARAMS {
    CK_ULONG ulMacSizeInBits;
    CK_ULONG ulKeySizeInBits;
    CK_ULONG ulIVSizeInBits;
    CK_BBOOL bIsExport;
    CK_SSL3_RANDOM_DATA RandomInfo;
    CK_SSL3_KEY_MAT_OUT_PTR pReturnedKeyMaterial;
} CK_SSL3_KEY_MAT_PARAMS;

typedef CK_SSL3_KEY_MAT_PARAMS * CK_SSL3_KEY_MAT_PARAMS_PTR;


typedef struct CK_TLS_PRF_PARAMS {
    CK_BYTE_PTR pSeed;
    CK_ULONG ulSeedLen;
    CK_BYTE_PTR pLabel;
    CK_ULONG ulLabelLen;
    CK_BYTE_PTR pOutput;
    CK_ULONG_PTR pulOutputLen;
} CK_TLS_PRF_PARAMS;

typedef CK_TLS_PRF_PARAMS * CK_TLS_PRF_PARAMS_PTR;


typedef struct CK_TLS12_MASTER_KEY_DERIVE_PARAMS {
    CK_SSL3_RANDOM_DATA RandomInfo;
    CK_VERSION_PTR pVersion;
    CK_MECHANISM_TYPE prfHashMechanism;
} CK_TLS12_MASTER_KEY_DERIVE_PARAMS;

typedef CK_TLS12_MASTER_KEY_DERIVE_PARAMS *
    CK_TLS12_MASTER_KEY_DERIVE_PARAMS_PTR;

typedef struct CK_TLS12_KEY_MAT_PARAMS {
    CK_ULONG ulMacSizeInBits;
    CK_ULONG ulKeySizeInBits;
    CK_ULONG ulIVSizeInBits;
    CK_BBOOL bIsExport;
    CK_SSL3_RANDOM_DATA RandomInfo;
    CK_SSL3_KEY_MAT_OUT_PTR pReturnedKeyMaterial;
    CK_MECHANISM_TYPE prfHashMechanism;
} CK_TLS12_KEY_MAT_PARAMS;

typedef CK_TLS12_KEY_MAT_PARAMS * CK_TLS12_KEY_MAT_PARAMS_PTR;

typedef struct CK_TLS_KDF_PARAMS {
    CK_MECHANISM_TYPE prfMechanism;
    CK_BYTE_PTR pLabel;
    CK_ULONG ulLabelLength;
    CK_SSL3_RANDOM_DATA RandomInfo;
    CK_BYTE_PTR pContextData;
    CK_ULONG ulContextDataLength;
} CK_TLS_KDF_PARAMS;

typedef struct CK_TLS_MAC_PARAMS {
    CK_MECHANISM_TYPE prfMechanism;
    CK_ULONG ulMacLength;
    CK_ULONG ulServerOrClient;
} CK_TLS_MAC_PARAMS;

typedef CK_TLS_MAC_PARAMS * CK_TLS_MAC_PARAMS_PTR;


typedef struct CK_WTLS_RANDOM_DATA {
    CK_BYTE_PTR pClientRandom;
    CK_ULONG ulClientRandomLen;
    CK_BYTE_PTR pServerRandom;
    CK_ULONG ulServerRandomLen;
} CK_WTLS_RANDOM_DATA;

typedef CK_WTLS_RANDOM_DATA * CK_WTLS_RANDOM_DATA_PTR;

typedef struct CK_WTLS_MASTER_KEY_DERIVE_PARAMS {
    CK_MECHANISM_TYPE DigestMechanism;
    CK_WTLS_RANDOM_DATA RandomInfo;
    CK_BYTE_PTR pVersion;
} CK_WTLS_MASTER_KEY_DERIVE_PARAMS;

typedef CK_WTLS_MASTER_KEY_DERIVE_PARAMS *
    CK_WTLS_MASTER_KEY_DERIVE_PARAMS_PTR;

typedef struct CK_WTLS_PRF_PARAMS {
    CK_MECHANISM_TYPE DigestMechanism;
    CK_BYTE_PTR pSeed;
    CK_ULONG ulSeedLen;
    CK_BYTE_PTR pLabel;
    CK_ULONG ulLabelLen;
    CK_BYTE_PTR pOutput;
    CK_ULONG_PTR pulOutputLen;
} CK_WTLS_PRF_PARAMS;

typedef CK_WTLS_PRF_PARAMS * CK_WTLS_PRF_PARAMS_PTR;

typedef struct CK_WTLS_KEY_MAT_OUT {
    CK_OBJECT_HANDLE hMacSecret;
    CK_OBJECT_HANDLE hKey;
    CK_BYTE_PTR pIV;
} CK_WTLS_KEY_MAT_OUT;

typedef CK_WTLS_KEY_MAT_OUT * CK_WTLS_KEY_MAT_OUT_PTR;

typedef struct CK_WTLS_KEY_MAT_PARAMS {
    CK_MECHANISM_TYPE DigestMechanism;
    CK_ULONG ulMacSizeInBits;
    CK_ULONG ulKeySizeInBits;
    CK_ULONG ulIVSizeInBits;
    CK_ULONG ulSequenceNumber;
    CK_BBOOL bIsExport;
    CK_WTLS_RANDOM_DATA RandomInfo;
    CK_WTLS_KEY_MAT_OUT_PTR pReturnedKeyMaterial;
} CK_WTLS_KEY_MAT_PARAMS;

typedef CK_WTLS_KEY_MAT_PARAMS * CK_WTLS_KEY_MAT_PARAMS_PTR;


typedef struct CK_CMS_SIG_PARAMS {
    CK_OBJECT_HANDLE certificateHandle;
    CK_MECHANISM_PTR pSigningMechanism;
    CK_MECHANISM_PTR pDigestMechanism;
    CK_UTF8CHAR_PTR pContentType;
    CK_BYTE_PTR pRequestedAttributes;
    CK_ULONG ulRequestedAttributesLen;
    CK_BYTE_PTR pRequiredAttributes;
    CK_ULONG ulRequiredAttributesLen;
} CK_CMS_SIG_PARAMS;

typedef CK_CMS_SIG_PARAMS * CK_CMS_SIG_PARAMS_PTR;

typedef struct CK_KEY_DERIVATION_STRING_DATA {
    CK_BYTE_PTR pData;
    CK_ULONG ulLen;
} CK_KEY_DERIVATION_STRING_DATA;

typedef CK_KEY_DERIVATION_STRING_DATA *
    CK_KEY_DERIVATION_STRING_DATA_PTR;






typedef CK_ULONG CK_EXTRACT_PARAMS;

typedef CK_EXTRACT_PARAMS * CK_EXTRACT_PARAMS_PTR;





typedef CK_ULONG CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE;

typedef CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE * CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE_PTR;
# 1780 "/usr/include/nss3/pkcs11t.h"
typedef CK_ULONG CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE;

typedef CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE * CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE_PTR;







typedef struct CK_PKCS5_PBKD2_PARAMS {
    CK_PKCS5_PBKDF2_SALT_SOURCE_TYPE saltSource;
    CK_VOID_PTR pSaltSourceData;
    CK_ULONG ulSaltSourceDataLen;
    CK_ULONG iterations;
    CK_PKCS5_PBKD2_PSEUDO_RANDOM_FUNCTION_TYPE prf;
    CK_VOID_PTR pPrfData;
    CK_ULONG ulPrfDataLen;
    CK_UTF8CHAR_PTR pPassword;
    CK_ULONG_PTR ulPasswordLen;
} CK_PKCS5_PBKD2_PARAMS;

typedef CK_PKCS5_PBKD2_PARAMS * CK_PKCS5_PBKD2_PARAMS_PTR;
# 1817 "/usr/include/nss3/pkcs11t.h"
# 1 "/usr/include/nss3/pkcs11n.h" 1
# 265 "/usr/include/nss3/pkcs11n.h"
typedef struct CK_NSS_JPAKEPublicValue {
    CK_BYTE *pGX;
    CK_ULONG ulGXLen;
    CK_BYTE *pGV;
    CK_ULONG ulGVLen;
    CK_BYTE *pR;
    CK_ULONG ulRLen;
} CK_NSS_JPAKEPublicValue;

typedef struct CK_NSS_JPAKERound1Params {
    CK_NSS_JPAKEPublicValue gx1;
    CK_NSS_JPAKEPublicValue gx2;
} CK_NSS_JPAKERound1Params;

typedef struct CK_NSS_JPAKERound2Params {
    CK_BYTE *pSharedKey;
    CK_ULONG ulSharedKeyLen;
    CK_NSS_JPAKEPublicValue gx3;
    CK_NSS_JPAKEPublicValue gx4;
    CK_NSS_JPAKEPublicValue A;
} CK_NSS_JPAKERound2Params;

typedef struct CK_NSS_JPAKEFinalParams {
    CK_NSS_JPAKEPublicValue B;
} CK_NSS_JPAKEFinalParams;
# 306 "/usr/include/nss3/pkcs11n.h"
typedef struct CK_NSS_MAC_CONSTANT_TIME_PARAMS {
    CK_MECHANISM_TYPE macAlg;
    CK_ULONG ulBodyTotalLen;
    CK_BYTE *pHeader;
    CK_ULONG ulHeaderLen;
} CK_NSS_MAC_CONSTANT_TIME_PARAMS;

typedef struct CK_NSS_AEAD_PARAMS {
    CK_BYTE_PTR pNonce;
    CK_ULONG ulNonceLen;
    CK_BYTE_PTR pAAD;
    CK_ULONG ulAADLen;
    CK_ULONG ulTagLen;
} CK_NSS_AEAD_PARAMS;
# 348 "/usr/include/nss3/pkcs11n.h"
typedef struct CK_NSS_HKDFParams {
    CK_BBOOL bExtract;
    CK_BYTE_PTR pSalt;
    CK_ULONG ulSaltLen;
    CK_BBOOL bExpand;
    CK_BYTE_PTR pInfo;
    CK_ULONG ulInfoLen;
} CK_NSS_HKDFParams;
# 368 "/usr/include/nss3/pkcs11n.h"
typedef struct CK_NSS_IKE_PRF_PLUS_DERIVE_PARAMS {
    CK_MECHANISM_TYPE prfMechanism;
    CK_BBOOL bHasSeedKey;
    CK_OBJECT_HANDLE hSeedKey;
    CK_BYTE_PTR pSeedData;
    CK_ULONG ulSeedDataLen;
} CK_NSS_IKE_PRF_PLUS_DERIVE_PARAMS;
# 388 "/usr/include/nss3/pkcs11n.h"
typedef struct CK_NSS_IKE_PRF_DERIVE_PARAMS {
    CK_MECHANISM_TYPE prfMechanism;
    CK_BBOOL bDataAsKey;
    CK_BBOOL bRekey;
    CK_BYTE_PTR pNi;
    CK_ULONG ulNiLen;
    CK_BYTE_PTR pNr;
    CK_ULONG ulNrLen;
    CK_OBJECT_HANDLE hNewKey;
} CK_NSS_IKE_PRF_DERIVE_PARAMS;
# 411 "/usr/include/nss3/pkcs11n.h"
typedef struct CK_NSS_IKE1_PRF_DERIVE_PARAMS {
    CK_MECHANISM_TYPE prfMechanism;
    CK_BBOOL bHasPrevKey;
    CK_OBJECT_HANDLE hKeygxy;
    CK_OBJECT_HANDLE hPrevKey;
    CK_BYTE_PTR pCKYi;
    CK_ULONG ulCKYiLen;
    CK_BYTE_PTR pCKYr;
    CK_ULONG ulCKYrLen;
    CK_BYTE keyNumber;
} CK_NSS_IKE1_PRF_DERIVE_PARAMS;
# 440 "/usr/include/nss3/pkcs11n.h"
typedef struct CK_NSS_TLS_EXTENDED_MASTER_KEY_DERIVE_PARAMS {
    CK_MECHANISM_TYPE prfHashMechanism;
    CK_BYTE_PTR pSessionHash;
    CK_ULONG ulSessionHashLen;
    CK_VERSION_PTR pVersion;
} CK_NSS_TLS_EXTENDED_MASTER_KEY_DERIVE_PARAMS;
# 457 "/usr/include/nss3/pkcs11n.h"
typedef CK_ULONG CK_TRUST;
# 507 "/usr/include/nss3/pkcs11n.h"
typedef CK_TRUST __CKT_NSS_UNTRUSTED __attribute__((deprecated("CKT_NSS_UNTRUSTED really means CKT_NSS_MUST_VERIFY_TRUST")));
typedef CK_TRUST __CKT_NSS_VALID __attribute__((deprecated("CKT_NSS_VALID really means CKT_NSS_NOT_TRUSTED")));
typedef CK_TRUST __CKT_NSS_MUST_VERIFY __attribute__((deprecated("CKT_NSS_MUST_VERIFY really functions as CKT_NSS_TRUST_UNKNOWN")));
# 579 "/usr/include/nss3/pkcs11n.h"
typedef char **( *SECMODModuleDBFunc)(unsigned long function,
                                                 char *parameters, void *moduleSpec);
# 1818 "/usr/include/nss3/pkcs11t.h" 2


# 1 "/usr/include/nss3/pkcs11u.h" 1
# 1821 "/usr/include/nss3/pkcs11t.h" 2
# 10 "/usr/include/nss3/keythi.h" 2
# 1 "/usr/include/nss3/secmodt.h" 1






# 1 "/usr/include/nss3/nssrwlkt.h" 1
# 9 "/usr/include/nss3/nssrwlkt.h"
# 1 "/usr/include/nss3/nssilock.h" 1
# 106 "/usr/include/nss3/nssilock.h"
# 1 "/usr/include/nspr4/prmon.h" 1
# 10 "/usr/include/nspr4/prmon.h"
# 1 "/usr/include/nspr4/prinrval.h" 1
# 23 "/usr/include/nspr4/prinrval.h"
extern "C" {





typedef PRUint32 PRIntervalTime;
# 79 "/usr/include/nspr4/prinrval.h"
extern __attribute__((visibility("default"))) PRIntervalTime PR_IntervalNow(void);
# 97 "/usr/include/nspr4/prinrval.h"
extern __attribute__((visibility("default"))) PRUint32 PR_TicksPerSecond(void);
# 116 "/usr/include/nspr4/prinrval.h"
extern __attribute__((visibility("default"))) PRIntervalTime PR_SecondsToInterval(PRUint32 seconds);
extern __attribute__((visibility("default"))) PRIntervalTime PR_MillisecondsToInterval(PRUint32 milli);
extern __attribute__((visibility("default"))) PRIntervalTime PR_MicrosecondsToInterval(PRUint32 micro);
# 137 "/usr/include/nspr4/prinrval.h"
extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToSeconds(PRIntervalTime ticks);
extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMilliseconds(PRIntervalTime ticks);
extern __attribute__((visibility("default"))) PRUint32 PR_IntervalToMicroseconds(PRIntervalTime ticks);

}
# 11 "/usr/include/nspr4/prmon.h" 2

extern "C" {

typedef struct PRMonitor PRMonitor;
# 23 "/usr/include/nspr4/prmon.h"
extern __attribute__((visibility("default"))) PRMonitor* PR_NewMonitor(void);







extern __attribute__((visibility("default"))) void PR_DestroyMonitor(PRMonitor *mon);






extern __attribute__((visibility("default"))) void PR_EnterMonitor(PRMonitor *mon);






extern __attribute__((visibility("default"))) PRStatus PR_ExitMonitor(PRMonitor *mon);
# 63 "/usr/include/nspr4/prmon.h"
extern __attribute__((visibility("default"))) PRStatus PR_Wait(PRMonitor *mon, PRIntervalTime ticks);






extern __attribute__((visibility("default"))) PRStatus PR_Notify(PRMonitor *mon);






extern __attribute__((visibility("default"))) PRStatus PR_NotifyAll(PRMonitor *mon);
# 92 "/usr/include/nspr4/prmon.h"
extern __attribute__((visibility("default"))) void PR_AssertCurrentThreadInMonitor(PRMonitor *mon);

}
# 107 "/usr/include/nss3/nssilock.h" 2
# 1 "/usr/include/nspr4/prlock.h" 1
# 21 "/usr/include/nspr4/prlock.h"
extern "C" {
# 34 "/usr/include/nspr4/prlock.h"
typedef struct PRLock PRLock;
# 51 "/usr/include/nspr4/prlock.h"
extern __attribute__((visibility("default"))) PRLock* PR_NewLock(void);
# 62 "/usr/include/nspr4/prlock.h"
extern __attribute__((visibility("default"))) void PR_DestroyLock(PRLock *lock);
# 73 "/usr/include/nspr4/prlock.h"
extern __attribute__((visibility("default"))) void PR_Lock(PRLock *lock);
# 85 "/usr/include/nspr4/prlock.h"
extern __attribute__((visibility("default"))) PRStatus PR_Unlock(PRLock *lock);
# 105 "/usr/include/nspr4/prlock.h"
extern __attribute__((visibility("default"))) void PR_AssertCurrentThreadOwnsLock(PRLock *lock);

}
# 108 "/usr/include/nss3/nssilock.h" 2
# 1 "/usr/include/nspr4/prcvar.h" 1
# 9 "/usr/include/nspr4/prcvar.h"
# 1 "/usr/include/nspr4/prlock.h" 1
# 10 "/usr/include/nspr4/prcvar.h" 2


extern "C" {

typedef struct PRCondVar PRCondVar;
# 27 "/usr/include/nspr4/prcvar.h"
extern __attribute__((visibility("default"))) PRCondVar* PR_NewCondVar(PRLock *lock);







extern __attribute__((visibility("default"))) void PR_DestroyCondVar(PRCondVar *cvar);
# 65 "/usr/include/nspr4/prcvar.h"
extern __attribute__((visibility("default"))) PRStatus PR_WaitCondVar(PRCondVar *cvar, PRIntervalTime timeout);
# 80 "/usr/include/nspr4/prcvar.h"
extern __attribute__((visibility("default"))) PRStatus PR_NotifyCondVar(PRCondVar *cvar);
# 90 "/usr/include/nspr4/prcvar.h"
extern __attribute__((visibility("default"))) PRStatus PR_NotifyAllCondVar(PRCondVar *cvar);

}
# 109 "/usr/include/nss3/nssilock.h" 2

# 1 "/usr/include/nss3/nssilckt.h" 1
# 110 "/usr/include/nss3/nssilckt.h"
typedef enum {
    nssILockArena = 0,
    nssILockSession = 1,
    nssILockObject = 2,
    nssILockRefLock = 3,
    nssILockCert = 4,
    nssILockCertDB = 5,
    nssILockDBM = 6,
    nssILockCache = 7,
    nssILockSSL = 8,
    nssILockList = 9,
    nssILockSlot = 10,
    nssILockFreelist = 11,
    nssILockOID = 12,
    nssILockAttribute = 13,
    nssILockPK11cxt = 14,
    nssILockRWLock = 15,
    nssILockOther = 16,
    nssILockSelfServ = 17,
    nssILockKeyDB = 18,
    nssILockLast
} nssILockType;
# 111 "/usr/include/nss3/nssilock.h" 2

extern "C" {
# 266 "/usr/include/nss3/nssilock.h"
}
# 10 "/usr/include/nss3/nssrwlkt.h" 2







typedef struct nssRWLockStr NSSRWLock;
# 8 "/usr/include/nss3/secmodt.h" 2

# 1 "/usr/include/nss3/secoid.h" 1
# 18 "/usr/include/nss3/secoid.h"
# 1 "/usr/include/nss3/secasn1t.h" 1
# 24 "/usr/include/nss3/secasn1t.h"
typedef struct sec_ASN1Template_struct {



    unsigned long kind;





    unsigned long offset;
# 47 "/usr/include/nss3/secasn1t.h"
    const void *sub;







    unsigned int size;
} SEC_ASN1Template;
# 178 "/usr/include/nss3/secasn1t.h"
typedef const SEC_ASN1Template *SEC_ASN1TemplateChooser(void *arg, PRBool enc);
typedef SEC_ASN1TemplateChooser *SEC_ASN1TemplateChooserPtr;
# 206 "/usr/include/nss3/secasn1t.h"
typedef struct sec_DecoderContext_struct SEC_ASN1DecoderContext;




typedef struct sec_EncoderContext_struct SEC_ASN1EncoderContext;







typedef enum {
    SEC_ASN1_Identifier = 0,
    SEC_ASN1_Length = 1,
    SEC_ASN1_Contents = 2,
    SEC_ASN1_EndOfContents = 3
} SEC_ASN1EncodingPart;





typedef void (*SEC_ASN1NotifyProc)(void *arg, PRBool before,
                                   void *dest, int real_depth);
# 263 "/usr/include/nss3/secasn1t.h"
typedef void (*SEC_ASN1WriteProc)(void *arg,
                                  const char *data, unsigned long len,
                                  int depth, SEC_ASN1EncodingPart data_kind);
# 19 "/usr/include/nss3/secoid.h" 2

extern "C" {

extern const SEC_ASN1Template SECOID_AlgorithmIDTemplate[];


extern const SEC_ASN1Template *NSS_Get_SECOID_AlgorithmIDTemplate(void *arg, PRBool enc);




extern SECOidData *SECOID_FindOID(const SECItem *oid);
extern SECOidTag SECOID_FindOIDTag(const SECItem *oid);
extern SECOidData *SECOID_FindOIDByTag(SECOidTag tagnum);
extern SECOidData *SECOID_FindOIDByMechanism(unsigned long mechanism);
# 47 "/usr/include/nss3/secoid.h"
extern SECStatus SECOID_SetAlgorithmID(PLArenaPool *arena, SECAlgorithmID *aid,
                                       SECOidTag tag, SECItem *params);







extern SECStatus SECOID_CopyAlgorithmID(PLArenaPool *arena, SECAlgorithmID *dest,
                                        const SECAlgorithmID *src);




extern SECOidTag SECOID_GetAlgorithmTag(const SECAlgorithmID *aid);






extern void SECOID_DestroyAlgorithmID(SECAlgorithmID *aid, PRBool freeit);





extern SECComparison SECOID_CompareAlgorithmID(SECAlgorithmID *a,
                                               SECAlgorithmID *b);

extern PRBool SECOID_KnownCertExtenOID(SECItem *extenOid);



extern const char *SECOID_FindOIDTagDescription(SECOidTag tagnum);





extern SECOidTag SECOID_AddEntry(const SECOidData *src);




extern SECStatus SECOID_Init(void);




extern SECStatus SECOID_Shutdown(void);
# 113 "/usr/include/nss3/secoid.h"
extern SECStatus SEC_StringToOID(PLArenaPool *pool, SECItem *to,
                                 const char *from, PRUint32 len);

extern void UTIL_SetForkState(PRBool forked);
# 129 "/usr/include/nss3/secoid.h"
extern SECStatus NSS_GetAlgorithmPolicy(SECOidTag tag, PRUint32 *pValue);





extern SECStatus
NSS_SetAlgorithmPolicy(SECOidTag tag, PRUint32 setBits, PRUint32 clearBits);

}
# 10 "/usr/include/nss3/secmodt.h" 2
# 1 "/usr/include/nss3/secasn1.h" 1
# 21 "/usr/include/nss3/secasn1.h"
extern "C" {
# 31 "/usr/include/nss3/secasn1.h"
extern SEC_ASN1DecoderContext *SEC_ASN1DecoderStart(PLArenaPool *pool,
                                                    void *dest,
                                                    const SEC_ASN1Template *t);


extern SECStatus SEC_ASN1DecoderUpdate(SEC_ASN1DecoderContext *cx,
                                       const char *buf,
                                       unsigned long len);

extern SECStatus SEC_ASN1DecoderFinish(SEC_ASN1DecoderContext *cx);


extern void SEC_ASN1DecoderAbort(SEC_ASN1DecoderContext *cx, int error);

extern void SEC_ASN1DecoderSetFilterProc(SEC_ASN1DecoderContext *cx,
                                         SEC_ASN1WriteProc fn,
                                         void *arg, PRBool no_store);

extern void SEC_ASN1DecoderClearFilterProc(SEC_ASN1DecoderContext *cx);

extern void SEC_ASN1DecoderSetNotifyProc(SEC_ASN1DecoderContext *cx,
                                         SEC_ASN1NotifyProc fn,
                                         void *arg);

extern void SEC_ASN1DecoderClearNotifyProc(SEC_ASN1DecoderContext *cx);
# 66 "/usr/include/nss3/secasn1.h"
extern void SEC_ASN1DecoderSetMaximumElementSize(SEC_ASN1DecoderContext *cx,
                                                 unsigned long max_size);

extern SECStatus SEC_ASN1Decode(PLArenaPool *pool, void *dest,
                                const SEC_ASN1Template *t,
                                const char *buf, long len);
# 80 "/usr/include/nss3/secasn1.h"
extern SECStatus SEC_ASN1DecodeItem(PLArenaPool *pool, void *dest,
                                    const SEC_ASN1Template *t,
                                    const SECItem *src);

extern SECStatus SEC_QuickDERDecodeItem(PLArenaPool *arena, void *dest,
                                        const SEC_ASN1Template *templateEntry,
                                        const SECItem *src);





extern SEC_ASN1EncoderContext *SEC_ASN1EncoderStart(const void *src,
                                                    const SEC_ASN1Template *t,
                                                    SEC_ASN1WriteProc fn,
                                                    void *output_arg);


extern SECStatus SEC_ASN1EncoderUpdate(SEC_ASN1EncoderContext *cx,
                                       const char *buf,
                                       unsigned long len);

extern void SEC_ASN1EncoderFinish(SEC_ASN1EncoderContext *cx);


extern void SEC_ASN1EncoderAbort(SEC_ASN1EncoderContext *cx, int error);

extern void SEC_ASN1EncoderSetNotifyProc(SEC_ASN1EncoderContext *cx,
                                         SEC_ASN1NotifyProc fn,
                                         void *arg);

extern void SEC_ASN1EncoderClearNotifyProc(SEC_ASN1EncoderContext *cx);

extern void SEC_ASN1EncoderSetStreaming(SEC_ASN1EncoderContext *cx);

extern void SEC_ASN1EncoderClearStreaming(SEC_ASN1EncoderContext *cx);

extern void sec_ASN1EncoderSetDER(SEC_ASN1EncoderContext *cx);

extern void sec_ASN1EncoderClearDER(SEC_ASN1EncoderContext *cx);

extern void SEC_ASN1EncoderSetTakeFromBuf(SEC_ASN1EncoderContext *cx);

extern void SEC_ASN1EncoderClearTakeFromBuf(SEC_ASN1EncoderContext *cx);

extern SECStatus SEC_ASN1Encode(const void *src, const SEC_ASN1Template *t,
                                SEC_ASN1WriteProc output_proc,
                                void *output_arg);







extern SECItem *SEC_ASN1EncodeItem(PLArenaPool *pool, SECItem *dest,
                                   const void *src, const SEC_ASN1Template *t);

extern SECItem *SEC_ASN1EncodeInteger(PLArenaPool *pool,
                                      SECItem *dest, long value);

extern SECItem *SEC_ASN1EncodeUnsignedInteger(PLArenaPool *pool,
                                              SECItem *dest,
                                              unsigned long value);

extern SECStatus SEC_ASN1DecodeInteger(SECItem *src,
                                       unsigned long *value);
# 156 "/usr/include/nss3/secasn1.h"
extern int SEC_ASN1LengthLength(unsigned long len);



extern int SEC_ASN1EncodeLength(unsigned char *buf, int value);
# 173 "/usr/include/nss3/secasn1.h"
extern const SEC_ASN1Template *
SEC_ASN1GetSubtemplate(const SEC_ASN1Template *inTemplate, void *thing,
                       PRBool encoding);




extern PRBool SEC_ASN1IsTemplateSimple(const SEC_ASN1Template *theTemplate);
# 195 "/usr/include/nss3/secasn1.h"
extern const SEC_ASN1Template SEC_AnyTemplate[];
extern const SEC_ASN1Template SEC_BitStringTemplate[];
extern const SEC_ASN1Template SEC_BMPStringTemplate[];
extern const SEC_ASN1Template SEC_BooleanTemplate[];
extern const SEC_ASN1Template SEC_EnumeratedTemplate[];
extern const SEC_ASN1Template SEC_GeneralizedTimeTemplate[];
extern const SEC_ASN1Template SEC_IA5StringTemplate[];
extern const SEC_ASN1Template SEC_IntegerTemplate[];
extern const SEC_ASN1Template SEC_NullTemplate[];
extern const SEC_ASN1Template SEC_ObjectIDTemplate[];
extern const SEC_ASN1Template SEC_OctetStringTemplate[];
extern const SEC_ASN1Template SEC_PrintableStringTemplate[];
extern const SEC_ASN1Template SEC_T61StringTemplate[];
extern const SEC_ASN1Template SEC_UniversalStringTemplate[];
extern const SEC_ASN1Template SEC_UTCTimeTemplate[];
extern const SEC_ASN1Template SEC_UTF8StringTemplate[];
extern const SEC_ASN1Template SEC_VisibleStringTemplate[];

extern const SEC_ASN1Template SEC_PointerToAnyTemplate[];
extern const SEC_ASN1Template SEC_PointerToBitStringTemplate[];
extern const SEC_ASN1Template SEC_PointerToBMPStringTemplate[];
extern const SEC_ASN1Template SEC_PointerToBooleanTemplate[];
extern const SEC_ASN1Template SEC_PointerToEnumeratedTemplate[];
extern const SEC_ASN1Template SEC_PointerToGeneralizedTimeTemplate[];
extern const SEC_ASN1Template SEC_PointerToIA5StringTemplate[];
extern const SEC_ASN1Template SEC_PointerToIntegerTemplate[];
extern const SEC_ASN1Template SEC_PointerToNullTemplate[];
extern const SEC_ASN1Template SEC_PointerToObjectIDTemplate[];
extern const SEC_ASN1Template SEC_PointerToOctetStringTemplate[];
extern const SEC_ASN1Template SEC_PointerToPrintableStringTemplate[];
extern const SEC_ASN1Template SEC_PointerToT61StringTemplate[];
extern const SEC_ASN1Template SEC_PointerToUniversalStringTemplate[];
extern const SEC_ASN1Template SEC_PointerToUTCTimeTemplate[];
extern const SEC_ASN1Template SEC_PointerToUTF8StringTemplate[];
extern const SEC_ASN1Template SEC_PointerToVisibleStringTemplate[];

extern const SEC_ASN1Template SEC_SequenceOfAnyTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfBitStringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfBMPStringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfBooleanTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfEnumeratedTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfGeneralizedTimeTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfIA5StringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfIntegerTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfNullTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfObjectIDTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfOctetStringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfPrintableStringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfT61StringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfUniversalStringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfUTCTimeTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfUTF8StringTemplate[];
extern const SEC_ASN1Template SEC_SequenceOfVisibleStringTemplate[];

extern const SEC_ASN1Template SEC_SetOfAnyTemplate[];
extern const SEC_ASN1Template SEC_SetOfBitStringTemplate[];
extern const SEC_ASN1Template SEC_SetOfBMPStringTemplate[];
extern const SEC_ASN1Template SEC_SetOfBooleanTemplate[];
extern const SEC_ASN1Template SEC_SetOfEnumeratedTemplate[];
extern const SEC_ASN1Template SEC_SetOfGeneralizedTimeTemplate[];
extern const SEC_ASN1Template SEC_SetOfIA5StringTemplate[];
extern const SEC_ASN1Template SEC_SetOfIntegerTemplate[];
extern const SEC_ASN1Template SEC_SetOfNullTemplate[];
extern const SEC_ASN1Template SEC_SetOfObjectIDTemplate[];
extern const SEC_ASN1Template SEC_SetOfOctetStringTemplate[];
extern const SEC_ASN1Template SEC_SetOfPrintableStringTemplate[];
extern const SEC_ASN1Template SEC_SetOfT61StringTemplate[];
extern const SEC_ASN1Template SEC_SetOfUniversalStringTemplate[];
extern const SEC_ASN1Template SEC_SetOfUTCTimeTemplate[];
extern const SEC_ASN1Template SEC_SetOfUTF8StringTemplate[];
extern const SEC_ASN1Template SEC_SetOfVisibleStringTemplate[];




extern const SEC_ASN1Template SEC_SkipTemplate[];




extern const SEC_ASN1Template *NSS_Get_SEC_AnyTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_BMPStringTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_BooleanTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_BitStringTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_GeneralizedTimeTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_IA5StringTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_IntegerTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_NullTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_ObjectIDTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_OctetStringTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_UTCTimeTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_UTF8StringTemplate(void *arg, PRBool enc);

extern const SEC_ASN1Template *NSS_Get_SEC_PointerToAnyTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_PointerToOctetStringTemplate(void *arg, PRBool enc);

extern const SEC_ASN1Template *NSS_Get_SEC_SetOfAnyTemplate(void *arg, PRBool enc);

extern const SEC_ASN1Template *NSS_Get_SEC_EnumeratedTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_PointerToEnumeratedTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_SequenceOfAnyTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_SequenceOfObjectIDTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_SkipTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_UniversalStringTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_PrintableStringTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_T61StringTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_PointerToGeneralizedTimeTemplate(void *arg, PRBool enc);
}
# 11 "/usr/include/nss3/secmodt.h" 2

# 1 "/usr/include/nss3/utilmodt.h" 1
# 13 "/usr/include/nss3/secmodt.h" 2

extern "C" {


extern const SEC_ASN1Template SECKEY_PointerToEncryptedPrivateKeyInfoTemplate[];
extern const SEC_ASN1Template *NSS_Get_SECKEY_PointerToEncryptedPrivateKeyInfoTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template SECKEY_EncryptedPrivateKeyInfoTemplate[];
extern const SEC_ASN1Template *NSS_Get_SECKEY_EncryptedPrivateKeyInfoTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template SECKEY_PrivateKeyInfoTemplate[];
extern const SEC_ASN1Template *NSS_Get_SECKEY_PrivateKeyInfoTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template SECKEY_PointerToPrivateKeyInfoTemplate[];
extern const SEC_ASN1Template *NSS_Get_SECKEY_PointerToPrivateKeyInfoTemplate(void *arg, PRBool enc);

}


typedef struct SECMODModuleStr SECMODModule;
typedef struct SECMODModuleListStr SECMODModuleList;
typedef NSSRWLock SECMODListLock;
typedef struct PK11SlotInfoStr PK11SlotInfo;
typedef struct NSSUTILPreSlotInfoStr PK11PreSlotInfo;
typedef struct PK11SymKeyStr PK11SymKey;
typedef struct PK11ContextStr PK11Context;
typedef struct PK11SlotListStr PK11SlotList;
typedef struct PK11SlotListElementStr PK11SlotListElement;
typedef struct PK11RSAGenParamsStr PK11RSAGenParams;
typedef unsigned long SECMODModuleID;
typedef struct PK11DefaultArrayEntryStr PK11DefaultArrayEntry;
typedef struct PK11GenericObjectStr PK11GenericObject;
typedef void (*PK11FreeDataFunc)(void *);

struct SECMODModuleStr {
    PLArenaPool *arena;
    PRBool internal;

    PRBool loaded;
    PRBool isFIPS;
    char *dllName;

    char *commonName;
    void *library;

    void *functionList;
    PRLock *refLock;
    int refCount;
    PK11SlotInfo **slots;
    int slotCount;
    PK11PreSlotInfo *slotInfo;
    int slotInfoCount;
    SECMODModuleID moduleID;
    PRBool isThreadSafe;
    unsigned long ssl[2];
    char *libraryParams;
    void *moduleDBFunc;
    SECMODModule *parent;
    PRBool isCritical;
    PRBool isModuleDB;
    PRBool moduleDBOnly;
    int trustOrder;
    int cipherOrder;
    unsigned long evControlMask;

    CK_VERSION cryptokiVersion;
};
# 94 "/usr/include/nss3/secmodt.h"
struct SECMODModuleListStr {
    SECMODModuleList *next;
    SECMODModule *module;
};

struct PK11SlotListStr {
    PK11SlotListElement *head;
    PK11SlotListElement *tail;
    PRLock *lock;
};

struct PK11SlotListElementStr {
    PK11SlotListElement *next;
    PK11SlotListElement *prev;
    PK11SlotInfo *slot;
    int refCount;
};

struct PK11RSAGenParamsStr {
    int keySizeInBits;
    unsigned long pe;
};

typedef enum {
    PK11CertListUnique = 0,
    PK11CertListUser = 1,
    PK11CertListRootUnique = 2,


    PK11CertListCA = 3,
    PK11CertListCAUnique = 4,
    PK11CertListUserUnique = 5,
    PK11CertListAll = 6
} PK11CertListType;






struct PK11DefaultArrayEntryStr {
    const char *name;
    unsigned long flag;
    unsigned long mechanism;

};






typedef PRUint32 PK11AttrFlags;
# 298 "/usr/include/nss3/secmodt.h"
typedef enum {
    PK11_OriginNULL = 0,
    PK11_OriginDerive = 1,
    PK11_OriginGenerated = 2,
    PK11_OriginFortezzaHack = 3,
    PK11_OriginUnwrap = 4
} PK11Origin;


typedef enum {
    PK11_DIS_NONE = 0,
    PK11_DIS_USER_SELECTED = 1,
    PK11_DIS_COULD_NOT_INIT_TOKEN = 2,
    PK11_DIS_TOKEN_VERIFY_FAILED = 3,
    PK11_DIS_TOKEN_NOT_PRESENT = 4
} PK11DisableReasons;
# 324 "/usr/include/nss3/secmodt.h"
typedef enum {
    PK11_TypeGeneric = 0,
    PK11_TypePrivKey = 1,
    PK11_TypePubKey = 2,
    PK11_TypeCert = 3,
    PK11_TypeSymKey = 4
} PK11ObjectType;




typedef char *( *PK11PasswordFunc)(PK11SlotInfo *slot, PRBool retry, void *arg);
typedef PRBool( *PK11VerifyPasswordFunc)(PK11SlotInfo *slot, void *arg);
typedef PRBool( *PK11IsLoggedInFunc)(PK11SlotInfo *slot, void *arg);
# 363 "/usr/include/nss3/secmodt.h"
struct SECKEYAttributeStr {
    SECItem attrType;
    SECItem **attrValue;
};
typedef struct SECKEYAttributeStr SECKEYAttribute;




struct SECKEYPrivateKeyInfoStr {
    PLArenaPool *arena;
    SECItem version;
    SECAlgorithmID algorithm;
    SECItem privateKey;
    SECKEYAttribute **attributes;
};
typedef struct SECKEYPrivateKeyInfoStr SECKEYPrivateKeyInfo;




struct SECKEYEncryptedPrivateKeyInfoStr {
    PLArenaPool *arena;
    SECAlgorithmID algorithm;
    SECItem encryptedData;
};
typedef struct SECKEYEncryptedPrivateKeyInfoStr SECKEYEncryptedPrivateKeyInfo;




typedef enum {
    PK11TokenNotRemovable = 0,
    PK11TokenPresent = 1,
    PK11TokenChanged = 2,
    PK11TokenRemoved = 3
} PK11TokenStatus;

typedef enum {
    PK11TokenRemovedOrChangedEvent = 0,
    PK11TokenPresentEvent = 1
} PK11TokenEvent;
# 415 "/usr/include/nss3/secmodt.h"
typedef struct PK11MergeLogStr PK11MergeLog;
typedef struct PK11MergeLogNodeStr PK11MergeLogNode;



struct PK11MergeLogNodeStr {
    PK11MergeLogNode *next;
    PK11MergeLogNode *prev;
    PK11GenericObject *object;
    int error;
    CK_RV reserved1;
    unsigned long reserved2;
    unsigned long reserved3;
    void *reserved4;
    void *reserved5;
};

struct PK11MergeLogStr {
    PK11MergeLogNode *head;
    PK11MergeLogNode *tail;
    PLArenaPool *arena;
    int version;
    unsigned long reserved1;
    unsigned long reserved2;
    unsigned long reserved3;
    void *reserverd4;
    void *reserverd5;
};
# 11 "/usr/include/nss3/keythi.h" 2
# 1 "/usr/include/nspr4/prclist.h" 1
# 11 "/usr/include/nspr4/prclist.h"
typedef struct PRCListStr PRCList;




struct PRCListStr {
    PRCList *next;
    PRCList *prev;
};
# 12 "/usr/include/nss3/keythi.h" 2
# 27 "/usr/include/nss3/keythi.h"
typedef enum {
    nullKey = 0,
    rsaKey = 1,
    dsaKey = 2,
    fortezzaKey = 3,
    dhKey = 4,
    keaKey = 5,
    ecKey = 6,
    rsaPssKey = 7,
    rsaOaepKey = 8
} KeyType;





extern "C" {
extern const SEC_ASN1Template SECKEY_RSAPublicKeyTemplate[];
extern const SEC_ASN1Template SECKEY_RSAPSSParamsTemplate[];
extern const SEC_ASN1Template SECKEY_DSAPublicKeyTemplate[];
extern const SEC_ASN1Template SECKEY_DHPublicKeyTemplate[];
extern const SEC_ASN1Template SECKEY_DHParamKeyTemplate[];
extern const SEC_ASN1Template SECKEY_PQGParamsTemplate[];
extern const SEC_ASN1Template SECKEY_DSAPrivateKeyExportTemplate[];


extern const SEC_ASN1Template *NSS_Get_SECKEY_DSAPublicKeyTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SECKEY_RSAPublicKeyTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SECKEY_RSAPSSParamsTemplate(void *arg, PRBool enc);
}






struct SECKEYRSAPublicKeyStr {
    PLArenaPool *arena;
    SECItem modulus;
    SECItem publicExponent;
};
typedef struct SECKEYRSAPublicKeyStr SECKEYRSAPublicKey;




struct SECKEYRSAPSSParamsStr {
    SECAlgorithmID *hashAlg;
    SECAlgorithmID *maskAlg;
    SECItem saltLength;
    SECItem trailerField;
};
typedef struct SECKEYRSAPSSParamsStr SECKEYRSAPSSParams;





struct SECKEYPQGParamsStr {
    PLArenaPool *arena;
    SECItem prime;
    SECItem subPrime;
    SECItem base;

};
typedef struct SECKEYPQGParamsStr SECKEYPQGParams;

struct SECKEYDSAPublicKeyStr {
    SECKEYPQGParams params;
    SECItem publicValue;
};
typedef struct SECKEYDSAPublicKeyStr SECKEYDSAPublicKey;





struct SECKEYDHParamsStr {
    PLArenaPool *arena;
    SECItem prime;
    SECItem base;
};
typedef struct SECKEYDHParamsStr SECKEYDHParams;

struct SECKEYDHPublicKeyStr {
    PLArenaPool *arena;
    SECItem prime;
    SECItem base;
    SECItem publicValue;
};
typedef struct SECKEYDHPublicKeyStr SECKEYDHPublicKey;






typedef SECItem SECKEYECParams;

struct SECKEYECPublicKeyStr {
    SECKEYECParams DEREncodedParams;
    int size;
    SECItem publicValue;
    ECPointEncoding encoding;
};
typedef struct SECKEYECPublicKeyStr SECKEYECPublicKey;




struct SECKEYFortezzaPublicKeyStr {
    int KEAversion;
    int DSSversion;
    unsigned char KMID[8];
    SECItem clearance;
    SECItem KEApriviledge;
    SECItem DSSpriviledge;
    SECItem KEAKey;
    SECItem DSSKey;
    SECKEYPQGParams params;
    SECKEYPQGParams keaParams;
};
typedef struct SECKEYFortezzaPublicKeyStr SECKEYFortezzaPublicKey;



struct SECKEYDiffPQGParamsStr {
    SECKEYPQGParams DiffKEAParams;
    SECKEYPQGParams DiffDSAParams;
};
typedef struct SECKEYDiffPQGParamsStr SECKEYDiffPQGParams;

struct SECKEYPQGDualParamsStr {
    SECKEYPQGParams CommParams;
    SECKEYDiffPQGParams DiffParams;
};
typedef struct SECKEYPQGDualParamsStr SECKEYPQGDualParams;

struct SECKEYKEAParamsStr {
    PLArenaPool *arena;
    SECItem hash;
};
typedef struct SECKEYKEAParamsStr SECKEYKEAParams;

struct SECKEYKEAPublicKeyStr {
    SECKEYKEAParams params;
    SECItem publicValue;
};
typedef struct SECKEYKEAPublicKeyStr SECKEYKEAPublicKey;




struct SECKEYPublicKeyStr {
    PLArenaPool *arena;
    KeyType keyType;
    PK11SlotInfo *pkcs11Slot;
    CK_OBJECT_HANDLE pkcs11ID;
    union {
        SECKEYRSAPublicKey rsa;
        SECKEYDSAPublicKey dsa;
        SECKEYDHPublicKey dh;
        SECKEYKEAPublicKey kea;
        SECKEYFortezzaPublicKey fortezza;
        SECKEYECPublicKey ec;
    } u;
};
typedef struct SECKEYPublicKeyStr SECKEYPublicKey;
# 217 "/usr/include/nss3/keythi.h"
struct SECKEYPrivateKeyStr {
    PLArenaPool *arena;
    KeyType keyType;
    PK11SlotInfo *pkcs11Slot;
    CK_OBJECT_HANDLE pkcs11ID;
    PRBool pkcs11IsTemp;
    void *wincx;
    PRUint32 staticflags;
};
typedef struct SECKEYPrivateKeyStr SECKEYPrivateKey;

typedef struct {
    PRCList links;
    SECKEYPrivateKey *key;
} SECKEYPrivateKeyListNode;

typedef struct {
    PRCList list;
    PLArenaPool *arena;
} SECKEYPrivateKeyList;

typedef struct {
    PRCList links;
    SECKEYPublicKey *key;
} SECKEYPublicKeyListNode;

typedef struct {
    PRCList list;
    PLArenaPool *arena;
} SECKEYPublicKeyList;
# 11 "/usr/include/nss3/pk11pub.h" 2
# 1 "/usr/include/nss3/certt.h" 1
# 18 "/usr/include/nss3/certt.h"
# 1 "/usr/include/nspr4/prio.h" 1
# 16 "/usr/include/nspr4/prio.h"
# 1 "/usr/include/nspr4/prlong.h" 1
# 19 "/usr/include/nspr4/prlong.h"
extern "C" {
# 30 "/usr/include/nspr4/prlong.h"
extern __attribute__((visibility("default"))) PRInt64 LL_MaxInt(void);
extern __attribute__((visibility("default"))) PRInt64 LL_MinInt(void);
extern __attribute__((visibility("default"))) PRInt64 LL_Zero(void);
extern __attribute__((visibility("default"))) PRUint64 LL_MaxUint(void);
# 401 "/usr/include/nspr4/prlong.h"
}
# 17 "/usr/include/nspr4/prio.h" 2
# 1 "/usr/include/nspr4/prtime.h" 1
# 21 "/usr/include/nspr4/prtime.h"
extern "C" {
# 48 "/usr/include/nspr4/prtime.h"
typedef PRInt64 PRTime;






typedef struct PRTimeParameters {
    PRInt32 tp_gmt_offset;
    PRInt32 tp_dst_offset;
} PRTimeParameters;
# 83 "/usr/include/nspr4/prtime.h"
typedef struct PRExplodedTime {
    PRInt32 tm_usec;
    PRInt32 tm_sec;

    PRInt32 tm_min;
    PRInt32 tm_hour;
    PRInt32 tm_mday;

    PRInt32 tm_month;
    PRInt16 tm_year;


    PRInt8 tm_wday;

    PRInt16 tm_yday;


    PRTimeParameters tm_params;
} PRExplodedTime;
# 126 "/usr/include/nspr4/prtime.h"
typedef PRTimeParameters ( *PRTimeParamFn)(const PRExplodedTime *gmt);
# 145 "/usr/include/nspr4/prtime.h"
extern __attribute__((visibility("default"))) PRTime
PR_Now(void);
# 158 "/usr/include/nspr4/prtime.h"
extern __attribute__((visibility("default"))) void PR_ExplodeTime(
    PRTime usecs, PRTimeParamFn params, PRExplodedTime *exploded);


extern __attribute__((visibility("default"))) PRTime
PR_ImplodeTime(const PRExplodedTime *exploded);
# 177 "/usr/include/nspr4/prtime.h"
extern __attribute__((visibility("default"))) void PR_NormalizeTime(
    PRExplodedTime *exploded, PRTimeParamFn params);






extern __attribute__((visibility("default"))) PRTimeParameters PR_LocalTimeParameters(const PRExplodedTime *gmt);


extern __attribute__((visibility("default"))) PRTimeParameters PR_GMTParameters(const PRExplodedTime *gmt);





extern __attribute__((visibility("default"))) PRTimeParameters PR_USPacificTimeParameters(const PRExplodedTime *gmt);
# 231 "/usr/include/nspr4/prtime.h"
extern __attribute__((visibility("default"))) PRStatus PR_ParseTimeStringToExplodedTime (
    const char *string,
    PRBool default_to_gmt,
    PRExplodedTime *result);
# 244 "/usr/include/nspr4/prtime.h"
extern __attribute__((visibility("default"))) PRStatus PR_ParseTimeString (
    const char *string,
    PRBool default_to_gmt,
    PRTime *result);


extern __attribute__((visibility("default"))) PRUint32 PR_FormatTime(char *buf, int buflen, const char *fmt,
                                 const PRExplodedTime *time);




extern __attribute__((visibility("default"))) PRUint32
PR_FormatTimeUSEnglish(char *buf, PRUint32 bufSize,
                       const char *format, const PRExplodedTime *time);

}
# 18 "/usr/include/nspr4/prio.h" 2

# 1 "/usr/include/nspr4/prinet.h" 1
# 53 "/usr/include/nspr4/prinet.h"
# 1 "/usr/include/arpa/inet.h" 1 3 4
# 30 "/usr/include/arpa/inet.h" 3 4

# 30 "/usr/include/arpa/inet.h" 3 4
extern "C" {



extern in_addr_t inet_addr (const char *__cp) throw ();


extern in_addr_t inet_lnaof (struct in_addr __in) throw ();



extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
     throw ();


extern in_addr_t inet_netof (struct in_addr __in) throw ();



extern in_addr_t inet_network (const char *__cp) throw ();



extern char *inet_ntoa (struct in_addr __in) throw ();




extern int inet_pton (int __af, const char *__restrict __cp,
        void *__restrict __buf) throw ();




extern const char *inet_ntop (int __af, const void *__restrict __cp,
         char *__restrict __buf, socklen_t __len)
     throw ();






extern int inet_aton (const char *__cp, struct in_addr *__inp) throw ();



extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) throw ();




extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
       char *__buf, size_t __len) throw ();




extern int inet_net_pton (int __af, const char *__cp,
     void *__buf, size_t __len) throw ();




extern unsigned int inet_nsap_addr (const char *__cp,
        unsigned char *__buf, int __len) throw ();



extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
        char *__buf) throw ();


}
# 54 "/usr/include/nspr4/prinet.h" 2

# 1 "/usr/include/netdb.h" 1 3 4
# 32 "/usr/include/netdb.h" 3 4
# 1 "/usr/include/rpc/netdb.h" 1 3 4
# 42 "/usr/include/rpc/netdb.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 43 "/usr/include/rpc/netdb.h" 2 3 4

extern "C" {

struct rpcent
{
  char *r_name;
  char **r_aliases;
  int r_number;
};

extern void setrpcent (int __stayopen) throw ();
extern void endrpcent (void) throw ();
extern struct rpcent *getrpcbyname (const char *__name) throw ();
extern struct rpcent *getrpcbynumber (int __number) throw ();
extern struct rpcent *getrpcent (void) throw ();


extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
      char *__buffer, size_t __buflen,
      struct rpcent **__result) throw ();

extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
        char *__buffer, size_t __buflen,
        struct rpcent **__result) throw ();

extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
   size_t __buflen, struct rpcent **__result) throw ();


}
# 33 "/usr/include/netdb.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

# 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/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;
# 37 "/usr/include/netdb.h" 2 3 4



# 1 "/usr/include/bits/netdb.h" 1 3 4
# 26 "/usr/include/bits/netdb.h" 3 4
struct netent
{
  char *n_name;
  char **n_aliases;
  int n_addrtype;
  uint32_t n_net;
};
# 41 "/usr/include/netdb.h" 2 3 4
# 51 "/usr/include/netdb.h" 3 4
extern "C" {







extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
# 90 "/usr/include/netdb.h" 3 4
extern void herror (const char *__str) throw ();


extern const char *hstrerror (int __err_num) throw ();




struct hostent
{
  char *h_name;
  char **h_aliases;
  int h_addrtype;
  int h_length;
  char **h_addr_list;



};






extern void sethostent (int __stay_open);





extern void endhostent (void);






extern struct hostent *gethostent (void);






extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
          int __type);





extern struct hostent *gethostbyname (const char *__name);
# 153 "/usr/include/netdb.h" 3 4
extern struct hostent *gethostbyname2 (const char *__name, int __af);
# 165 "/usr/include/netdb.h" 3 4
extern int gethostent_r (struct hostent *__restrict __result_buf,
    char *__restrict __buf, size_t __buflen,
    struct hostent **__restrict __result,
    int *__restrict __h_errnop);

extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
       int __type,
       struct hostent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct hostent **__restrict __result,
       int *__restrict __h_errnop);

extern int gethostbyname_r (const char *__restrict __name,
       struct hostent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct hostent **__restrict __result,
       int *__restrict __h_errnop);

extern int gethostbyname2_r (const char *__restrict __name, int __af,
        struct hostent *__restrict __result_buf,
        char *__restrict __buf, size_t __buflen,
        struct hostent **__restrict __result,
        int *__restrict __h_errnop);
# 196 "/usr/include/netdb.h" 3 4
extern void setnetent (int __stay_open);





extern void endnetent (void);






extern struct netent *getnetent (void);






extern struct netent *getnetbyaddr (uint32_t __net, int __type);





extern struct netent *getnetbyname (const char *__name);
# 235 "/usr/include/netdb.h" 3 4
extern int getnetent_r (struct netent *__restrict __result_buf,
   char *__restrict __buf, size_t __buflen,
   struct netent **__restrict __result,
   int *__restrict __h_errnop);

extern int getnetbyaddr_r (uint32_t __net, int __type,
      struct netent *__restrict __result_buf,
      char *__restrict __buf, size_t __buflen,
      struct netent **__restrict __result,
      int *__restrict __h_errnop);

extern int getnetbyname_r (const char *__restrict __name,
      struct netent *__restrict __result_buf,
      char *__restrict __buf, size_t __buflen,
      struct netent **__restrict __result,
      int *__restrict __h_errnop);




struct servent
{
  char *s_name;
  char **s_aliases;
  int s_port;
  char *s_proto;
};






extern void setservent (int __stay_open);





extern void endservent (void);






extern struct servent *getservent (void);






extern struct servent *getservbyname (const char *__name, const char *__proto);






extern struct servent *getservbyport (int __port, const char *__proto);
# 306 "/usr/include/netdb.h" 3 4
extern int getservent_r (struct servent *__restrict __result_buf,
    char *__restrict __buf, size_t __buflen,
    struct servent **__restrict __result);

extern int getservbyname_r (const char *__restrict __name,
       const char *__restrict __proto,
       struct servent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct servent **__restrict __result);

extern int getservbyport_r (int __port, const char *__restrict __proto,
       struct servent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct servent **__restrict __result);




struct protoent
{
  char *p_name;
  char **p_aliases;
  int p_proto;
};






extern void setprotoent (int __stay_open);





extern void endprotoent (void);






extern struct protoent *getprotoent (void);





extern struct protoent *getprotobyname (const char *__name);





extern struct protoent *getprotobynumber (int __proto);
# 372 "/usr/include/netdb.h" 3 4
extern int getprotoent_r (struct protoent *__restrict __result_buf,
     char *__restrict __buf, size_t __buflen,
     struct protoent **__restrict __result);

extern int getprotobyname_r (const char *__restrict __name,
        struct protoent *__restrict __result_buf,
        char *__restrict __buf, size_t __buflen,
        struct protoent **__restrict __result);

extern int getprotobynumber_r (int __proto,
          struct protoent *__restrict __result_buf,
          char *__restrict __buf, size_t __buflen,
          struct protoent **__restrict __result);
# 393 "/usr/include/netdb.h" 3 4
extern int setnetgrent (const char *__netgroup);







extern void endnetgrent (void);
# 410 "/usr/include/netdb.h" 3 4
extern int getnetgrent (char **__restrict __hostp,
   char **__restrict __userp,
   char **__restrict __domainp);
# 421 "/usr/include/netdb.h" 3 4
extern int innetgr (const char *__netgroup, const char *__host,
      const char *__user, const char *__domain);







extern int getnetgrent_r (char **__restrict __hostp,
     char **__restrict __userp,
     char **__restrict __domainp,
     char *__restrict __buffer, size_t __buflen);
# 449 "/usr/include/netdb.h" 3 4
extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
   const char *__restrict __locuser,
   const char *__restrict __remuser,
   const char *__restrict __cmd, int *__restrict __fd2p);
# 461 "/usr/include/netdb.h" 3 4
extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
      const char *__restrict __locuser,
      const char *__restrict __remuser,
      const char *__restrict __cmd, int *__restrict __fd2p,
      sa_family_t __af);
# 477 "/usr/include/netdb.h" 3 4
extern int rexec (char **__restrict __ahost, int __rport,
    const char *__restrict __name,
    const char *__restrict __pass,
    const char *__restrict __cmd, int *__restrict __fd2p);
# 489 "/usr/include/netdb.h" 3 4
extern int rexec_af (char **__restrict __ahost, int __rport,
       const char *__restrict __name,
       const char *__restrict __pass,
       const char *__restrict __cmd, int *__restrict __fd2p,
       sa_family_t __af);
# 503 "/usr/include/netdb.h" 3 4
extern int ruserok (const char *__rhost, int __suser,
      const char *__remuser, const char *__locuser);
# 513 "/usr/include/netdb.h" 3 4
extern int ruserok_af (const char *__rhost, int __suser,
         const char *__remuser, const char *__locuser,
         sa_family_t __af);
# 526 "/usr/include/netdb.h" 3 4
extern int iruserok (uint32_t __raddr, int __suser,
       const char *__remuser, const char *__locuser);
# 537 "/usr/include/netdb.h" 3 4
extern int iruserok_af (const void *__raddr, int __suser,
   const char *__remuser, const char *__locuser,
   sa_family_t __af);
# 549 "/usr/include/netdb.h" 3 4
extern int rresvport (int *__alport);
# 558 "/usr/include/netdb.h" 3 4
extern int rresvport_af (int *__alport, sa_family_t __af);






struct addrinfo
{
  int ai_flags;
  int ai_family;
  int ai_socktype;
  int ai_protocol;
  socklen_t ai_addrlen;
  struct sockaddr *ai_addr;
  char *ai_canonname;
  struct addrinfo *ai_next;
};



struct gaicb
{
  const char *ar_name;
  const char *ar_service;
  const struct addrinfo *ar_request;
  struct addrinfo *ar_result;

  int __return;
  int __glibc_reserved[5];
};
# 660 "/usr/include/netdb.h" 3 4
extern int getaddrinfo (const char *__restrict __name,
   const char *__restrict __service,
   const struct addrinfo *__restrict __req,
   struct addrinfo **__restrict __pai);


extern void freeaddrinfo (struct addrinfo *__ai) throw ();


extern const char *gai_strerror (int __ecode) throw ();





extern int getnameinfo (const struct sockaddr *__restrict __sa,
   socklen_t __salen, char *__restrict __host,
   socklen_t __hostlen, char *__restrict __serv,
   socklen_t __servlen, int __flags);
# 690 "/usr/include/netdb.h" 3 4
extern int getaddrinfo_a (int __mode, struct gaicb *__list[],
     int __ent, struct sigevent *__restrict __sig);
# 701 "/usr/include/netdb.h" 3 4
extern int gai_suspend (const struct gaicb *const __list[], int __ent,
   const struct timespec *__timeout);


extern int gai_error (struct gaicb *__req) throw ();


extern int gai_cancel (struct gaicb *__gaicbp) throw ();


}
# 56 "/usr/include/nspr4/prinet.h" 2
# 20 "/usr/include/nspr4/prio.h" 2


# 21 "/usr/include/nspr4/prio.h"
extern "C" {


typedef struct PRDir PRDir;
typedef struct PRDirEntry PRDirEntry;




typedef struct PRFileDesc PRFileDesc;
typedef struct PRFileInfo PRFileInfo;
typedef struct PRFileInfo64 PRFileInfo64;
typedef union PRNetAddr PRNetAddr;
typedef struct PRIOMethods PRIOMethods;
typedef struct PRPollDesc PRPollDesc;
typedef struct PRFilePrivate PRFilePrivate;
typedef struct PRSendFileData PRSendFileData;
# 50 "/usr/include/nspr4/prio.h"
typedef PRIntn PRDescIdentity;

struct PRFileDesc {
    const PRIOMethods *methods;
    PRFilePrivate *secret;
    PRFileDesc *lower, *higher;
    void ( *dtor)(PRFileDesc *fd);

    PRDescIdentity identity;
};
# 70 "/usr/include/nspr4/prio.h"
typedef enum PRTransmitFileFlags {
    PR_TRANSMITFILE_KEEP_OPEN = 0,

    PR_TRANSMITFILE_CLOSE_SOCKET = 1

} PRTransmitFileFlags;
# 130 "/usr/include/nspr4/prio.h"
struct PRIPv6Addr {
    union {
        PRUint8 _S6_u8[16];
        PRUint16 _S6_u16[8];
        PRUint32 _S6_u32[4];
        PRUint64 _S6_u64[2];
    } _S6_un;
};





typedef struct PRIPv6Addr PRIPv6Addr;

union PRNetAddr {
    struct {
        PRUint16 family;
        char data[14];
    } raw;
    struct {
        PRUint16 family;
        PRUint16 port;
        PRUint32 ip;
        char pad[8];
    } inet;
    struct {
        PRUint16 family;
        PRUint16 port;
        PRUint32 flowinfo;
        PRIPv6Addr ip;
        PRUint32 scope_id;
    } ipv6;

    struct {
        PRUint16 family;




        char path[104];

    } local;

};
# 185 "/usr/include/nspr4/prio.h"
typedef enum PRSockOption
{
    PR_SockOpt_Nonblocking,
    PR_SockOpt_Linger,
    PR_SockOpt_Reuseaddr,
    PR_SockOpt_Keepalive,
    PR_SockOpt_RecvBufferSize,
    PR_SockOpt_SendBufferSize,

    PR_SockOpt_IpTimeToLive,
    PR_SockOpt_IpTypeOfService,

    PR_SockOpt_AddMember,
    PR_SockOpt_DropMember,
    PR_SockOpt_McastInterface,
    PR_SockOpt_McastTimeToLive,
    PR_SockOpt_McastLoopback,

    PR_SockOpt_NoDelay,
    PR_SockOpt_MaxSegment,
    PR_SockOpt_Broadcast,
    PR_SockOpt_Reuseport,

    PR_SockOpt_Last
} PRSockOption;

typedef struct PRLinger {
    PRBool polarity;
    PRIntervalTime linger;
} PRLinger;

typedef struct PRMcastRequest {
    PRNetAddr mcaddr;
    PRNetAddr ifaddr;
} PRMcastRequest;

typedef struct PRSocketOptionData
{
    PRSockOption option;
    union
    {
        PRUintn ip_ttl;
        PRUintn mcast_ttl;
        PRUintn tos;
        PRBool non_blocking;
        PRBool reuse_addr;
        PRBool reuse_port;

        PRBool keep_alive;
        PRBool mcast_loopback;
        PRBool no_delay;
        PRBool broadcast;
        PRSize max_segment;
        PRSize recv_buffer_size;
        PRSize send_buffer_size;
        PRLinger linger;
        PRMcastRequest add_member;
        PRMcastRequest drop_member;
        PRNetAddr mcast_if;
    } value;
} PRSocketOptionData;
# 255 "/usr/include/nspr4/prio.h"
typedef struct PRIOVec {
    char *iov_base;
    int iov_len;
} PRIOVec;






typedef enum PRDescType
{
    PR_DESC_FILE = 1,
    PR_DESC_SOCKET_TCP = 2,
    PR_DESC_SOCKET_UDP = 3,
    PR_DESC_LAYERED = 4,
    PR_DESC_PIPE = 5
} PRDescType;

typedef enum PRSeekWhence {
    PR_SEEK_SET = 0,
    PR_SEEK_CUR = 1,
    PR_SEEK_END = 2
} PRSeekWhence;

extern __attribute__((visibility("default"))) PRDescType PR_GetDescType(PRFileDesc *file);
# 298 "/usr/include/nspr4/prio.h"
typedef PRStatus ( *PRCloseFN)(PRFileDesc *fd);
typedef PRInt32 ( *PRReadFN)(PRFileDesc *fd, void *buf, PRInt32 amount);
typedef PRInt32 ( *PRWriteFN)(PRFileDesc *fd, const void *buf, PRInt32 amount);
typedef PRInt32 ( *PRAvailableFN)(PRFileDesc *fd);
typedef PRInt64 ( *PRAvailable64FN)(PRFileDesc *fd);
typedef PRStatus ( *PRFsyncFN)(PRFileDesc *fd);
typedef PROffset32 ( *PRSeekFN)(PRFileDesc *fd, PROffset32 offset, PRSeekWhence how);
typedef PROffset64 ( *PRSeek64FN)(PRFileDesc *fd, PROffset64 offset, PRSeekWhence how);
typedef PRStatus ( *PRFileInfoFN)(PRFileDesc *fd, PRFileInfo *info);
typedef PRStatus ( *PRFileInfo64FN)(PRFileDesc *fd, PRFileInfo64 *info);
typedef PRInt32 ( *PRWritevFN)(
    PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_size,
    PRIntervalTime timeout);
typedef PRStatus ( *PRConnectFN)(
    PRFileDesc *fd, const PRNetAddr *addr, PRIntervalTime timeout);
typedef PRFileDesc* ( *PRAcceptFN) (
    PRFileDesc *fd, PRNetAddr *addr, PRIntervalTime timeout);
typedef PRStatus ( *PRBindFN)(PRFileDesc *fd, const PRNetAddr *addr);
typedef PRStatus ( *PRListenFN)(PRFileDesc *fd, PRIntn backlog);
typedef PRStatus ( *PRShutdownFN)(PRFileDesc *fd, PRIntn how);
typedef PRInt32 ( *PRRecvFN)(
    PRFileDesc *fd, void *buf, PRInt32 amount,
    PRIntn flags, PRIntervalTime timeout);
typedef PRInt32 ( *PRSendFN) (
    PRFileDesc *fd, const void *buf, PRInt32 amount,
    PRIntn flags, PRIntervalTime timeout);
typedef PRInt32 ( *PRRecvfromFN)(
    PRFileDesc *fd, void *buf, PRInt32 amount,
    PRIntn flags, PRNetAddr *addr, PRIntervalTime timeout);
typedef PRInt32 ( *PRSendtoFN)(
    PRFileDesc *fd, const void *buf, PRInt32 amount,
    PRIntn flags, const PRNetAddr *addr, PRIntervalTime timeout);
typedef PRInt16 ( *PRPollFN)(
    PRFileDesc *fd, PRInt16 in_flags, PRInt16 *out_flags);
typedef PRInt32 ( *PRAcceptreadFN)(
    PRFileDesc *sd, PRFileDesc **nd, PRNetAddr **raddr,
    void *buf, PRInt32 amount, PRIntervalTime t);
typedef PRInt32 ( *PRTransmitfileFN)(
    PRFileDesc *sd, PRFileDesc *fd, const void *headers,
    PRInt32 hlen, PRTransmitFileFlags flags, PRIntervalTime t);
typedef PRStatus ( *PRGetsocknameFN)(PRFileDesc *fd, PRNetAddr *addr);
typedef PRStatus ( *PRGetpeernameFN)(PRFileDesc *fd, PRNetAddr *addr);
typedef PRStatus ( *PRGetsocketoptionFN)(
    PRFileDesc *fd, PRSocketOptionData *data);
typedef PRStatus ( *PRSetsocketoptionFN)(
    PRFileDesc *fd, const PRSocketOptionData *data);
typedef PRInt32 ( *PRSendfileFN)(
    PRFileDesc *networkSocket, PRSendFileData *sendData,
    PRTransmitFileFlags flags, PRIntervalTime timeout);
typedef PRStatus ( *PRConnectcontinueFN)(
    PRFileDesc *fd, PRInt16 out_flags);
typedef PRIntn ( *PRReservedFN)(PRFileDesc *fd);

struct PRIOMethods {
    PRDescType file_type;
    PRCloseFN close;
    PRReadFN read;
    PRWriteFN write;
    PRAvailableFN available;
    PRAvailable64FN available64;
    PRFsyncFN fsync;
    PRSeekFN seek;
    PRSeek64FN seek64;
    PRFileInfoFN fileInfo;
    PRFileInfo64FN fileInfo64;
    PRWritevFN writev;
    PRConnectFN connect;
    PRAcceptFN accept;
    PRBindFN bind;
    PRListenFN listen;
    PRShutdownFN shutdown;
    PRRecvFN recv;
    PRSendFN send;
    PRRecvfromFN recvfrom;
    PRSendtoFN sendto;
    PRPollFN poll;
    PRAcceptreadFN acceptread;
    PRTransmitfileFN transmitfile;
    PRGetsocknameFN getsockname;
    PRGetpeernameFN getpeername;
    PRReservedFN reserved_fn_6;
    PRReservedFN reserved_fn_5;
    PRGetsocketoptionFN getsocketoption;

    PRSetsocketoptionFN setsocketoption;

    PRSendfileFN sendfile;
    PRConnectcontinueFN connectcontinue;

    PRReservedFN reserved_fn_3;
    PRReservedFN reserved_fn_2;
    PRReservedFN reserved_fn_1;
    PRReservedFN reserved_fn_0;
};
# 412 "/usr/include/nspr4/prio.h"
typedef enum PRSpecialFD
{
    PR_StandardInput,
    PR_StandardOutput,
    PR_StandardError
} PRSpecialFD;

extern __attribute__((visibility("default"))) PRFileDesc* PR_GetSpecialFD(PRSpecialFD id);
# 459 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRDescIdentity PR_GetUniqueIdentity(const char *layer_name);
extern __attribute__((visibility("default"))) const char* PR_GetNameForIdentity(PRDescIdentity ident);
extern __attribute__((visibility("default"))) PRDescIdentity PR_GetLayersIdentity(PRFileDesc* fd);
extern __attribute__((visibility("default"))) PRFileDesc* PR_GetIdentitiesLayer(PRFileDesc* fd_stack, PRDescIdentity id);
# 472 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) const PRIOMethods * PR_GetDefaultIOMethods(void);
# 483 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_CreateIOLayerStub(
    PRDescIdentity ident, const PRIOMethods *methods);
# 500 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_CreateIOLayer(PRFileDesc* fd);
# 516 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_PushIOLayer(
    PRFileDesc *fd_stack, PRDescIdentity id, PRFileDesc *layer);
# 533 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_PopIOLayer(PRFileDesc *fd_stack, PRDescIdentity id);
# 607 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_Open(const char *name, PRIntn flags, PRIntn mode);
# 633 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_OpenFile(
    const char *name, PRIntn flags, PRIntn mode);
# 664 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_Close(PRFileDesc *fd);
# 699 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_Read(PRFileDesc *fd, void *buf, PRInt32 amount);
# 723 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_Write(PRFileDesc *fd,const void *buf,PRInt32 amount);
# 757 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_Writev(
    PRFileDesc *fd, const PRIOVec *iov, PRInt32 iov_size,
    PRIntervalTime timeout);
# 778 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_Delete(const char *name);



typedef enum PRFileType
{
    PR_FILE_FILE = 1,
    PR_FILE_DIRECTORY = 2,
    PR_FILE_OTHER = 3
} PRFileType;

struct PRFileInfo {
    PRFileType type;
    PROffset32 size;
    PRTime creationTime;
    PRTime modifyTime;
};

struct PRFileInfo64 {
    PRFileType type;
    PROffset64 size;
    PRTime creationTime;
    PRTime modifyTime;
};
# 821 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_GetFileInfo(const char *fn, PRFileInfo *info);
extern __attribute__((visibility("default"))) PRStatus PR_GetFileInfo64(const char *fn, PRFileInfo64 *info);
# 848 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_GetOpenFileInfo(PRFileDesc *fd, PRFileInfo *info);
extern __attribute__((visibility("default"))) PRStatus PR_GetOpenFileInfo64(PRFileDesc *fd, PRFileInfo64 *info);
# 867 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_Rename(const char *from, const char *to);
# 893 "/usr/include/nspr4/prio.h"
typedef enum PRAccessHow {
    PR_ACCESS_EXISTS = 1,
    PR_ACCESS_WRITE_OK = 2,
    PR_ACCESS_READ_OK = 3
} PRAccessHow;

extern __attribute__((visibility("default"))) PRStatus PR_Access(const char *name, PRAccessHow how);
# 934 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PROffset32 PR_Seek(PRFileDesc *fd, PROffset32 offset, PRSeekWhence whence);
extern __attribute__((visibility("default"))) PROffset64 PR_Seek64(PRFileDesc *fd, PROffset64 offset, PRSeekWhence whence);
# 957 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_Available(PRFileDesc *fd);
extern __attribute__((visibility("default"))) PRInt64 PR_Available64(PRFileDesc *fd);
# 977 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_Sync(PRFileDesc *fd);



struct PRDirEntry {
    const char *name;
};
# 1016 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRDir* PR_OpenDir(const char *name);
# 1048 "/usr/include/nspr4/prio.h"
typedef enum PRDirFlags {
    PR_SKIP_NONE = 0x0,
    PR_SKIP_DOT = 0x1,
    PR_SKIP_DOT_DOT = 0x2,
    PR_SKIP_BOTH = 0x3,
    PR_SKIP_HIDDEN = 0x4
} PRDirFlags;

extern __attribute__((visibility("default"))) PRDirEntry* PR_ReadDir(PRDir *dir, PRDirFlags flags);
# 1082 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_CloseDir(PRDir *dir);
# 1111 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_MkDir(const char *name, PRIntn mode);
# 1123 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_MakeDir(const char *name, PRIntn mode);
# 1143 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_RmDir(const char *name);
# 1162 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_NewUDPSocket(void);
# 1181 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_NewTCPSocket(void);
# 1201 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_OpenUDPSocket(PRIntn af);
# 1221 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_OpenTCPSocket(PRIntn af);
# 1249 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_Connect(
    PRFileDesc *fd, const PRNetAddr *addr, PRIntervalTime timeout);
# 1284 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_ConnectContinue(PRFileDesc *fd, PRInt16 out_flags);
# 1314 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_GetConnectStatus(const PRPollDesc *pd);
# 1338 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc* PR_Accept(
    PRFileDesc *fd, PRNetAddr *addr, PRIntervalTime timeout);
# 1360 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_Bind(PRFileDesc *fd, const PRNetAddr *addr);
# 1382 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_Listen(PRFileDesc *fd, PRIntn backlog);
# 1406 "/usr/include/nspr4/prio.h"
typedef enum PRShutdownHow
{
    PR_SHUTDOWN_RCV = 0,
    PR_SHUTDOWN_SEND = 1,
    PR_SHUTDOWN_BOTH = 2
} PRShutdownHow;

extern __attribute__((visibility("default"))) PRStatus PR_Shutdown(PRFileDesc *fd, PRShutdownHow how);
# 1446 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_Recv(PRFileDesc *fd, void *buf, PRInt32 amount,
                             PRIntn flags, PRIntervalTime timeout);
# 1477 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_Send(PRFileDesc *fd, const void *buf, PRInt32 amount,
                             PRIntn flags, PRIntervalTime timeout);
# 1512 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_RecvFrom(
    PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags,
    PRNetAddr *addr, PRIntervalTime timeout);
# 1545 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_SendTo(
    PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags,
    const PRNetAddr *addr, PRIntervalTime timeout);
# 1585 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_TransmitFile(
    PRFileDesc *networkSocket, PRFileDesc *sourceFile,
    const void *headers, PRInt32 hlen, PRTransmitFileFlags flags,
    PRIntervalTime timeout);
# 1624 "/usr/include/nspr4/prio.h"
struct PRSendFileData {
    PRFileDesc *fd;
    PRUint32 file_offset;
    PRSize file_nbytes;


    const void *header;
    PRInt32 hlen;
    const void *trailer;
    PRInt32 tlen;
};


extern __attribute__((visibility("default"))) PRInt32 PR_SendFile(
    PRFileDesc *networkSocket, PRSendFileData *sendData,
    PRTransmitFileFlags flags, PRIntervalTime timeout);
# 1691 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_AcceptRead(
    PRFileDesc *listenSock, PRFileDesc **acceptedSock,
    PRNetAddr **peerAddr, void *buf, PRInt32 amount, PRIntervalTime timeout);
# 1715 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_NewTCPSocketPair(PRFileDesc *fds[2]);
# 1735 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_GetSockName(PRFileDesc *fd, PRNetAddr *addr);
# 1757 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_GetPeerName(PRFileDesc *fd, PRNetAddr *addr);

extern __attribute__((visibility("default"))) PRStatus PR_GetSocketOption(
    PRFileDesc *fd, PRSocketOptionData *data);

extern __attribute__((visibility("default"))) PRStatus PR_SetSocketOption(
    PRFileDesc *fd, const PRSocketOptionData *data);
# 1792 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_SetFDInheritable(
    PRFileDesc *fd,
    PRBool inheritable);
# 1812 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc * PR_GetInheritedFD(const char *name);
# 1822 "/usr/include/nspr4/prio.h"
typedef struct PRFileMap PRFileMap;




typedef enum PRFileMapProtect {
    PR_PROT_READONLY,
    PR_PROT_READWRITE,
    PR_PROT_WRITECOPY
} PRFileMapProtect;

extern __attribute__((visibility("default"))) PRFileMap * PR_CreateFileMap(
    PRFileDesc *fd,
    PRInt64 size,
    PRFileMapProtect prot);




extern __attribute__((visibility("default"))) PRInt32 PR_GetMemMapAlignment(void);

extern __attribute__((visibility("default"))) void * PR_MemMap(
    PRFileMap *fmap,
    PROffset64 offset,

    PRUint32 len);

extern __attribute__((visibility("default"))) PRStatus PR_MemUnmap(void *addr, PRUint32 len);

extern __attribute__((visibility("default"))) PRStatus PR_CloseFileMap(PRFileMap *fmap);
# 1861 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_SyncMemMap(
    PRFileDesc *fd,
    void *addr,
    PRUint32 len);
# 1879 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRStatus PR_CreatePipe(
    PRFileDesc **readPipe,
    PRFileDesc **writePipe
);





struct PRPollDesc {
    PRFileDesc* fd;
    PRInt16 in_flags;
    PRInt16 out_flags;
};
# 1960 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRInt32 PR_Poll(
    PRPollDesc *pds, PRIntn npds, PRIntervalTime timeout);
# 2004 "/usr/include/nspr4/prio.h"
extern __attribute__((visibility("default"))) PRFileDesc * PR_NewPollableEvent(void);

extern __attribute__((visibility("default"))) PRStatus PR_DestroyPollableEvent(PRFileDesc *event);

extern __attribute__((visibility("default"))) PRStatus PR_SetPollableEvent(PRFileDesc *event);

extern __attribute__((visibility("default"))) PRStatus PR_WaitForPollableEvent(PRFileDesc *event);

}
# 19 "/usr/include/nss3/certt.h" 2



struct NSSCertificateStr;
struct NSSTrustDomainStr;


typedef struct CERTAVAStr CERTAVA;
typedef struct CERTAttributeStr CERTAttribute;
typedef struct CERTAuthInfoAccessStr CERTAuthInfoAccess;
typedef struct CERTAuthKeyIDStr CERTAuthKeyID;
typedef struct CERTBasicConstraintsStr CERTBasicConstraints;
typedef struct NSSTrustDomainStr CERTCertDBHandle;
typedef struct CERTCertExtensionStr CERTCertExtension;
typedef struct CERTCertKeyStr CERTCertKey;
typedef struct CERTCertListStr CERTCertList;
typedef struct CERTCertListNodeStr CERTCertListNode;
typedef struct CERTCertNicknamesStr CERTCertNicknames;
typedef struct CERTCertTrustStr CERTCertTrust;
typedef struct CERTCertDistrustStr CERTCertDistrust;
typedef struct CERTCertificateStr CERTCertificate;
typedef struct CERTCertificateListStr CERTCertificateList;
typedef struct CERTCertificateRequestStr CERTCertificateRequest;
typedef struct CERTCrlStr CERTCrl;
typedef struct CERTCrlDistributionPointsStr CERTCrlDistributionPoints;
typedef struct CERTCrlEntryStr CERTCrlEntry;
typedef struct CERTCrlHeadNodeStr CERTCrlHeadNode;
typedef struct CERTCrlKeyStr CERTCrlKey;
typedef struct CERTCrlNodeStr CERTCrlNode;
typedef struct CERTDERCertsStr CERTDERCerts;
typedef struct CERTDistNamesStr CERTDistNames;
typedef struct CERTGeneralNameStr CERTGeneralName;
typedef struct CERTGeneralNameListStr CERTGeneralNameList;
typedef struct CERTIssuerAndSNStr CERTIssuerAndSN;
typedef struct CERTNameStr CERTName;
typedef struct CERTNameConstraintStr CERTNameConstraint;
typedef struct CERTNameConstraintsStr CERTNameConstraints;
typedef struct CERTOKDomainNameStr CERTOKDomainName;
typedef struct CERTPrivKeyUsagePeriodStr CERTPrivKeyUsagePeriod;
typedef struct CERTPublicKeyAndChallengeStr CERTPublicKeyAndChallenge;
typedef struct CERTRDNStr CERTRDN;
typedef struct CERTSignedCrlStr CERTSignedCrl;
typedef struct CERTSignedDataStr CERTSignedData;
typedef struct CERTStatusConfigStr CERTStatusConfig;
typedef struct CERTSubjectListStr CERTSubjectList;
typedef struct CERTSubjectNodeStr CERTSubjectNode;
typedef struct CERTSubjectPublicKeyInfoStr CERTSubjectPublicKeyInfo;
typedef struct CERTValidityStr CERTValidity;
typedef struct CERTVerifyLogStr CERTVerifyLog;
typedef struct CERTVerifyLogNodeStr CERTVerifyLogNode;
typedef struct CRLDistributionPointStr CRLDistributionPoint;


typedef unsigned long CERTCrlNumber;




struct CERTAVAStr {
    SECItem type;
    SECItem value;
};




struct CERTRDNStr {
    CERTAVA **avas;
};




struct CERTNameStr {
    PLArenaPool *arena;
    CERTRDN **rdns;
};




struct CERTValidityStr {
    PLArenaPool *arena;
    SECItem notBefore;
    SECItem notAfter;
};




struct CERTCertKeyStr {
    SECItem serialNumber;
    SECItem derIssuer;
};





struct CERTSignedDataStr {
    SECItem data;
    SECAlgorithmID signatureAlgorithm;
    SECItem signature;
};




struct CERTSubjectPublicKeyInfoStr {
    PLArenaPool *arena;
    SECAlgorithmID algorithm;
    SECItem subjectPublicKey;
};

struct CERTPublicKeyAndChallengeStr {
    SECItem spki;
    SECItem challenge;
};

struct CERTCertTrustStr {
    unsigned int sslFlags;
    unsigned int emailFlags;
    unsigned int objectSigningFlags;
};
# 151 "/usr/include/nss3/certt.h"
struct CERTCertDistrustStr {
    SECItem serverDistrustAfter;
    SECItem emailDistrustAfter;
};




typedef enum SECTrustTypeEnum {
    trustSSL = 0,
    trustEmail = 1,
    trustObjectSigning = 2,
    trustTypeNone = 3
} SECTrustType;
# 177 "/usr/include/nss3/certt.h"
struct CERTCertExtensionStr {
    SECItem id;
    SECItem critical;
    SECItem value;
};

struct CERTSubjectNodeStr {
    struct CERTSubjectNodeStr *next;
    struct CERTSubjectNodeStr *prev;
    SECItem certKey;
    SECItem keyID;
};

struct CERTSubjectListStr {
    PLArenaPool *arena;
    int ncerts;
    char *emailAddr;
    CERTSubjectNode *head;
    CERTSubjectNode *tail;
    void *entry;
};




struct CERTCertificateStr {






    PLArenaPool *arena;


    char *subjectName;
    char *issuerName;
    CERTSignedData signatureWrap;
    SECItem derCert;
    SECItem derIssuer;
    SECItem derSubject;
    SECItem derPublicKey;
    SECItem certKey;
    SECItem version;
    SECItem serialNumber;
    SECAlgorithmID signature;
    CERTName issuer;
    CERTValidity validity;
    CERTName subject;
    CERTSubjectPublicKeyInfo subjectPublicKeyInfo;
    SECItem issuerID;
    SECItem subjectID;
    CERTCertExtension **extensions;
    char *emailAddr;
    CERTCertDBHandle *dbhandle;
    SECItem subjectKeyID;
    PRBool keyIDGenerated;
    unsigned int keyUsage;
    unsigned int rawKeyUsage;
    PRBool keyUsagePresent;
    PRUint32 nsCertType;






    PRBool keepSession;
    PRBool timeOK;
    CERTOKDomainName *domainOK;






    PRBool isperm;
    PRBool istemp;
    char *nickname;
    char *dbnickname;
    struct NSSCertificateStr *nssCertificate;
    CERTCertTrust *trust;




    int referenceCount;





    CERTSubjectList *subjectList;




    CERTAuthKeyID *authKeyID;
    PRBool isRoot;






    union {
        void *apointer;
        struct {
            unsigned int hasUnsupportedCriticalExt : 1;

        } bits;
    } options;
    int series;


    PK11SlotInfo *slot;
    CK_OBJECT_HANDLE pkcs11ID;
    PRBool ownSlot;

    CERTCertDistrust *distrust;
};
# 313 "/usr/include/nss3/certt.h"
struct CERTDERCertsStr {
    PLArenaPool *arena;
    int numcerts;
    SECItem *rawCerts;
};






struct CERTAttributeStr {
    SECItem attrType;
    SECItem **attrValue;
};




struct CERTCertificateRequestStr {
    PLArenaPool *arena;
    SECItem version;
    CERTName subject;
    CERTSubjectPublicKeyInfo subjectPublicKeyInfo;
    CERTAttribute **attributes;
};





struct CERTCertificateListStr {
    SECItem *certs;
    int len;
    PLArenaPool *arena;
};

struct CERTCertListNodeStr {
    PRCList links;
    CERTCertificate *cert;
    void *appData;
};

struct CERTCertListStr {
    PRCList list;
    PLArenaPool *arena;
};







struct CERTCrlEntryStr {
    SECItem serialNumber;
    SECItem revocationDate;
    CERTCertExtension **extensions;
};

struct CERTCrlStr {
    PLArenaPool *arena;
    SECItem version;
    SECAlgorithmID signatureAlg;
    SECItem derName;
    CERTName name;
    SECItem lastUpdate;
    SECItem nextUpdate;
    CERTCrlEntry **entries;
    CERTCertExtension **extensions;

};

struct CERTCrlKeyStr {
    SECItem derName;
    SECItem dummy;



};

struct CERTSignedCrlStr {
    PLArenaPool *arena;
    CERTCrl crl;
    void *reserved1;
    PRBool reserved2;
    PRBool isperm;
    PRBool istemp;
    int referenceCount;
    CERTCertDBHandle *dbhandle;
    CERTSignedData signatureWrap;
    char *url;
    SECItem *derCrl;
    PK11SlotInfo *slot;
    CK_OBJECT_HANDLE pkcs11ID;
    void *opaque;
};

struct CERTCrlHeadNodeStr {
    PLArenaPool *arena;
    CERTCertDBHandle *dbhandle;
    CERTCrlNode *first;
    CERTCrlNode *last;
};

struct CERTCrlNodeStr {
    CERTCrlNode *next;
    int type;
    CERTSignedCrl *crl;
};




struct CERTDistNamesStr {
    PLArenaPool *arena;
    int nnames;
    SECItem *names;
    void *head;
};
# 467 "/usr/include/nss3/certt.h"
typedef enum SECCertUsageEnum {
    certUsageSSLClient = 0,
    certUsageSSLServer = 1,
    certUsageSSLServerWithStepUp = 2,
    certUsageSSLCA = 3,
    certUsageEmailSigner = 4,
    certUsageEmailRecipient = 5,
    certUsageObjectSigner = 6,
    certUsageUserCertImport = 7,
    certUsageVerifyCA = 8,
    certUsageProtectedObjectSigner = 9,
    certUsageStatusResponder = 10,
    certUsageAnyCA = 11,
    certUsageIPsec = 12
} SECCertUsage;

typedef PRInt64 SECCertificateUsage;
# 505 "/usr/include/nss3/certt.h"
typedef enum CERTCertOwnerEnum {
    certOwnerUser = 0,
    certOwnerPeer = 1,
    certOwnerCA = 2
} CERTCertOwner;




typedef enum SECCertTimeValidityEnum {
    secCertTimeValid = 0,
    secCertTimeExpired = 1,
    secCertTimeNotValidYet = 2,
    secCertTimeUndetermined = 3

} SECCertTimeValidity;







typedef enum CERTCompareValidityStatusEnum {
    certValidityUndetermined = 0,

    certValidityChooseB = 1,
    certValidityEqual = 2,
    certValidityChooseA = 3
} CERTCompareValidityStatus;
# 546 "/usr/include/nss3/certt.h"
struct CERTCertNicknamesStr {
    PLArenaPool *arena;
    void *head;
    int numnicknames;
    char **nicknames;
    int what;
    int totallen;
};

struct CERTIssuerAndSNStr {
    SECItem derIssuer;
    CERTName issuer;
    SECItem serialNumber;
};
# 601 "/usr/include/nss3/certt.h"
struct CERTBasicConstraintsStr {
    PRBool isCA;
    int pathLenConstraint;



};
# 625 "/usr/include/nss3/certt.h"
typedef enum CERTCRLEntryReasonCodeEnum {
    crlEntryReasonUnspecified = 0,
    crlEntryReasonKeyCompromise = 1,
    crlEntryReasonCaCompromise = 2,
    crlEntryReasonAffiliationChanged = 3,
    crlEntryReasonSuperseded = 4,
    crlEntryReasonCessationOfOperation = 5,
    crlEntryReasoncertificatedHold = 6,
    crlEntryReasonRemoveFromCRL = 8,
    crlEntryReasonPrivilegeWithdrawn = 9,
    crlEntryReasonAaCompromise = 10
} CERTCRLEntryReasonCode;



typedef enum CERTGeneralNameTypeEnum {
    certOtherName = 1,
    certRFC822Name = 2,
    certDNSName = 3,
    certX400Address = 4,
    certDirectoryName = 5,
    certEDIPartyName = 6,
    certURI = 7,
    certIPAddress = 8,
    certRegisterID = 9
} CERTGeneralNameType;

typedef struct OtherNameStr {
    SECItem name;
    SECItem oid;
} OtherName;

struct CERTGeneralNameStr {
    CERTGeneralNameType type;
    union {
        CERTName directoryName;
        OtherName OthName;
        SECItem other;
    } name;
    SECItem derDirectoryName;

    PRCList l;
};

struct CERTGeneralNameListStr {
    PLArenaPool *arena;
    CERTGeneralName *name;
    int refCount;
    int len;
    PRLock *lock;
};

struct CERTNameConstraintStr {
    CERTGeneralName name;
    SECItem DERName;
    SECItem min;
    SECItem max;
    PRCList l;
};

struct CERTNameConstraintsStr {
    CERTNameConstraint *permited;
    CERTNameConstraint *excluded;
    SECItem **DERPermited;
    SECItem **DERExcluded;
};


struct CERTPrivKeyUsagePeriodStr {
    SECItem notBefore;
    SECItem notAfter;
    PLArenaPool *arena;
};




struct CERTAuthKeyIDStr {
    SECItem keyID;
    CERTGeneralName *authCertIssuer;
    SECItem authCertSerialNumber;
    SECItem **DERAuthCertIssuer;




};






typedef enum DistributionPointTypesEnum {
    generalName = 1,
    relativeDistinguishedName = 2
} DistributionPointTypes;

struct CRLDistributionPointStr {
    DistributionPointTypes distPointType;
    union {
        CERTGeneralName *fullName;
        CERTRDN relativeName;
    } distPoint;
    SECItem reasons;
    CERTGeneralName *crlIssuer;


    SECItem derDistPoint;
    SECItem derRelativeName;
    SECItem **derCrlIssuer;
    SECItem **derFullName;
    SECItem bitsmap;
};

struct CERTCrlDistributionPointsStr {
    CRLDistributionPoint **distPoints;
};






struct CERTVerifyLogNodeStr {
    CERTCertificate *cert;
    long error;
    unsigned int depth;
    void *arg;
    struct CERTVerifyLogNodeStr *next;
    struct CERTVerifyLogNodeStr *prev;
};

struct CERTVerifyLogStr {
    PLArenaPool *arena;
    unsigned int count;
    struct CERTVerifyLogNodeStr *head;
    struct CERTVerifyLogNodeStr *tail;
};

struct CERTOKDomainNameStr {
    CERTOKDomainName *next;
    char *name;
};

typedef SECStatus( *CERTStatusChecker)(CERTCertDBHandle *handle,
                                                  CERTCertificate *cert,
                                                  PRTime time, void *pwArg);

typedef SECStatus( *CERTStatusDestroy)(CERTStatusConfig *handle);

struct CERTStatusConfigStr {
    CERTStatusChecker statusChecker;
    CERTStatusDestroy statusDestroy;
    void *statusContext;
};

struct CERTAuthInfoAccessStr {
    SECItem method;
    SECItem derLocation;
    CERTGeneralName *location;
};



typedef char *(*CERTDBNameFunc)(void *arg, int dbVersion);




typedef enum CERTPackageTypeEnum {
    certPackageNone = 0,
    certPackageCert = 1,
    certPackagePKCS7 = 2,
    certPackageNSCertSeq = 3,
    certPackageNSCertWrap = 4
} CERTPackageType;




typedef struct {
    SECOidTag oid;
    SECItem qualifierID;
    SECItem qualifierValue;
} CERTPolicyQualifier;

typedef struct {
    SECOidTag oid;
    SECItem policyID;
    CERTPolicyQualifier **policyQualifiers;
} CERTPolicyInfo;

typedef struct {
    PLArenaPool *arena;
    CERTPolicyInfo **policyInfos;
} CERTCertificatePolicies;

typedef struct {
    SECItem organization;
    SECItem **noticeNumbers;
} CERTNoticeReference;

typedef struct {
    PLArenaPool *arena;
    CERTNoticeReference noticeReference;
    SECItem derNoticeReference;
    SECItem displayText;
} CERTUserNotice;

typedef struct {
    PLArenaPool *arena;
    SECItem **oids;
} CERTOidSequence;




typedef struct {
    SECItem issuerDomainPolicy;
    SECItem subjectDomainPolicy;
} CERTPolicyMap;

typedef struct {
    PLArenaPool *arena;
    CERTPolicyMap **policyMaps;
} CERTCertificatePolicyMappings;




typedef struct {
    SECItem inhibitAnySkipCerts;
} CERTCertificateInhibitAny;




typedef struct {
    SECItem explicitPolicySkipCerts;
    SECItem inhibitMappingSkipCerts;
} CERTCertificatePolicyConstraints;
# 889 "/usr/include/nss3/certt.h"
typedef SECStatus (*CERTChainVerifyCallbackFunc)(
    void *isChainValidArg, const CERTCertList *currentChain, PRBool *chainOK);





typedef struct {
    CERTChainVerifyCallbackFunc isChainValid;
    void *isChainValidArg;
} CERTChainVerifyCallback;






typedef enum {
    cert_pi_end = 0,

    cert_pi_nbioContext = 1,





    cert_pi_nbioAbort = 2,






    cert_pi_certList = 3,



    cert_pi_policyOID = 4,




    cert_pi_policyFlags = 5,




    cert_pi_keyusage = 6,






    cert_pi_extendedKeyusage = 7,






    cert_pi_date = 8,


    cert_pi_revocationFlags = 9,


    cert_pi_certStores = 10,

    cert_pi_trustAnchors =
        11,
# 972 "/usr/include/nss3/certt.h"
    cert_pi_useAIACertFetch = 12,


    cert_pi_chainVerifyCallback = 13,



    cert_pi_useOnlyTrustAnchors = 14,
# 990 "/usr/include/nss3/certt.h"
    cert_pi_max

} CERTValParamInType;
# 1002 "/usr/include/nss3/certt.h"
typedef enum {
    cert_po_end = 0,

    cert_po_nbioContext = 1,






    cert_po_trustAnchor = 2,



    cert_po_certList = 3,



    cert_po_policyOID = 4,



    cert_po_errorLog = 5,

    cert_po_usages = 6,

    cert_po_keyUsage = 7,


    cert_po_extendedKeyusage = 8,


    cert_po_max


} CERTValParamOutType;

typedef enum {
    cert_revocation_method_crl = 0,
    cert_revocation_method_ocsp,
    cert_revocation_method_count
} CERTRevocationMethodIndex;
# 1165 "/usr/include/nss3/certt.h"
typedef struct {





    PRUint32 number_of_defined_methods;
# 1186 "/usr/include/nss3/certt.h"
    PRUint64 *cert_rev_flags_per_method;
# 1195 "/usr/include/nss3/certt.h"
    PRUint32 number_of_preferred_methods;
# 1204 "/usr/include/nss3/certt.h"
    CERTRevocationMethodIndex *preferred_methods;






    PRUint64 cert_rev_method_independent_flags;
} CERTRevocationTests;

typedef struct {
    CERTRevocationTests leafTests;
    CERTRevocationTests chainTests;
} CERTRevocationFlags;

typedef struct CERTValParamInValueStr {
    union {
        PRBool b;
        PRInt32 i;
        PRUint32 ui;
        PRInt64 l;
        PRUint64 ul;
        PRTime time;
    } scalar;
    union {
        const void *p;
        const char *s;
        const CERTCertificate *cert;
        const CERTCertList *chain;
        const CERTRevocationFlags *revocation;
        const CERTChainVerifyCallback *chainVerifyCallback;
    } pointer;
    union {
        const PRInt32 *pi;
        const PRUint32 *pui;
        const PRInt64 *pl;
        const PRUint64 *pul;
        const SECOidTag *oids;
    } array;
    int arraySize;
} CERTValParamInValue;

typedef struct CERTValParamOutValueStr {
    union {
        PRBool b;
        PRInt32 i;
        PRUint32 ui;
        PRInt64 l;
        PRUint64 ul;
        SECCertificateUsage usages;
    } scalar;
    union {
        void *p;
        char *s;
        CERTVerifyLog *log;
        CERTCertificate *cert;
        CERTCertList *chain;
    } pointer;
    union {
        void *p;
        SECOidTag *oids;
    } array;
    int arraySize;
} CERTValParamOutValue;

typedef struct {
    CERTValParamInType type;
    CERTValParamInValue value;
} CERTValInParam;

typedef struct {
    CERTValParamOutType type;
    CERTValParamOutValue value;
} CERTValOutParam;




typedef enum CertStrictnessLevels {
    CERT_N2A_READABLE = 0,
    CERT_N2A_STRICT = 10,
    CERT_N2A_INVERTIBLE = 20

} CertStrictnessLevel;
# 1306 "/usr/include/nss3/certt.h"
typedef char *(*CERT_StringFromCertFcn)(CERTCertificate *cert);






extern "C" {

extern const SEC_ASN1Template CERT_CertificateRequestTemplate[];
extern const SEC_ASN1Template CERT_CertificateTemplate[];
extern const SEC_ASN1Template SEC_SignedCertificateTemplate[];
extern const SEC_ASN1Template CERT_CertExtensionTemplate[];
extern const SEC_ASN1Template CERT_SequenceOfCertExtensionTemplate[];
extern const SEC_ASN1Template SECKEY_PublicKeyTemplate[];
extern const SEC_ASN1Template CERT_SubjectPublicKeyInfoTemplate[];
extern const SEC_ASN1Template CERT_TimeChoiceTemplate[];
extern const SEC_ASN1Template CERT_ValidityTemplate[];
extern const SEC_ASN1Template CERT_PublicKeyAndChallengeTemplate[];
extern const SEC_ASN1Template SEC_CertSequenceTemplate[];

extern const SEC_ASN1Template CERT_IssuerAndSNTemplate[];
extern const SEC_ASN1Template CERT_NameTemplate[];
extern const SEC_ASN1Template CERT_SetOfSignedCrlTemplate[];
extern const SEC_ASN1Template CERT_RDNTemplate[];
extern const SEC_ASN1Template CERT_SignedDataTemplate[];
extern const SEC_ASN1Template CERT_CrlTemplate[];
extern const SEC_ASN1Template CERT_SignedCrlTemplate[];




extern const SEC_ASN1Template CERT_AttributeTemplate[];
extern const SEC_ASN1Template CERT_SetOfAttributeTemplate[];




extern const SEC_ASN1Template *NSS_Get_CERT_CertificateRequestTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_CertificateTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_CrlTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_IssuerAndSNTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_NameTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_SequenceOfCertExtensionTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_SetOfSignedCrlTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_SignedDataTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_SubjectPublicKeyInfoTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_SEC_SignedCertificateTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_SignedCrlTemplate(void *arg, PRBool enc);
extern const SEC_ASN1Template *NSS_Get_CERT_TimeChoiceTemplate(void *arg, PRBool enc);

}
# 12 "/usr/include/nss3/pk11pub.h" 2



# 1 "/usr/include/nss3/pkcs7t.h" 1
# 20 "/usr/include/nss3/pkcs7t.h"
typedef struct SEC_PKCS7DecoderContextStr SEC_PKCS7DecoderContext;
typedef struct SEC_PKCS7EncoderContextStr SEC_PKCS7EncoderContext;


typedef void *(*SECKEYGetPasswordKey)(void *arg, void *handle);
# 56 "/usr/include/nss3/pkcs7t.h"
typedef struct SEC_PKCS7ContentInfoStr SEC_PKCS7ContentInfo;
typedef struct SEC_PKCS7SignedDataStr SEC_PKCS7SignedData;
typedef struct SEC_PKCS7EncryptedContentInfoStr SEC_PKCS7EncryptedContentInfo;
typedef struct SEC_PKCS7EnvelopedDataStr SEC_PKCS7EnvelopedData;
typedef struct SEC_PKCS7SignedAndEnvelopedDataStr
    SEC_PKCS7SignedAndEnvelopedData;
typedef struct SEC_PKCS7SignerInfoStr SEC_PKCS7SignerInfo;
typedef struct SEC_PKCS7RecipientInfoStr SEC_PKCS7RecipientInfo;
typedef struct SEC_PKCS7DigestedDataStr SEC_PKCS7DigestedData;
typedef struct SEC_PKCS7EncryptedDataStr SEC_PKCS7EncryptedData;






typedef struct SEC_PKCS7AttributeStr SEC_PKCS7Attribute;

struct SEC_PKCS7ContentInfoStr {
    PLArenaPool *poolp;
    PRBool created;
    int refCount;
    SECOidData *contentTypeTag;
    SECKEYGetPasswordKey pwfn;
    void *pwfn_arg;
    SECItem contentType;
    union {
        SECItem *data;
        SEC_PKCS7DigestedData *digestedData;
        SEC_PKCS7EncryptedData *encryptedData;
        SEC_PKCS7EnvelopedData *envelopedData;
        SEC_PKCS7SignedData *signedData;
        SEC_PKCS7SignedAndEnvelopedData *signedAndEnvelopedData;
    } content;
};

struct SEC_PKCS7SignedDataStr {
    SECItem version;
    SECAlgorithmID **digestAlgorithms;
    SEC_PKCS7ContentInfo contentInfo;
    SECItem **rawCerts;
    CERTSignedCrl **crls;
    SEC_PKCS7SignerInfo **signerInfos;
    SECItem **digests;
    CERTCertificate **certs;
    CERTCertificateList **certLists;
};


struct SEC_PKCS7EncryptedContentInfoStr {
    SECOidData *contentTypeTag;
    SECItem contentType;
    SECAlgorithmID contentEncAlg;
    SECItem encContent;
    SECItem plainContent;

    int keysize;


    SECOidTag encalg;


};

struct SEC_PKCS7EnvelopedDataStr {
    SECItem version;
    SEC_PKCS7RecipientInfo **recipientInfos;
    SEC_PKCS7EncryptedContentInfo encContentInfo;
};


struct SEC_PKCS7SignedAndEnvelopedDataStr {
    SECItem version;
    SEC_PKCS7RecipientInfo **recipientInfos;
    SECAlgorithmID **digestAlgorithms;
    SEC_PKCS7EncryptedContentInfo encContentInfo;
    SECItem **rawCerts;
    CERTSignedCrl **crls;
    SEC_PKCS7SignerInfo **signerInfos;
    SECItem **digests;
    CERTCertificate **certs;
    CERTCertificateList **certLists;
    PK11SymKey *sigKey;
};


struct SEC_PKCS7SignerInfoStr {
    SECItem version;
    CERTIssuerAndSN *issuerAndSN;
    SECAlgorithmID digestAlg;
    SEC_PKCS7Attribute **authAttr;
    SECAlgorithmID digestEncAlg;
    SECItem encDigest;
    SEC_PKCS7Attribute **unAuthAttr;
    CERTCertificate *cert;
    CERTCertificateList *certList;
};


struct SEC_PKCS7RecipientInfoStr {
    SECItem version;
    CERTIssuerAndSN *issuerAndSN;
    SECAlgorithmID keyEncAlg;
    SECItem encKey;
    CERTCertificate *cert;
};


struct SEC_PKCS7DigestedDataStr {
    SECItem version;
    SECAlgorithmID digestAlg;
    SEC_PKCS7ContentInfo contentInfo;
    SECItem digest;
};


struct SEC_PKCS7EncryptedDataStr {
    SECItem version;
    SEC_PKCS7EncryptedContentInfo encContentInfo;
};





struct SEC_PKCS7AttributeStr {

    SECItem type;
    SECItem **values;

    SECOidData *typeTag;
    PRBool encoded;
};
# 198 "/usr/include/nss3/pkcs7t.h"
typedef void (*SEC_PKCS7DecoderContentCallback)(void *arg,
                                                const char *buf,
                                                unsigned long len);
# 209 "/usr/include/nss3/pkcs7t.h"
typedef void (*SEC_PKCS7EncoderOutputCallback)(void *arg,
                                               const char *buf,
                                               unsigned long len);







typedef PK11SymKey *(*SEC_PKCS7GetDecryptKeyCallback)(void *arg,
                                                      SECAlgorithmID *algid);
# 230 "/usr/include/nss3/pkcs7t.h"
typedef PRBool (*SEC_PKCS7DecryptionAllowedCallback)(SECAlgorithmID *algid,
                                                     PK11SymKey *bulkkey);
# 16 "/usr/include/nss3/pk11pub.h" 2
# 1 "/usr/include/nss3/cmsreclist.h" 1







struct NSSCMSRecipientStr {
    int riIndex;
    int subIndex;

    enum { RLIssuerSN = 0,
           RLSubjKeyID = 1 } kind;
    union {
        CERTIssuerAndSN* issuerAndSN;
        SECItem* subjectKeyID;
    } id;


    CERTCertificate* cert;
    SECKEYPrivateKey* privkey;
    PK11SlotInfo* slot;
};

typedef struct NSSCMSRecipientStr NSSCMSRecipient;
# 17 "/usr/include/nss3/pk11pub.h" 2





extern "C" {




void PK11_FreeSlotList(PK11SlotList *list);
SECStatus PK11_FreeSlotListElement(PK11SlotList *list, PK11SlotListElement *le);
PK11SlotListElement *PK11_GetFirstSafe(PK11SlotList *list);
PK11SlotListElement *PK11_GetNextSafe(PK11SlotList *list,
                                      PK11SlotListElement *le, PRBool restart);




PK11SlotInfo *PK11_ReferenceSlot(PK11SlotInfo *slot);
void PK11_FreeSlot(PK11SlotInfo *slot);
SECStatus PK11_DestroyObject(PK11SlotInfo *slot, CK_OBJECT_HANDLE object);
SECStatus PK11_DestroyTokenObject(PK11SlotInfo *slot, CK_OBJECT_HANDLE object);
PK11SlotInfo *PK11_GetInternalKeySlot(void);
PK11SlotInfo *PK11_GetInternalSlot(void);
SECStatus PK11_Logout(PK11SlotInfo *slot);
void PK11_LogoutAll(void);




void PK11_SetSlotPWValues(PK11SlotInfo *slot, int askpw, int timeout);
void PK11_GetSlotPWValues(PK11SlotInfo *slot, int *askpw, int *timeout);
SECStatus PK11_CheckSSOPassword(PK11SlotInfo *slot, char *ssopw);
SECStatus PK11_CheckUserPassword(PK11SlotInfo *slot, const char *pw);
PRBool PK11_IsLoggedIn(PK11SlotInfo *slot, void *wincx);
SECStatus PK11_InitPin(PK11SlotInfo *slot, const char *ssopw,
                       const char *pk11_userpwd);
SECStatus PK11_ChangePW(PK11SlotInfo *slot, const char *oldpw,
                        const char *newpw);
void PK11_SetPasswordFunc(PK11PasswordFunc func);
int PK11_GetMinimumPwdLength(PK11SlotInfo *slot);
SECStatus PK11_ResetToken(PK11SlotInfo *slot, char *sso_pwd);
SECStatus PK11_Authenticate(PK11SlotInfo *slot, PRBool loadCerts, void *wincx);
SECStatus PK11_TokenRefresh(PK11SlotInfo *slot);




PK11SlotInfo *PK11_FindSlotByName(const char *name);






PK11SlotList *PK11_FindSlotsByNames(const char *dllName,
                                    const char *slotName, const char *tokenName, PRBool presentOnly);
PRBool PK11_IsReadOnly(PK11SlotInfo *slot);
PRBool PK11_IsInternal(PK11SlotInfo *slot);
PRBool PK11_IsInternalKeySlot(PK11SlotInfo *slot);
char *PK11_GetTokenName(PK11SlotInfo *slot);
char *PK11_GetTokenURI(PK11SlotInfo *slot);
char *PK11_GetSlotName(PK11SlotInfo *slot);
PRBool PK11_NeedLogin(PK11SlotInfo *slot);
PRBool PK11_IsFriendly(PK11SlotInfo *slot);
PRBool PK11_IsHW(PK11SlotInfo *slot);
PRBool PK11_IsRemovable(PK11SlotInfo *slot);
PRBool PK11_NeedUserInit(PK11SlotInfo *slot);
PRBool PK11_ProtectedAuthenticationPath(PK11SlotInfo *slot);
int PK11_GetSlotSeries(PK11SlotInfo *slot);
int PK11_GetCurrentWrapIndex(PK11SlotInfo *slot);
unsigned long PK11_GetDefaultFlags(PK11SlotInfo *slot);
CK_SLOT_ID PK11_GetSlotID(PK11SlotInfo *slot);
SECMODModuleID PK11_GetModuleID(PK11SlotInfo *slot);
SECStatus PK11_GetSlotInfo(PK11SlotInfo *slot, CK_SLOT_INFO *info);
SECStatus PK11_GetTokenInfo(PK11SlotInfo *slot, CK_TOKEN_INFO *info);
PRBool PK11_IsDisabled(PK11SlotInfo *slot);
PRBool PK11_HasRootCerts(PK11SlotInfo *slot);
PK11DisableReasons PK11_GetDisabledReason(PK11SlotInfo *slot);




PRBool PK11_UserDisableSlot(PK11SlotInfo *slot);


PRBool PK11_UserEnableSlot(PK11SlotInfo *slot);
# 133 "/usr/include/nss3/pk11pub.h"
PK11TokenStatus PK11_WaitForTokenEvent(PK11SlotInfo *slot, PK11TokenEvent event,
                                       PRIntervalTime timeout, PRIntervalTime pollInterval, int series);

PRBool PK11_NeedPWInit(void);
PRBool PK11_TokenExists(CK_MECHANISM_TYPE);
SECStatus PK11_GetModInfo(SECMODModule *mod, CK_INFO *info);
char *PK11_GetModuleURI(SECMODModule *mod);
PRBool PK11_IsFIPS(void);
SECMODModule *PK11_GetModule(PK11SlotInfo *slot);




PRBool PK11_IsPresent(PK11SlotInfo *slot);
PRBool PK11_DoesMechanism(PK11SlotInfo *slot, CK_MECHANISM_TYPE type);
PK11SlotList *PK11_GetAllTokens(CK_MECHANISM_TYPE type, PRBool needRW,
                                PRBool loadCerts, void *wincx);
PK11SlotInfo *PK11_GetBestSlotMultipleWithAttributes(CK_MECHANISM_TYPE *type,
                                                     CK_FLAGS *mechFlag, unsigned int *keySize,
                                                     unsigned int count, void *wincx);
PK11SlotInfo *PK11_GetBestSlotMultiple(CK_MECHANISM_TYPE *type,
                                       unsigned int count, void *wincx);
PK11SlotInfo *PK11_GetBestSlot(CK_MECHANISM_TYPE type, void *wincx);
PK11SlotInfo *PK11_GetBestSlotWithAttributes(CK_MECHANISM_TYPE type,
                                             CK_FLAGS mechFlag, unsigned int keySize, void *wincx);
CK_MECHANISM_TYPE PK11_GetBestWrapMechanism(PK11SlotInfo *slot);
int PK11_GetBestKeyLength(PK11SlotInfo *slot, CK_MECHANISM_TYPE type);
# 210 "/usr/include/nss3/pk11pub.h"
PK11SlotInfo *SECMOD_OpenUserDB(const char *moduleSpec);
SECStatus SECMOD_CloseUserDB(PK11SlotInfo *slot);







PK11SlotInfo *SECMOD_OpenNewSlot(SECMODModule *mod, const char *moduleSpec);




SECStatus PK11_MergeTokens(PK11SlotInfo *targetSlot, PK11SlotInfo *sourceSlot,
                           PK11MergeLog *log, void *targetPwArg, void *sourcePwArg);




PK11MergeLog *PK11_CreateMergeLog(void);
void PK11_DestroyMergeLog(PK11MergeLog *log);




CK_KEY_TYPE PK11_GetKeyType(CK_MECHANISM_TYPE type, unsigned long len);
CK_MECHANISM_TYPE PK11_GetKeyGen(CK_MECHANISM_TYPE type);
int PK11_GetBlockSize(CK_MECHANISM_TYPE type, SECItem *params);
int PK11_GetIVLength(CK_MECHANISM_TYPE type);
SECItem *PK11_ParamFromIV(CK_MECHANISM_TYPE type, SECItem *iv);
unsigned char *PK11_IVFromParam(CK_MECHANISM_TYPE type, SECItem *param, int *len);
SECItem *PK11_BlockData(SECItem *data, unsigned long size);


SECItem *PK11_ParamFromAlgid(SECAlgorithmID *algid);
SECItem *PK11_GenerateNewParam(CK_MECHANISM_TYPE, PK11SymKey *);
CK_MECHANISM_TYPE PK11_AlgtagToMechanism(SECOidTag algTag);
SECOidTag PK11_MechanismToAlgtag(CK_MECHANISM_TYPE type);
SECOidTag PK11_FortezzaMapSig(SECOidTag algTag);
SECStatus PK11_ParamToAlgid(SECOidTag algtag, SECItem *param,
                            PLArenaPool *arena, SECAlgorithmID *algid);
SECStatus PK11_SeedRandom(PK11SlotInfo *, unsigned char *data, int len);
SECStatus PK11_GenerateRandomOnSlot(PK11SlotInfo *, unsigned char *data, int len);
SECStatus PK11_RandomUpdate(void *data, size_t bytes);
SECStatus PK11_GenerateRandom(unsigned char *data, int len);



CK_RV PK11_MapPBEMechanismToCryptoMechanism(CK_MECHANISM_PTR pPBEMechanism,
                                            CK_MECHANISM_PTR pCryptoMechanism,
                                            SECItem *pbe_pwd, PRBool bad3DES);
CK_MECHANISM_TYPE PK11_GetPadMechanism(CK_MECHANISM_TYPE);
CK_MECHANISM_TYPE PK11_MapSignKeyType(KeyType keyType);




void PK11_FreeSymKey(PK11SymKey *key);
PK11SymKey *PK11_ReferenceSymKey(PK11SymKey *symKey);
PK11SymKey *PK11_ImportSymKey(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                              PK11Origin origin, CK_ATTRIBUTE_TYPE operation, SECItem *key, void *wincx);
PK11SymKey *PK11_ImportSymKeyWithFlags(PK11SlotInfo *slot,
                                       CK_MECHANISM_TYPE type, PK11Origin origin, CK_ATTRIBUTE_TYPE operation,
                                       SECItem *key, CK_FLAGS flags, PRBool isPerm, void *wincx);
PK11SymKey *PK11_SymKeyFromHandle(PK11SlotInfo *slot, PK11SymKey *parent,
                                  PK11Origin origin, CK_MECHANISM_TYPE type, CK_OBJECT_HANDLE keyID,
                                  PRBool owner, void *wincx);

PK11SymKey *PK11_GetWrapKey(PK11SlotInfo *slot, int wrap,
                            CK_MECHANISM_TYPE type, int series, void *wincx);
void PK11_SetWrapKey(PK11SlotInfo *slot, int wrap, PK11SymKey *wrapKey);
CK_MECHANISM_TYPE PK11_GetMechanism(PK11SymKey *symKey);
# 292 "/usr/include/nss3/pk11pub.h"
CK_OBJECT_HANDLE PK11_ImportPublicKey(PK11SlotInfo *slot,
                                      SECKEYPublicKey *pubKey, PRBool isToken);
PK11SymKey *PK11_KeyGen(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                        SECItem *param, int keySize, void *wincx);
PK11SymKey *PK11_TokenKeyGen(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                             SECItem *param, int keySize, SECItem *keyid,
                             PRBool isToken, void *wincx);
PK11SymKey *PK11_TokenKeyGenWithFlags(PK11SlotInfo *slot,
                                      CK_MECHANISM_TYPE type, SECItem *param,
                                      int keySize, SECItem *keyid, CK_FLAGS opFlags,
                                      PK11AttrFlags attrFlags, void *wincx);
# 312 "/usr/include/nss3/pk11pub.h"
PK11SymKey *PK11_KeyGenWithTemplate(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                                    CK_MECHANISM_TYPE keyGenType,
                                    SECItem *param, CK_ATTRIBUTE *attrs,
                                    unsigned int attrsCount, void *wincx);
PK11SymKey *PK11_ListFixedKeysInSlot(PK11SlotInfo *slot, char *nickname,
                                     void *wincx);
PK11SymKey *PK11_GetNextSymKey(PK11SymKey *symKey);
CK_KEY_TYPE PK11_GetSymKeyType(PK11SymKey *key);
CK_OBJECT_HANDLE PK11_GetSymKeyHandle(PK11SymKey *symKey);
# 341 "/usr/include/nss3/pk11pub.h"
void PK11_SetSymKeyUserData(PK11SymKey *symKey, void *data,
                            PK11FreeDataFunc freefunc);
# 353 "/usr/include/nss3/pk11pub.h"
void *PK11_GetSymKeyUserData(PK11SymKey *symKey);

SECStatus PK11_PubWrapSymKey(CK_MECHANISM_TYPE type, SECKEYPublicKey *pubKey,
                             PK11SymKey *symKey, SECItem *wrappedKey);
SECStatus PK11_WrapSymKey(CK_MECHANISM_TYPE type, SECItem *params,
                          PK11SymKey *wrappingKey, PK11SymKey *symKey, SECItem *wrappedKey);




PK11SymKey *PK11_MoveSymKey(PK11SlotInfo *slot, CK_ATTRIBUTE_TYPE operation,
                            CK_FLAGS flags, PRBool perm, PK11SymKey *symKey);
# 374 "/usr/include/nss3/pk11pub.h"
PK11SymKey *PK11_Derive(PK11SymKey *baseKey, CK_MECHANISM_TYPE mechanism,
                        SECItem *param, CK_MECHANISM_TYPE target,
                        CK_ATTRIBUTE_TYPE operation, int keySize);
PK11SymKey *PK11_DeriveWithFlags(PK11SymKey *baseKey,
                                 CK_MECHANISM_TYPE derive, SECItem *param, CK_MECHANISM_TYPE target,
                                 CK_ATTRIBUTE_TYPE operation, int keySize, CK_FLAGS flags);
PK11SymKey *PK11_DeriveWithFlagsPerm(PK11SymKey *baseKey,
                                     CK_MECHANISM_TYPE derive,
                                     SECItem *param, CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
                                     int keySize, CK_FLAGS flags, PRBool isPerm);
PK11SymKey *
PK11_DeriveWithTemplate(PK11SymKey *baseKey, CK_MECHANISM_TYPE derive,
                        SECItem *param, CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
                        int keySize, CK_ATTRIBUTE *userAttr, unsigned int numAttrs,
                        PRBool isPerm);

PK11SymKey *PK11_PubDerive(SECKEYPrivateKey *privKey,
                           SECKEYPublicKey *pubKey, PRBool isSender, SECItem *randomA, SECItem *randomB,
                           CK_MECHANISM_TYPE derive, CK_MECHANISM_TYPE target,
                           CK_ATTRIBUTE_TYPE operation, int keySize, void *wincx);
PK11SymKey *PK11_PubDeriveWithKDF(SECKEYPrivateKey *privKey,
                                  SECKEYPublicKey *pubKey, PRBool isSender, SECItem *randomA, SECItem *randomB,
                                  CK_MECHANISM_TYPE derive, CK_MECHANISM_TYPE target,
                                  CK_ATTRIBUTE_TYPE operation, int keySize,
                                  CK_ULONG kdf, SECItem *sharedData, void *wincx);
# 409 "/usr/include/nss3/pk11pub.h"
PK11SymKey *PK11_UnwrapSymKey(PK11SymKey *key,
                              CK_MECHANISM_TYPE wraptype, SECItem *param, SECItem *wrapppedKey,
                              CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize);
PK11SymKey *PK11_UnwrapSymKeyWithFlags(PK11SymKey *wrappingKey,
                                       CK_MECHANISM_TYPE wrapType, SECItem *param, SECItem *wrappedKey,
                                       CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize,
                                       CK_FLAGS flags);
PK11SymKey *PK11_UnwrapSymKeyWithFlagsPerm(PK11SymKey *wrappingKey,
                                           CK_MECHANISM_TYPE wrapType,
                                           SECItem *param, SECItem *wrappedKey,
                                           CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
                                           int keySize, CK_FLAGS flags, PRBool isPerm);
# 430 "/usr/include/nss3/pk11pub.h"
PK11SymKey *PK11_PubUnwrapSymKey(SECKEYPrivateKey *key, SECItem *wrapppedKey,
                                 CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize);
PK11SymKey *PK11_PubUnwrapSymKeyWithFlagsPerm(SECKEYPrivateKey *wrappingKey,
                                              SECItem *wrappedKey, CK_MECHANISM_TYPE target,
                                              CK_ATTRIBUTE_TYPE operation, int keySize,
                                              CK_FLAGS flags, PRBool isPerm);
PK11SymKey *PK11_FindFixedKey(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
                              SECItem *keyID, void *wincx);
SECStatus PK11_DeleteTokenPrivateKey(SECKEYPrivateKey *privKey, PRBool force);
SECStatus PK11_DeleteTokenPublicKey(SECKEYPublicKey *pubKey);
SECStatus PK11_DeleteTokenSymKey(PK11SymKey *symKey);
SECStatus PK11_DeleteTokenCertAndKey(CERTCertificate *cert, void *wincx);
SECKEYPrivateKey *PK11_LoadPrivKey(PK11SlotInfo *slot,
                                   SECKEYPrivateKey *privKey, SECKEYPublicKey *pubKey,
                                   PRBool token, PRBool sensitive);
char *PK11_GetSymKeyNickname(PK11SymKey *symKey);
char *PK11_GetPrivateKeyNickname(SECKEYPrivateKey *privKey);
char *PK11_GetPublicKeyNickname(SECKEYPublicKey *pubKey);
SECStatus PK11_SetSymKeyNickname(PK11SymKey *symKey, const char *nickname);
SECStatus PK11_SetPrivateKeyNickname(SECKEYPrivateKey *privKey,
                                     const char *nickname);
SECStatus PK11_SetPublicKeyNickname(SECKEYPublicKey *pubKey,
                                    const char *nickname);
# 466 "/usr/include/nss3/pk11pub.h"
SECStatus __PK11_SetCertificateNickname(CERTCertificate *cert,
                                        const char *nickname);


unsigned int PK11_GetKeyLength(PK11SymKey *key);



unsigned int PK11_GetKeyStrength(PK11SymKey *key, SECAlgorithmID *algid);
SECStatus PK11_ExtractKeyValue(PK11SymKey *symKey);
SECItem *PK11_GetKeyData(PK11SymKey *symKey);
PK11SlotInfo *PK11_GetSlotFromKey(PK11SymKey *symKey);
void *PK11_GetWindow(PK11SymKey *symKey);
# 495 "/usr/include/nss3/pk11pub.h"
SECKEYPrivateKey *PK11_GenerateKeyPairWithOpFlags(PK11SlotInfo *slot,
                                                  CK_MECHANISM_TYPE type, void *param, SECKEYPublicKey **pubk,
                                                  PK11AttrFlags attrFlags, CK_FLAGS opFlags, CK_FLAGS opFlagsMask,
                                                  void *wincx);






SECKEYPrivateKey *PK11_GenerateKeyPairWithFlags(PK11SlotInfo *slot,
                                                CK_MECHANISM_TYPE type, void *param, SECKEYPublicKey **pubk,
                                                PK11AttrFlags attrFlags, void *wincx);
SECKEYPrivateKey *PK11_GenerateKeyPair(PK11SlotInfo *slot,
                                       CK_MECHANISM_TYPE type, void *param, SECKEYPublicKey **pubk,
                                       PRBool isPerm, PRBool isSensitive, void *wincx);
SECKEYPrivateKey *PK11_FindPrivateKeyFromCert(PK11SlotInfo *slot,
                                              CERTCertificate *cert, void *wincx);
SECKEYPrivateKey *PK11_FindKeyByAnyCert(CERTCertificate *cert, void *wincx);
SECKEYPrivateKey *PK11_FindKeyByKeyID(PK11SlotInfo *slot, SECItem *keyID,
                                      void *wincx);
int PK11_GetPrivateModulusLen(SECKEYPrivateKey *key);

SECStatus PK11_Decrypt(PK11SymKey *symkey,
                       CK_MECHANISM_TYPE mechanism, SECItem *param,
                       unsigned char *out, unsigned int *outLen,
                       unsigned int maxLen,
                       const unsigned char *enc, unsigned int encLen);
SECStatus PK11_Encrypt(PK11SymKey *symKey,
                       CK_MECHANISM_TYPE mechanism, SECItem *param,
                       unsigned char *out, unsigned int *outLen,
                       unsigned int maxLen,
                       const unsigned char *data, unsigned int dataLen);


SECStatus PK11_PubDecryptRaw(SECKEYPrivateKey *key,
                             unsigned char *data, unsigned *outLen,
                             unsigned int maxLen,
                             const unsigned char *enc, unsigned encLen);


SECStatus PK11_PubEncryptRaw(SECKEYPublicKey *key,
                             unsigned char *enc,
                             const unsigned char *data, unsigned dataLen,
                             void *wincx);

SECStatus PK11_PrivDecryptPKCS1(SECKEYPrivateKey *key,
                                unsigned char *data, unsigned *outLen,
                                unsigned int maxLen,
                                const unsigned char *enc, unsigned encLen);

SECStatus PK11_PubEncryptPKCS1(SECKEYPublicKey *key,
                               unsigned char *enc,
                               const unsigned char *data, unsigned dataLen,
                               void *wincx);

SECStatus PK11_PrivDecrypt(SECKEYPrivateKey *key,
                           CK_MECHANISM_TYPE mechanism, SECItem *param,
                           unsigned char *out, unsigned int *outLen,
                           unsigned int maxLen,
                           const unsigned char *enc, unsigned int encLen);
SECStatus PK11_PubEncrypt(SECKEYPublicKey *key,
                          CK_MECHANISM_TYPE mechanism, SECItem *param,
                          unsigned char *out, unsigned int *outLen,
                          unsigned int maxLen,
                          const unsigned char *data, unsigned int dataLen,
                          void *wincx);

SECStatus PK11_ImportPrivateKeyInfo(PK11SlotInfo *slot,
                                    SECKEYPrivateKeyInfo *pki, SECItem *nickname,
                                    SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
                                    unsigned int usage, void *wincx);
SECStatus PK11_ImportPrivateKeyInfoAndReturnKey(PK11SlotInfo *slot,
                                                SECKEYPrivateKeyInfo *pki, SECItem *nickname,
                                                SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
                                                unsigned int usage, SECKEYPrivateKey **privk, void *wincx);
SECStatus PK11_ImportDERPrivateKeyInfo(PK11SlotInfo *slot,
                                       SECItem *derPKI, SECItem *nickname,
                                       SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
                                       unsigned int usage, void *wincx);
SECStatus PK11_ImportDERPrivateKeyInfoAndReturnKey(PK11SlotInfo *slot,
                                                   SECItem *derPKI, SECItem *nickname,
                                                   SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
                                                   unsigned int usage, SECKEYPrivateKey **privk, void *wincx);
SECStatus PK11_ImportEncryptedPrivateKeyInfo(PK11SlotInfo *slot,
                                             SECKEYEncryptedPrivateKeyInfo *epki, SECItem *pwitem,
                                             SECItem *nickname, SECItem *publicValue, PRBool isPerm,
                                             PRBool isPrivate, KeyType type,
                                             unsigned int usage, void *wincx);
SECStatus PK11_ImportEncryptedPrivateKeyInfoAndReturnKey(PK11SlotInfo *slot,
                                                         SECKEYEncryptedPrivateKeyInfo *epki, SECItem *pwitem,
                                                         SECItem *nickname, SECItem *publicValue, PRBool isPerm,
                                                         PRBool isPrivate, KeyType type,
                                                         unsigned int usage, SECKEYPrivateKey **privk, void *wincx);
SECItem *PK11_ExportDERPrivateKeyInfo(SECKEYPrivateKey *pk, void *wincx);
SECKEYPrivateKeyInfo *PK11_ExportPrivKeyInfo(
    SECKEYPrivateKey *pk, void *wincx);
SECKEYPrivateKeyInfo *PK11_ExportPrivateKeyInfo(
    CERTCertificate *cert, void *wincx);
SECKEYEncryptedPrivateKeyInfo *PK11_ExportEncryptedPrivKeyInfo(
    PK11SlotInfo *slot, SECOidTag algTag, SECItem *pwitem,
    SECKEYPrivateKey *pk, int iteration, void *wincx);
SECKEYEncryptedPrivateKeyInfo *PK11_ExportEncryptedPrivateKeyInfo(
    PK11SlotInfo *slot, SECOidTag algTag, SECItem *pwitem,
    CERTCertificate *cert, int iteration, void *wincx);
SECKEYPrivateKey *PK11_FindKeyByDERCert(PK11SlotInfo *slot,
                                        CERTCertificate *cert, void *wincx);
SECKEYPublicKey *PK11_MakeKEAPubKey(unsigned char *data, int length);
SECStatus PK11_DigestKey(PK11Context *context, PK11SymKey *key);
PRBool PK11_VerifyKeyOK(PK11SymKey *key);
SECKEYPrivateKey *PK11_UnwrapPrivKey(PK11SlotInfo *slot,
                                     PK11SymKey *wrappingKey, CK_MECHANISM_TYPE wrapType,
                                     SECItem *param, SECItem *wrappedKey, SECItem *label,
                                     SECItem *publicValue, PRBool token, PRBool sensitive,
                                     CK_KEY_TYPE keyType, CK_ATTRIBUTE_TYPE *usage, int usageCount,
                                     void *wincx);
SECStatus PK11_WrapPrivKey(PK11SlotInfo *slot, PK11SymKey *wrappingKey,
                           SECKEYPrivateKey *privKey, CK_MECHANISM_TYPE wrapType,
                           SECItem *param, SECItem *wrappedKey, void *wincx);




SECItem *PK11_DEREncodePublicKey(const SECKEYPublicKey *pubk);
PK11SymKey *PK11_CopySymKeyForSigning(PK11SymKey *originalKey,
                                      CK_MECHANISM_TYPE mech);
SECKEYPrivateKeyList *PK11_ListPrivKeysInSlot(PK11SlotInfo *slot,
                                              char *nickname, void *wincx);
SECKEYPublicKeyList *PK11_ListPublicKeysInSlot(PK11SlotInfo *slot,
                                               char *nickname);
SECKEYPQGParams *PK11_GetPQGParamsFromPrivateKey(SECKEYPrivateKey *privKey);

SECKEYPrivateKeyList *PK11_ListPrivateKeysInSlot(PK11SlotInfo *slot);

PK11SymKey *PK11_ConvertSessionSymKeyToTokenSymKey(PK11SymKey *symk,
                                                   void *wincx);
SECKEYPrivateKey *PK11_ConvertSessionPrivKeyToTokenPrivKey(
    SECKEYPrivateKey *privk, void *wincx);
SECKEYPrivateKey *PK11_CopyTokenPrivKeyToSessionPrivKey(PK11SlotInfo *destSlot,
                                                        SECKEYPrivateKey *privKey);




SECItem *PK11_MakeIDFromPubKey(SECItem *pubKeyData);
SECStatus PK11_TraverseSlotCerts(
    SECStatus (*callback)(CERTCertificate *, SECItem *, void *),
    void *arg, void *wincx);
CERTCertificate *PK11_FindCertFromNickname(const char *nickname, void *wincx);
CERTCertificate *PK11_FindCertFromURI(const char *uri, void *wincx);
CERTCertList *PK11_FindCertsFromURI(const char *uri, void *wincx);
CERTCertList *PK11_FindCertsFromEmailAddress(const char *email, void *wincx);
CERTCertList *PK11_FindCertsFromNickname(const char *nickname, void *wincx);
CERTCertificate *PK11_GetCertFromPrivateKey(SECKEYPrivateKey *privKey);
SECStatus PK11_ImportCert(PK11SlotInfo *slot, CERTCertificate *cert,
                          CK_OBJECT_HANDLE key, const char *nickname,
                          PRBool includeTrust);
SECStatus PK11_ImportDERCert(PK11SlotInfo *slot, SECItem *derCert,
                             CK_OBJECT_HANDLE key, char *nickname, PRBool includeTrust);
PK11SlotInfo *PK11_ImportCertForKey(CERTCertificate *cert,
                                    const char *nickname, void *wincx);
PK11SlotInfo *PK11_ImportDERCertForKey(SECItem *derCert, char *nickname,
                                       void *wincx);
PK11SlotInfo *PK11_KeyForCertExists(CERTCertificate *cert,
                                    CK_OBJECT_HANDLE *keyPtr, void *wincx);
PK11SlotInfo *PK11_KeyForDERCertExists(SECItem *derCert,
                                       CK_OBJECT_HANDLE *keyPtr, void *wincx);
CERTCertificate *PK11_FindCertByIssuerAndSN(PK11SlotInfo **slot,
                                            CERTIssuerAndSN *sn, void *wincx);
CERTCertificate *PK11_FindCertAndKeyByRecipientList(PK11SlotInfo **slot,
                                                    SEC_PKCS7RecipientInfo **array, SEC_PKCS7RecipientInfo **rip,
                                                    SECKEYPrivateKey **privKey, void *wincx);
int PK11_FindCertAndKeyByRecipientListNew(NSSCMSRecipient **recipientlist,
                                          void *wincx);
SECStatus PK11_TraverseCertsForSubjectInSlot(CERTCertificate *cert,
                                             PK11SlotInfo *slot, SECStatus (*callback)(CERTCertificate *, void *),
                                             void *arg);
CERTCertificate *PK11_FindCertFromDERCert(PK11SlotInfo *slot,
                                          CERTCertificate *cert, void *wincx);
CERTCertificate *PK11_FindCertFromDERCertItem(PK11SlotInfo *slot,
                                              const SECItem *derCert, void *wincx);
SECStatus PK11_ImportCertForKeyToSlot(PK11SlotInfo *slot, CERTCertificate *cert,
                                      char *nickname, PRBool addUsage,
                                      void *wincx);
CERTCertificate *PK11_FindBestKEAMatch(CERTCertificate *serverCert, void *wincx);
PRBool PK11_FortezzaHasKEA(CERTCertificate *cert);
CK_OBJECT_HANDLE PK11_FindCertInSlot(PK11SlotInfo *slot, CERTCertificate *cert,
                                     void *wincx);
SECStatus PK11_TraverseCertsForNicknameInSlot(SECItem *nickname,
                                              PK11SlotInfo *slot, SECStatus (*callback)(CERTCertificate *, void *),
                                              void *arg);
CERTCertList *PK11_ListCerts(PK11CertListType type, void *pwarg);
CERTCertList *PK11_ListCertsInSlot(PK11SlotInfo *slot);
CERTSignedCrl *PK11_ImportCRL(PK11SlotInfo *slot, SECItem *derCRL, char *url,
                              int type, void *wincx, PRInt32 importOptions, PLArenaPool *arena, PRInt32 decodeOptions);
CK_BBOOL PK11_HasAttributeSet(PK11SlotInfo *slot,
                              CK_OBJECT_HANDLE id,
                              CK_ATTRIBUTE_TYPE type,
                              PRBool haslock );
# 706 "/usr/include/nss3/pk11pub.h"
int PK11_SignatureLen(SECKEYPrivateKey *key);
PK11SlotInfo *PK11_GetSlotFromPrivateKey(SECKEYPrivateKey *key);
SECStatus PK11_Sign(SECKEYPrivateKey *key, SECItem *sig,
                    const SECItem *hash);
SECStatus PK11_SignWithMechanism(SECKEYPrivateKey *key,
                                 CK_MECHANISM_TYPE mechanism,
                                 const SECItem *param, SECItem *sig,
                                 const SECItem *hash);
SECStatus PK11_SignWithSymKey(PK11SymKey *symKey, CK_MECHANISM_TYPE mechanism,
                              SECItem *param, SECItem *sig, const SECItem *data);
SECStatus PK11_VerifyRecover(SECKEYPublicKey *key, const SECItem *sig,
                             SECItem *dsig, void *wincx);
SECStatus PK11_Verify(SECKEYPublicKey *key, const SECItem *sig,
                      const SECItem *hash, void *wincx);
SECStatus PK11_VerifyWithMechanism(SECKEYPublicKey *key,
                                   CK_MECHANISM_TYPE mechanism,
                                   const SECItem *param, const SECItem *sig,
                                   const SECItem *hash, void *wincx);




void PK11_DestroyContext(PK11Context *context, PRBool freeit);
PK11Context *PK11_CreateContextBySymKey(CK_MECHANISM_TYPE type,
                                        CK_ATTRIBUTE_TYPE operation, PK11SymKey *symKey, SECItem *param);
PK11Context *PK11_CreateDigestContext(SECOidTag hashAlg);
PK11Context *PK11_CloneContext(PK11Context *old);
SECStatus PK11_DigestBegin(PK11Context *cx);




SECStatus PK11_HashBuf(SECOidTag hashAlg, unsigned char *out,
                       const unsigned char *in, PRInt32 len);
SECStatus PK11_DigestOp(PK11Context *context, const unsigned char *in,
                        unsigned len);
SECStatus PK11_CipherOp(PK11Context *context, unsigned char *out, int *outlen,
                        int maxout, const unsigned char *in, int inlen);
SECStatus PK11_Finalize(PK11Context *context);
SECStatus PK11_DigestFinal(PK11Context *context, unsigned char *data,
                           unsigned int *outLen, unsigned int length);

SECStatus PK11_SaveContext(PK11Context *cx, unsigned char *save,
                           int *len, int saveLength);
# 760 "/usr/include/nss3/pk11pub.h"
unsigned char *
PK11_SaveContextAlloc(PK11Context *cx,
                      unsigned char *preAllocBuf, unsigned int pabLen,
                      unsigned int *stateLen);

SECStatus PK11_RestoreContext(PK11Context *cx, unsigned char *save, int len);
SECStatus PK11_GenerateFortezzaIV(PK11SymKey *symKey, unsigned char *iv, int len);
void PK11_SetFortezzaHack(PK11SymKey *symKey);
# 777 "/usr/include/nss3/pk11pub.h"
SECItem *
PK11_CreatePBEParams(SECItem *salt, SECItem *pwd, unsigned int iterations);


void PK11_DestroyPBEParams(SECItem *params);

SECAlgorithmID *
PK11_CreatePBEAlgorithmID(SECOidTag algorithm, int iteration, SECItem *salt);



SECAlgorithmID *
PK11_CreatePBEV2AlgorithmID(SECOidTag pbeAlgTag, SECOidTag cipherAlgTag,
                            SECOidTag prfAlgTag, int keyLength, int iteration,
                            SECItem *salt);
PK11SymKey *
PK11_PBEKeyGen(PK11SlotInfo *slot, SECAlgorithmID *algid, SECItem *pwitem,
               PRBool faulty3DES, void *wincx);


PK11SymKey *
PK11_RawPBEKeyGen(PK11SlotInfo *slot, CK_MECHANISM_TYPE type, SECItem *params,
                  SECItem *pwitem, PRBool faulty3DES, void *wincx);
SECItem *
PK11_GetPBEIV(SECAlgorithmID *algid, SECItem *pwitem);





CK_MECHANISM_TYPE
PK11_GetPBECryptoMechanism(SECAlgorithmID *algid,
                           SECItem **param, SECItem *pwd);




const PK11DefaultArrayEntry *PK11_GetDefaultArray(int *size);
SECStatus PK11_UpdateSlotAttribute(PK11SlotInfo *slot,
                                   const PK11DefaultArrayEntry *entry,
                                   PRBool add);




PK11GenericObject *PK11_FindGenericObjects(PK11SlotInfo *slot,
                                           CK_OBJECT_CLASS objClass);
PK11GenericObject *PK11_GetNextGenericObject(PK11GenericObject *object);
PK11GenericObject *PK11_GetPrevGenericObject(PK11GenericObject *object);
SECStatus PK11_UnlinkGenericObject(PK11GenericObject *object);
SECStatus PK11_LinkGenericObject(PK11GenericObject *list,
                                 PK11GenericObject *object);
SECStatus PK11_DestroyGenericObjects(PK11GenericObject *object);
SECStatus PK11_DestroyGenericObject(PK11GenericObject *object);
PK11GenericObject *PK11_CreateManagedGenericObject(PK11SlotInfo *slot,
                                                   const CK_ATTRIBUTE *pTemplate,
                                                   int count, PRBool token);

PK11GenericObject *PK11_CreateGenericObject(PK11SlotInfo *slot,
                                            const CK_ATTRIBUTE *pTemplate,
                                            int count, PRBool token);
# 862 "/usr/include/nss3/pk11pub.h"
SECStatus PK11_ReadRawAttribute(PK11ObjectType type, void *object,
                                CK_ATTRIBUTE_TYPE attr, SECItem *item);
SECStatus PK11_WriteRawAttribute(PK11ObjectType type, void *object,
                                 CK_ATTRIBUTE_TYPE attr, SECItem *item);






PK11SlotList *
PK11_GetAllSlotsForCert(CERTCertificate *cert, void *arg);
# 882 "/usr/include/nss3/pk11pub.h"
SECStatus
PK11_FindRawCertsWithSubject(PK11SlotInfo *slot, SECItem *derSubject,
                             CERTCertificateList **results);






CERTCertList *
PK11_GetCertsMatchingPrivateKey(SECKEYPrivateKey *privKey);




SECItem *
PK11_GetLowLevelKeyIDForCert(PK11SlotInfo *slot,
                             CERTCertificate *cert, void *pwarg);
SECItem *
PK11_GetLowLevelKeyIDForPrivateKey(SECKEYPrivateKey *key);

PRBool SECMOD_HasRootCerts(void);

}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 2
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h"
# 1 "/usr/include/openssl/evp.h" 1 3 4
# 13 "/usr/include/openssl/evp.h" 3 4
# 1 "/usr/include/openssl/opensslconf.h" 1 3 4
# 42 "/usr/include/openssl/opensslconf.h" 3 4
# 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
# 20 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
# 1 "/usr/include/openssl/opensslv.h" 1 3 4
# 14 "/usr/include/openssl/opensslv.h" 3 4

# 14 "/usr/include/openssl/opensslv.h" 3 4
extern "C" {
# 99 "/usr/include/openssl/opensslv.h" 3 4
}
# 21 "/usr/include/openssl/opensslconf-x86_64.h" 2 3 4


extern "C" {
# 197 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
}
# 43 "/usr/include/openssl/opensslconf.h" 2 3 4
# 14 "/usr/include/openssl/evp.h" 2 3 4
# 1 "/usr/include/openssl/ossl_typ.h" 1 3 4
# 13 "/usr/include/openssl/ossl_typ.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 14 "/usr/include/openssl/ossl_typ.h" 2 3 4


extern "C" {


# 1 "/usr/include/openssl/e_os2.h" 1 3 4
# 13 "/usr/include/openssl/e_os2.h" 3 4
# 1 "/usr/include/openssl/opensslconf.h" 1 3 4
# 42 "/usr/include/openssl/opensslconf.h" 3 4
# 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
# 23 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
extern "C" {
# 197 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
}
# 43 "/usr/include/openssl/opensslconf.h" 2 3 4
# 14 "/usr/include/openssl/e_os2.h" 2 3 4


extern "C" {
# 298 "/usr/include/openssl/e_os2.h" 3 4
}
# 20 "/usr/include/openssl/ossl_typ.h" 2 3 4
# 40 "/usr/include/openssl/ossl_typ.h" 3 4
typedef struct asn1_string_st ASN1_INTEGER;
typedef struct asn1_string_st ASN1_ENUMERATED;
typedef struct asn1_string_st ASN1_BIT_STRING;
typedef struct asn1_string_st ASN1_OCTET_STRING;
typedef struct asn1_string_st ASN1_PRINTABLESTRING;
typedef struct asn1_string_st ASN1_T61STRING;
typedef struct asn1_string_st ASN1_IA5STRING;
typedef struct asn1_string_st ASN1_GENERALSTRING;
typedef struct asn1_string_st ASN1_UNIVERSALSTRING;
typedef struct asn1_string_st ASN1_BMPSTRING;
typedef struct asn1_string_st ASN1_UTCTIME;
typedef struct asn1_string_st ASN1_TIME;
typedef struct asn1_string_st ASN1_GENERALIZEDTIME;
typedef struct asn1_string_st ASN1_VISIBLESTRING;
typedef struct asn1_string_st ASN1_UTF8STRING;
typedef struct asn1_string_st ASN1_STRING;
typedef int ASN1_BOOLEAN;
typedef int ASN1_NULL;


typedef struct asn1_object_st ASN1_OBJECT;

typedef struct ASN1_ITEM_st ASN1_ITEM;
typedef struct asn1_pctx_st ASN1_PCTX;
typedef struct asn1_sctx_st ASN1_SCTX;
# 78 "/usr/include/openssl/ossl_typ.h" 3 4
struct dane_st;
typedef struct bio_st BIO;
typedef struct bignum_st BIGNUM;
typedef struct bignum_ctx BN_CTX;
typedef struct bn_blinding_st BN_BLINDING;
typedef struct bn_mont_ctx_st BN_MONT_CTX;
typedef struct bn_recp_ctx_st BN_RECP_CTX;
typedef struct bn_gencb_st BN_GENCB;

typedef struct buf_mem_st BUF_MEM;

typedef struct evp_cipher_st EVP_CIPHER;
typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
typedef struct evp_md_st EVP_MD;
typedef struct evp_md_ctx_st EVP_MD_CTX;
typedef struct evp_pkey_st EVP_PKEY;

typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;

typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;

typedef struct evp_kdf_ctx_st EVP_KDF_CTX;

typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX;

typedef struct hmac_ctx_st HMAC_CTX;

typedef struct dh_st DH;
typedef struct dh_method DH_METHOD;

typedef struct dsa_st DSA;
typedef struct dsa_method DSA_METHOD;

typedef struct rsa_st RSA;
typedef struct rsa_meth_st RSA_METHOD;

typedef struct ec_key_st EC_KEY;
typedef struct ec_key_method_st EC_KEY_METHOD;

typedef struct rand_meth_st RAND_METHOD;
typedef struct rand_drbg_st RAND_DRBG;

typedef struct ssl_dane_st SSL_DANE;
typedef struct x509_st X509;
typedef struct X509_algor_st X509_ALGOR;
typedef struct X509_crl_st X509_CRL;
typedef struct x509_crl_method_st X509_CRL_METHOD;
typedef struct x509_revoked_st X509_REVOKED;
typedef struct X509_name_st X509_NAME;
typedef struct X509_pubkey_st X509_PUBKEY;
typedef struct x509_store_st X509_STORE;
typedef struct x509_store_ctx_st X509_STORE_CTX;

typedef struct x509_object_st X509_OBJECT;
typedef struct x509_lookup_st X509_LOOKUP;
typedef struct x509_lookup_method_st X509_LOOKUP_METHOD;
typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;

typedef struct x509_sig_info_st X509_SIG_INFO;

typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;

typedef struct v3_ext_ctx X509V3_CTX;
typedef struct conf_st CONF;
typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;

typedef struct ui_st UI;
typedef struct ui_method_st UI_METHOD;

typedef struct engine_st ENGINE;
typedef struct ssl_st SSL;
typedef struct ssl_ctx_st SSL_CTX;

typedef struct comp_ctx_st COMP_CTX;
typedef struct comp_method_st COMP_METHOD;

typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;

typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
typedef struct DIST_POINT_st DIST_POINT;
typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;

typedef struct crypto_ex_data_st CRYPTO_EX_DATA;

typedef struct ocsp_req_ctx_st OCSP_REQ_CTX;
typedef struct ocsp_response_st OCSP_RESPONSE;
typedef struct ocsp_responder_id_st OCSP_RESPID;

typedef struct sct_st SCT;
typedef struct sct_ctx_st SCT_CTX;
typedef struct ctlog_st CTLOG;
typedef struct ctlog_store_st CTLOG_STORE;
typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX;

typedef struct ossl_store_info_st OSSL_STORE_INFO;
typedef struct ossl_store_search_st OSSL_STORE_SEARCH;
# 191 "/usr/include/openssl/ossl_typ.h" 3 4
typedef long ossl_intmax_t;
typedef unsigned long ossl_uintmax_t;



}
# 15 "/usr/include/openssl/evp.h" 2 3 4
# 1 "/usr/include/openssl/symhacks.h" 1 3 4
# 16 "/usr/include/openssl/evp.h" 2 3 4
# 1 "/usr/include/openssl/bio.h" 1 3 4
# 20 "/usr/include/openssl/bio.h" 3 4
# 1 "/usr/include/openssl/crypto.h" 1 3 4
# 14 "/usr/include/openssl/crypto.h" 3 4
# 1 "/usr/include/c++/10/stdlib.h" 1 3 4
# 15 "/usr/include/openssl/crypto.h" 2 3 4
# 23 "/usr/include/openssl/crypto.h" 3 4
# 1 "/usr/include/openssl/safestack.h" 1 3 4
# 13 "/usr/include/openssl/safestack.h" 3 4
# 1 "/usr/include/openssl/stack.h" 1 3 4
# 14 "/usr/include/openssl/stack.h" 3 4
extern "C" {


typedef struct stack_st OPENSSL_STACK;

typedef int (*OPENSSL_sk_compfunc)(const void *, const void *);
typedef void (*OPENSSL_sk_freefunc)(void *);
typedef void *(*OPENSSL_sk_copyfunc)(const void *);

int OPENSSL_sk_num(const OPENSSL_STACK *);
void *OPENSSL_sk_value(const OPENSSL_STACK *, int);

void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data);

OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
OPENSSL_STACK *OPENSSL_sk_new_null(void);
OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n);
int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n);
void OPENSSL_sk_free(OPENSSL_STACK *);
void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *));
OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *,
                                    OPENSSL_sk_copyfunc c,
                                    OPENSSL_sk_freefunc f);
int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where);
void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc);
void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p);
int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data);
int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data);
int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data);
int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data);
void *OPENSSL_sk_shift(OPENSSL_STACK *st);
void *OPENSSL_sk_pop(OPENSSL_STACK *st);
void OPENSSL_sk_zero(OPENSSL_STACK *st);
OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
                                            OPENSSL_sk_compfunc cmp);
OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st);
void OPENSSL_sk_sort(OPENSSL_STACK *st);
int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st);
# 80 "/usr/include/openssl/stack.h" 3 4
}
# 14 "/usr/include/openssl/safestack.h" 2 3 4



extern "C" {
# 149 "/usr/include/openssl/safestack.h" 3 4
typedef char *OPENSSL_STRING;
typedef const char *OPENSSL_CSTRING;
# 159 "/usr/include/openssl/safestack.h" 3 4
struct stack_st_OPENSSL_STRING; typedef int (*sk_OPENSSL_STRING_compfunc)(const char * const *a, const char *const *b); typedef void (*sk_OPENSSL_STRING_freefunc)(char *a); typedef char * (*sk_OPENSSL_STRING_copyfunc)(const char *a); static __attribute__((unused)) inline int sk_OPENSSL_STRING_num(const struct stack_st_OPENSSL_STRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline char *sk_OPENSSL_STRING_value(const struct stack_st_OPENSSL_STRING *sk, int idx) { return (char *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_new(sk_OPENSSL_STRING_compfunc compare) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_new_null(void) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_new_reserve(sk_OPENSSL_STRING_compfunc compare, int n) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_OPENSSL_STRING_reserve(struct stack_st_OPENSSL_STRING *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_OPENSSL_STRING_free(struct stack_st_OPENSSL_STRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_OPENSSL_STRING_zero(struct stack_st_OPENSSL_STRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline char *sk_OPENSSL_STRING_delete(struct stack_st_OPENSSL_STRING *sk, int i) { return (char *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline char *sk_OPENSSL_STRING_delete_ptr(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return (char *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_STRING_push(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_STRING_unshift(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline char *sk_OPENSSL_STRING_pop(struct stack_st_OPENSSL_STRING *sk) { return (char *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline char *sk_OPENSSL_STRING_shift(struct stack_st_OPENSSL_STRING *sk) { return (char *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_OPENSSL_STRING_pop_free(struct stack_st_OPENSSL_STRING *sk, sk_OPENSSL_STRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_OPENSSL_STRING_insert(struct stack_st_OPENSSL_STRING *sk, char *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline char *sk_OPENSSL_STRING_set(struct stack_st_OPENSSL_STRING *sk, int idx, char *ptr) { return (char *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_STRING_find(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_STRING_find_ex(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_OPENSSL_STRING_sort(struct stack_st_OPENSSL_STRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_OPENSSL_STRING_is_sorted(const struct stack_st_OPENSSL_STRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_OPENSSL_STRING * sk_OPENSSL_STRING_dup(const struct stack_st_OPENSSL_STRING *sk) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_deep_copy(const struct stack_st_OPENSSL_STRING *sk, sk_OPENSSL_STRING_copyfunc copyfunc, sk_OPENSSL_STRING_freefunc freefunc) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_OPENSSL_STRING_compfunc sk_OPENSSL_STRING_set_cmp_func(struct stack_st_OPENSSL_STRING *sk, sk_OPENSSL_STRING_compfunc compare) { return (sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
struct stack_st_OPENSSL_CSTRING; typedef int (*sk_OPENSSL_CSTRING_compfunc)(const char * const *a, const char *const *b); typedef void (*sk_OPENSSL_CSTRING_freefunc)(char *a); typedef char * (*sk_OPENSSL_CSTRING_copyfunc)(const char *a); static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_num(const struct stack_st_OPENSSL_CSTRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline const char *sk_OPENSSL_CSTRING_value(const struct stack_st_OPENSSL_CSTRING *sk, int idx) { return (const char *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_OPENSSL_CSTRING *sk_OPENSSL_CSTRING_new(sk_OPENSSL_CSTRING_compfunc compare) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_OPENSSL_CSTRING *sk_OPENSSL_CSTRING_new_null(void) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_OPENSSL_CSTRING *sk_OPENSSL_CSTRING_new_reserve(sk_OPENSSL_CSTRING_compfunc compare, int n) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_reserve(struct stack_st_OPENSSL_CSTRING *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_OPENSSL_CSTRING_free(struct stack_st_OPENSSL_CSTRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_OPENSSL_CSTRING_zero(struct stack_st_OPENSSL_CSTRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline const char *sk_OPENSSL_CSTRING_delete(struct stack_st_OPENSSL_CSTRING *sk, int i) { return (const char *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline const char *sk_OPENSSL_CSTRING_delete_ptr(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return (const char *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_push(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_unshift(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline const char *sk_OPENSSL_CSTRING_pop(struct stack_st_OPENSSL_CSTRING *sk) { return (const char *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline const char *sk_OPENSSL_CSTRING_shift(struct stack_st_OPENSSL_CSTRING *sk) { return (const char *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_OPENSSL_CSTRING_pop_free(struct stack_st_OPENSSL_CSTRING *sk, sk_OPENSSL_CSTRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_insert(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline const char *sk_OPENSSL_CSTRING_set(struct stack_st_OPENSSL_CSTRING *sk, int idx, const char *ptr) { return (const char *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_find(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_find_ex(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_OPENSSL_CSTRING_sort(struct stack_st_OPENSSL_CSTRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_OPENSSL_CSTRING_is_sorted(const struct stack_st_OPENSSL_CSTRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_OPENSSL_CSTRING * sk_OPENSSL_CSTRING_dup(const struct stack_st_OPENSSL_CSTRING *sk) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_OPENSSL_CSTRING *sk_OPENSSL_CSTRING_deep_copy(const struct stack_st_OPENSSL_CSTRING *sk, sk_OPENSSL_CSTRING_copyfunc copyfunc, sk_OPENSSL_CSTRING_freefunc freefunc) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_OPENSSL_CSTRING_compfunc sk_OPENSSL_CSTRING_set_cmp_func(struct stack_st_OPENSSL_CSTRING *sk, sk_OPENSSL_CSTRING_compfunc compare) { return (sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }





typedef void *OPENSSL_BLOCK;
struct stack_st_OPENSSL_BLOCK; typedef int (*sk_OPENSSL_BLOCK_compfunc)(const void * const *a, const void *const *b); typedef void (*sk_OPENSSL_BLOCK_freefunc)(void *a); typedef void * (*sk_OPENSSL_BLOCK_copyfunc)(const void *a); static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_num(const struct stack_st_OPENSSL_BLOCK *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void *sk_OPENSSL_BLOCK_value(const struct stack_st_OPENSSL_BLOCK *sk, int idx) { return (void *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_OPENSSL_BLOCK *sk_OPENSSL_BLOCK_new(sk_OPENSSL_BLOCK_compfunc compare) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_OPENSSL_BLOCK *sk_OPENSSL_BLOCK_new_null(void) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_OPENSSL_BLOCK *sk_OPENSSL_BLOCK_new_reserve(sk_OPENSSL_BLOCK_compfunc compare, int n) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_reserve(struct stack_st_OPENSSL_BLOCK *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_OPENSSL_BLOCK_free(struct stack_st_OPENSSL_BLOCK *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_OPENSSL_BLOCK_zero(struct stack_st_OPENSSL_BLOCK *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void *sk_OPENSSL_BLOCK_delete(struct stack_st_OPENSSL_BLOCK *sk, int i) { return (void *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline void *sk_OPENSSL_BLOCK_delete_ptr(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return (void *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_push(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_unshift(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void *sk_OPENSSL_BLOCK_pop(struct stack_st_OPENSSL_BLOCK *sk) { return (void *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void *sk_OPENSSL_BLOCK_shift(struct stack_st_OPENSSL_BLOCK *sk) { return (void *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_OPENSSL_BLOCK_pop_free(struct stack_st_OPENSSL_BLOCK *sk, sk_OPENSSL_BLOCK_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_insert(struct stack_st_OPENSSL_BLOCK *sk, void *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline void *sk_OPENSSL_BLOCK_set(struct stack_st_OPENSSL_BLOCK *sk, int idx, void *ptr) { return (void *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_find(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_find_ex(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_OPENSSL_BLOCK_sort(struct stack_st_OPENSSL_BLOCK *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_OPENSSL_BLOCK_is_sorted(const struct stack_st_OPENSSL_BLOCK *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_OPENSSL_BLOCK * sk_OPENSSL_BLOCK_dup(const struct stack_st_OPENSSL_BLOCK *sk) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_OPENSSL_BLOCK *sk_OPENSSL_BLOCK_deep_copy(const struct stack_st_OPENSSL_BLOCK *sk, sk_OPENSSL_BLOCK_copyfunc copyfunc, sk_OPENSSL_BLOCK_freefunc freefunc) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_OPENSSL_BLOCK_compfunc sk_OPENSSL_BLOCK_set_cmp_func(struct stack_st_OPENSSL_BLOCK *sk, sk_OPENSSL_BLOCK_compfunc compare) { return (sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
# 205 "/usr/include/openssl/safestack.h" 3 4
}
# 24 "/usr/include/openssl/crypto.h" 2 3 4


# 1 "/usr/include/openssl/opensslconf.h" 1 3 4
# 42 "/usr/include/openssl/opensslconf.h" 3 4
# 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
# 23 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
extern "C" {
# 197 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
}
# 43 "/usr/include/openssl/opensslconf.h" 2 3 4
# 27 "/usr/include/openssl/crypto.h" 2 3 4
# 1 "/usr/include/openssl/cryptoerr.h" 1 3 4
# 19 "/usr/include/openssl/cryptoerr.h" 3 4
extern "C"

int ERR_load_CRYPTO_strings(void);
# 28 "/usr/include/openssl/crypto.h" 2 3 4
# 44 "/usr/include/openssl/crypto.h" 3 4
extern "C" {
# 61 "/usr/include/openssl/crypto.h" 3 4
typedef struct {
    int dummy;
} CRYPTO_dynlock;



typedef void CRYPTO_RWLOCK;

CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);

int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
# 86 "/usr/include/openssl/crypto.h" 3 4
struct crypto_ex_data_st {
    struct stack_st_void *sk;
};
struct stack_st_void; typedef int (*sk_void_compfunc)(const void * const *a, const void *const *b); typedef void (*sk_void_freefunc)(void *a); typedef void * (*sk_void_copyfunc)(const void *a); static __attribute__((unused)) inline int sk_void_num(const struct stack_st_void *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void *sk_void_value(const struct stack_st_void *sk, int idx) { return (void *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_void *sk_void_new(sk_void_compfunc compare) { return (struct stack_st_void *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_void *sk_void_new_null(void) { return (struct stack_st_void *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_void *sk_void_new_reserve(sk_void_compfunc compare, int n) { return (struct stack_st_void *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_void_reserve(struct stack_st_void *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_void_free(struct stack_st_void *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_void_zero(struct stack_st_void *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void *sk_void_delete(struct stack_st_void *sk, int i) { return (void *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline void *sk_void_delete_ptr(struct stack_st_void *sk, void *ptr) { return (void *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_void_push(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_void_unshift(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void *sk_void_pop(struct stack_st_void *sk) { return (void *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void *sk_void_shift(struct stack_st_void *sk) { return (void *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_void_pop_free(struct stack_st_void *sk, sk_void_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_void_insert(struct stack_st_void *sk, void *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline void *sk_void_set(struct stack_st_void *sk, int idx, void *ptr) { return (void *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_void_find(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_void_find_ex(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_void_sort(struct stack_st_void *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_void_is_sorted(const struct stack_st_void *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_void * sk_void_dup(const struct stack_st_void *sk) { return (struct stack_st_void *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_void *sk_void_deep_copy(const struct stack_st_void *sk, sk_void_copyfunc copyfunc, sk_void_freefunc freefunc) { return (struct stack_st_void *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_void_compfunc sk_void_set_cmp_func(struct stack_st_void *sk, sk_void_compfunc compare) { return (sk_void_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
# 115 "/usr/include/openssl/crypto.h" 3 4
int CRYPTO_mem_ctrl(int mode);
# 146 "/usr/include/openssl/crypto.h" 3 4
size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz);
size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz);
size_t OPENSSL_strnlen(const char *str, size_t maxlen);
char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len);
unsigned char *OPENSSL_hexstr2buf(const char *str, long *len);
int OPENSSL_hexchar2int(unsigned char c);



unsigned long OpenSSL_version_num(void);
const char *OpenSSL_version(int type);







int OPENSSL_issetugid(void);

typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
                           int idx, long argl, void *argp);
typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
                             int idx, long argl, void *argp);
typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
                           void *from_d, int idx, long argl, void *argp);
 int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
                            CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
                            CRYPTO_EX_free *free_func);

int CRYPTO_free_ex_index(int class_index, int idx);





int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
                       const CRYPTO_EX_DATA *from);

void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);





int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
# 229 "/usr/include/openssl/crypto.h" 3 4
typedef struct crypto_threadid_st {
    int dummy;
} CRYPTO_THREADID;
# 256 "/usr/include/openssl/crypto.h" 3 4
int CRYPTO_set_mem_functions(
        void *(*m) (size_t, const char *, int),
        void *(*r) (void *, size_t, const char *, int),
        void (*f) (void *, const char *, int));
int CRYPTO_set_mem_debug(int flag);
void CRYPTO_get_mem_functions(
        void *(**m) (size_t, const char *, int),
        void *(**r) (void *, size_t, const char *, int),
        void (**f) (void *, const char *, int));

void *CRYPTO_malloc(size_t num, const char *file, int line);
void *CRYPTO_zalloc(size_t num, const char *file, int line);
void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line);
char *CRYPTO_strdup(const char *str, const char *file, int line);
char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line);
void CRYPTO_free(void *ptr, const char *file, int line);
void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line);
void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line);
void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
                           const char *file, int line);

int CRYPTO_secure_malloc_init(size_t sz, int minsize);
int CRYPTO_secure_malloc_done(void);
void *CRYPTO_secure_malloc(size_t num, const char *file, int line);
void *CRYPTO_secure_zalloc(size_t num, const char *file, int line);
void CRYPTO_secure_free(void *ptr, const char *file, int line);
void CRYPTO_secure_clear_free(void *ptr, size_t num,
                              const char *file, int line);
int CRYPTO_secure_allocated(const void *ptr);
int CRYPTO_secure_malloc_initialized(void);
size_t CRYPTO_secure_actual_size(void *ptr);
size_t CRYPTO_secure_used(void);

void OPENSSL_cleanse(void *ptr, size_t len);
# 322 "/usr/include/openssl/crypto.h" 3 4
__attribute__((noreturn)) void OPENSSL_die(const char *assertion, const char *file, int line);






int OPENSSL_isservice(void);

int FIPS_mode(void);
int FIPS_mode_set(int r);



void FIPS_selftest_check(void);


void OPENSSL_init(void);

void OPENSSL_fork_prepare(void);
void OPENSSL_fork_parent(void);
void OPENSSL_fork_child(void);


struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result);
int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec);
int OPENSSL_gmtime_diff(int *pday, int *psec,
                        const struct tm *from, const struct tm *to);
# 358 "/usr/include/openssl/crypto.h" 3 4
int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len);
# 392 "/usr/include/openssl/crypto.h" 3 4
void OPENSSL_cleanup(void);
int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
int OPENSSL_atexit(void (*handler)(void));
void OPENSSL_thread_stop(void);


OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void);

int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings,
                                     const char *config_filename);
void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings,
                                        unsigned long flags);
int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
                                    const char *config_appname);

void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings);
# 421 "/usr/include/openssl/crypto.h" 3 4
typedef pthread_once_t CRYPTO_ONCE;
typedef pthread_key_t CRYPTO_THREAD_LOCAL;
typedef pthread_t CRYPTO_THREAD_ID;
# 436 "/usr/include/openssl/crypto.h" 3 4
int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void));

int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *));
void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key);
int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val);
int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key);

CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);



}
# 21 "/usr/include/openssl/bio.h" 2 3 4
# 1 "/usr/include/openssl/bioerr.h" 1 3 4
# 19 "/usr/include/openssl/bioerr.h" 3 4
extern "C"

int ERR_load_BIO_strings(void);
# 22 "/usr/include/openssl/bio.h" 2 3 4


extern "C" {
# 173 "/usr/include/openssl/bio.h" 3 4
typedef union bio_addr_st BIO_ADDR;
typedef struct bio_addrinfo_st BIO_ADDRINFO;

int BIO_get_new_index(void);
void BIO_set_flags(BIO *b, int flags);
int BIO_test_flags(const BIO *b, int flags);
void BIO_clear_flags(BIO *b, int flags);
# 235 "/usr/include/openssl/bio.h" 3 4
typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi,
                                long argl, long ret);
typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp,
                                   size_t len, int argi,
                                   long argl, int ret, size_t *processed);
BIO_callback_fn BIO_get_callback(const BIO *b);
void BIO_set_callback(BIO *b, BIO_callback_fn callback);

BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b);
void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback);

char *BIO_get_callback_arg(const BIO *b);
void BIO_set_callback_arg(BIO *b, char *arg);

typedef struct bio_method_st BIO_METHOD;

const char *BIO_method_name(const BIO *b);
int BIO_method_type(const BIO *b);

typedef int BIO_info_cb(BIO *, int, int);
typedef BIO_info_cb bio_info_cb;

struct stack_st_BIO; typedef int (*sk_BIO_compfunc)(const BIO * const *a, const BIO *const *b); typedef void (*sk_BIO_freefunc)(BIO *a); typedef BIO * (*sk_BIO_copyfunc)(const BIO *a); static __attribute__((unused)) inline int sk_BIO_num(const struct stack_st_BIO *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline BIO *sk_BIO_value(const struct stack_st_BIO *sk, int idx) { return (BIO *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_BIO *sk_BIO_new(sk_BIO_compfunc compare) { return (struct stack_st_BIO *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_BIO *sk_BIO_new_null(void) { return (struct stack_st_BIO *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_BIO *sk_BIO_new_reserve(sk_BIO_compfunc compare, int n) { return (struct stack_st_BIO *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_BIO_reserve(struct stack_st_BIO *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_BIO_free(struct stack_st_BIO *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_BIO_zero(struct stack_st_BIO *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline BIO *sk_BIO_delete(struct stack_st_BIO *sk, int i) { return (BIO *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline BIO *sk_BIO_delete_ptr(struct stack_st_BIO *sk, BIO *ptr) { return (BIO *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_BIO_push(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_BIO_unshift(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline BIO *sk_BIO_pop(struct stack_st_BIO *sk) { return (BIO *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline BIO *sk_BIO_shift(struct stack_st_BIO *sk) { return (BIO *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_BIO_pop_free(struct stack_st_BIO *sk, sk_BIO_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_BIO_insert(struct stack_st_BIO *sk, BIO *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline BIO *sk_BIO_set(struct stack_st_BIO *sk, int idx, BIO *ptr) { return (BIO *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_BIO_find(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_BIO_find_ex(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_BIO_sort(struct stack_st_BIO *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_BIO_is_sorted(const struct stack_st_BIO *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_BIO * sk_BIO_dup(const struct stack_st_BIO *sk) { return (struct stack_st_BIO *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_BIO *sk_BIO_deep_copy(const struct stack_st_BIO *sk, sk_BIO_copyfunc copyfunc, sk_BIO_freefunc freefunc) { return (struct stack_st_BIO *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_BIO_compfunc sk_BIO_set_cmp_func(struct stack_st_BIO *sk, sk_BIO_compfunc compare) { return (sk_BIO_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }


typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen,
                          void *parg);



struct bio_dgram_sctp_sndinfo {
    uint16_t snd_sid;
    uint16_t snd_flags;
    uint32_t snd_ppid;
    uint32_t snd_context;
};

struct bio_dgram_sctp_rcvinfo {
    uint16_t rcv_sid;
    uint16_t rcv_ssn;
    uint16_t rcv_flags;
    uint32_t rcv_ppid;
    uint32_t rcv_tsn;
    uint32_t rcv_cumtsn;
    uint32_t rcv_context;
};

struct bio_dgram_sctp_prinfo {
    uint16_t pr_policy;
    uint32_t pr_value;
};
# 486 "/usr/include/openssl/bio.h" 3 4
size_t BIO_ctrl_pending(BIO *b);
size_t BIO_ctrl_wpending(BIO *b);
# 506 "/usr/include/openssl/bio.h" 3 4
size_t BIO_ctrl_get_write_guarantee(BIO *b);
size_t BIO_ctrl_get_read_request(BIO *b);
int BIO_ctrl_reset_read_request(BIO *b);
# 528 "/usr/include/openssl/bio.h" 3 4
int BIO_set_ex_data(BIO *bio, int idx, void *data);
void *BIO_get_ex_data(BIO *bio, int idx);
uint64_t BIO_number_read(BIO *bio);
uint64_t BIO_number_written(BIO *bio);


int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
                        asn1_ps_func *prefix_free);
int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
                        asn1_ps_func **pprefix_free);
int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
                        asn1_ps_func *suffix_free);
int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
                        asn1_ps_func **psuffix_free);

const BIO_METHOD *BIO_s_file(void);
BIO *BIO_new_file(const char *filename, const char *mode);

BIO *BIO_new_fp(FILE *stream, int close_flag);

BIO *BIO_new(const BIO_METHOD *type);
int BIO_free(BIO *a);
void BIO_set_data(BIO *a, void *ptr);
void *BIO_get_data(BIO *a);
void BIO_set_init(BIO *a, int init);
int BIO_get_init(BIO *a);
void BIO_set_shutdown(BIO *a, int shut);
int BIO_get_shutdown(BIO *a);
void BIO_vfree(BIO *a);
int BIO_up_ref(BIO *a);
int BIO_read(BIO *b, void *data, int dlen);
int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
int BIO_gets(BIO *bp, char *buf, int size);
int BIO_write(BIO *b, const void *data, int dlen);
int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
int BIO_puts(BIO *bp, const char *buf);
int BIO_indent(BIO *b, int indent, int max);
long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
BIO *BIO_push(BIO *b, BIO *append);
BIO *BIO_pop(BIO *b);
void BIO_free_all(BIO *a);
BIO *BIO_find_type(BIO *b, int bio_type);
BIO *BIO_next(BIO *b);
void BIO_set_next(BIO *b, BIO *next);
BIO *BIO_get_retry_BIO(BIO *bio, int *reason);
int BIO_get_retry_reason(BIO *bio);
void BIO_set_retry_reason(BIO *bio, int reason);
BIO *BIO_dup_chain(BIO *in);

int BIO_nread0(BIO *bio, char **buf);
int BIO_nread(BIO *bio, char **buf, int num);
int BIO_nwrite0(BIO *bio, char **buf);
int BIO_nwrite(BIO *bio, char **buf, int num);

long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi,
                        long argl, long ret);

const BIO_METHOD *BIO_s_mem(void);
const BIO_METHOD *BIO_s_secmem(void);
BIO *BIO_new_mem_buf(const void *buf, int len);

const BIO_METHOD *BIO_s_socket(void);
const BIO_METHOD *BIO_s_connect(void);
const BIO_METHOD *BIO_s_accept(void);

const BIO_METHOD *BIO_s_fd(void);
const BIO_METHOD *BIO_s_log(void);
const BIO_METHOD *BIO_s_bio(void);
const BIO_METHOD *BIO_s_null(void);
const BIO_METHOD *BIO_f_null(void);
const BIO_METHOD *BIO_f_buffer(void);
const BIO_METHOD *BIO_f_linebuffer(void);
const BIO_METHOD *BIO_f_nbio_test(void);

const BIO_METHOD *BIO_s_datagram(void);
int BIO_dgram_non_fatal_error(int error);
BIO *BIO_new_dgram(int fd, int close_flag);

const BIO_METHOD *BIO_s_datagram_sctp(void);
BIO *BIO_new_dgram_sctp(int fd, int close_flag);
int BIO_dgram_is_sctp(BIO *bio);
int BIO_dgram_sctp_notification_cb(BIO *b,
                                   void (*handle_notifications) (BIO *bio,
                                                                 void *context,
                                                                 void *buf),
                                   void *context);
int BIO_dgram_sctp_wait_for_dry(BIO *b);
int BIO_dgram_sctp_msg_waiting(BIO *b);




int BIO_sock_should_retry(int i);
int BIO_sock_non_fatal_error(int error);


int BIO_fd_should_retry(int i);
int BIO_fd_non_fatal_error(int error);
int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u),
                void *u, const char *s, int len);
int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u),
                       void *u, const char *s, int len, int indent);
int BIO_dump(BIO *b, const char *bytes, int len);
int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent);

int BIO_dump_fp(FILE *fp, const char *s, int len);
int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent);

int BIO_hex_string(BIO *out, int indent, int width, unsigned char *data,
                   int datalen);


BIO_ADDR *BIO_ADDR_new(void);
int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
                     const void *where, size_t wherelen, unsigned short port);
void BIO_ADDR_free(BIO_ADDR *);
void BIO_ADDR_clear(BIO_ADDR *ap);
int BIO_ADDR_family(const BIO_ADDR *ap);
int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l);
unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap);
char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric);
char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric);
char *BIO_ADDR_path_string(const BIO_ADDR *ap);

const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai);
int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai);
int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai);
int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai);
const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai);
void BIO_ADDRINFO_free(BIO_ADDRINFO *bai);

enum BIO_hostserv_priorities {
    BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV
};
int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
                       enum BIO_hostserv_priorities hostserv_prio);
enum BIO_lookup_type {
    BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER
};
int BIO_lookup(const char *host, const char *service,
               enum BIO_lookup_type lookup_type,
               int family, int socktype, BIO_ADDRINFO **res);
int BIO_lookup_ex(const char *host, const char *service,
                  int lookup_type, int family, int socktype, int protocol,
                  BIO_ADDRINFO **res);
int BIO_sock_error(int sock);
int BIO_socket_ioctl(int fd, long type, void *arg);
int BIO_socket_nbio(int fd, int mode);
int BIO_sock_init(void);



int BIO_set_tcp_ndelay(int sock, int turn_on);

struct hostent *BIO_gethostbyname(const char *name) __attribute__ ((deprecated));
int BIO_get_port(const char *str, unsigned short *port_ptr) __attribute__ ((deprecated));
int BIO_get_host_ip(const char *str, unsigned char *ip) __attribute__ ((deprecated));
int BIO_get_accept_socket(char *host_port, int mode) __attribute__ ((deprecated));
int BIO_accept(int sock, char **ip_port) __attribute__ ((deprecated));

union BIO_sock_info_u {
    BIO_ADDR *addr;
};
enum BIO_sock_info_type {
    BIO_SOCK_INFO_ADDRESS
};
int BIO_sock_info(int sock,
                  enum BIO_sock_info_type type, union BIO_sock_info_u *info);







int BIO_socket(int domain, int socktype, int protocol, int options);
int BIO_connect(int sock, const BIO_ADDR *addr, int options);
int BIO_bind(int sock, const BIO_ADDR *addr, int options);
int BIO_listen(int sock, const BIO_ADDR *addr, int options);
int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options);
int BIO_closesocket(int sock);

BIO *BIO_new_socket(int sock, int close_flag);
BIO *BIO_new_connect(const char *host_port);
BIO *BIO_new_accept(const char *host_port);


BIO *BIO_new_fd(int fd, int close_flag);

int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
                     BIO **bio2, size_t writebuf2);






void BIO_copy_next_retry(BIO *b);
# 751 "/usr/include/openssl/bio.h" 3 4
int BIO_printf(BIO *bio, const char *format, ...)
;
int BIO_vprintf(BIO *bio, const char *format, va_list args)
;
int BIO_snprintf(char *buf, size_t n, const char *format, ...)
;
int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
;




BIO_METHOD *BIO_meth_new(int type, const char *name);
void BIO_meth_free(BIO_METHOD *biom);
int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int);
int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t,
                                                size_t *);
int BIO_meth_set_write(BIO_METHOD *biom,
                       int (*write) (BIO *, const char *, int));
int BIO_meth_set_write_ex(BIO_METHOD *biom,
                       int (*bwrite) (BIO *, const char *, size_t, size_t *));
int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int);
int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *);
int BIO_meth_set_read(BIO_METHOD *biom,
                      int (*read) (BIO *, char *, int));
int BIO_meth_set_read_ex(BIO_METHOD *biom,
                         int (*bread) (BIO *, char *, size_t, size_t *));
int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *);
int BIO_meth_set_puts(BIO_METHOD *biom,
                      int (*puts) (BIO *, const char *));
int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int);
int BIO_meth_set_gets(BIO_METHOD *biom,
                      int (*gets) (BIO *, char *, int));
long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *);
int BIO_meth_set_ctrl(BIO_METHOD *biom,
                      long (*ctrl) (BIO *, int, long, void *));
int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *);
int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *));
int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *);
int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *));
long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))
                                 (BIO *, int, BIO_info_cb *);
int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
                               long (*callback_ctrl) (BIO *, int,
                                                      BIO_info_cb *));


}
# 17 "/usr/include/openssl/evp.h" 2 3 4
# 1 "/usr/include/openssl/evperr.h" 1 3 4
# 19 "/usr/include/openssl/evperr.h" 3 4
extern "C"

int ERR_load_EVP_strings(void);
# 18 "/usr/include/openssl/evp.h" 2 3 4
# 28 "/usr/include/openssl/evp.h" 3 4
# 1 "/usr/include/openssl/objects.h" 1 3 4
# 13 "/usr/include/openssl/objects.h" 3 4
# 1 "/usr/include/openssl/obj_mac.h" 1 3 4
# 14 "/usr/include/openssl/objects.h" 2 3 4

# 1 "/usr/include/openssl/asn1.h" 1 3 4
# 15 "/usr/include/openssl/asn1.h" 3 4
# 1 "/usr/include/openssl/opensslconf.h" 1 3 4
# 42 "/usr/include/openssl/opensslconf.h" 3 4
# 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
# 23 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
extern "C" {
# 197 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
}
# 43 "/usr/include/openssl/opensslconf.h" 2 3 4
# 16 "/usr/include/openssl/asn1.h" 2 3 4


# 1 "/usr/include/openssl/asn1err.h" 1 3 4
# 19 "/usr/include/openssl/asn1err.h" 3 4
extern "C"

int ERR_load_ASN1_strings(void);
# 19 "/usr/include/openssl/asn1.h" 2 3 4




# 1 "/usr/include/openssl/bn.h" 1 3 4
# 18 "/usr/include/openssl/bn.h" 3 4
# 1 "/usr/include/openssl/opensslconf.h" 1 3 4
# 42 "/usr/include/openssl/opensslconf.h" 3 4
# 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
# 23 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
extern "C" {
# 197 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
}
# 43 "/usr/include/openssl/opensslconf.h" 2 3 4
# 19 "/usr/include/openssl/bn.h" 2 3 4


# 1 "/usr/include/openssl/bnerr.h" 1 3 4
# 19 "/usr/include/openssl/bnerr.h" 3 4
extern "C"

int ERR_load_BN_strings(void);
# 22 "/usr/include/openssl/bn.h" 2 3 4


extern "C" {
# 70 "/usr/include/openssl/bn.h" 3 4
void BN_set_flags(BIGNUM *b, int n);
int BN_get_flags(const BIGNUM *b, int n);
# 88 "/usr/include/openssl/bn.h" 3 4
void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);


int BN_GENCB_call(BN_GENCB *cb, int a, int b);

BN_GENCB *BN_GENCB_new(void);
void BN_GENCB_free(BN_GENCB *cb);


void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *),
                      void *cb_arg);


void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *),
                  void *cb_arg);

void *BN_GENCB_get_arg(BN_GENCB *cb);
# 183 "/usr/include/openssl/bn.h" 3 4
int BN_abs_is_word(const BIGNUM *a, const unsigned long w);
int BN_is_zero(const BIGNUM *a);
int BN_is_one(const BIGNUM *a);
int BN_is_word(const BIGNUM *a, const unsigned long w);
int BN_is_odd(const BIGNUM *a);



void BN_zero_ex(BIGNUM *a);







const BIGNUM *BN_value_one(void);
char *BN_options(void);
BN_CTX *BN_CTX_new(void);
BN_CTX *BN_CTX_secure_new(void);
void BN_CTX_free(BN_CTX *c);
void BN_CTX_start(BN_CTX *ctx);
BIGNUM *BN_CTX_get(BN_CTX *ctx);
void BN_CTX_end(BN_CTX *ctx);
int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom);
int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range);
int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
int BN_num_bits(const BIGNUM *a);
int BN_num_bits_word(unsigned long l);
int BN_security_bits(int L, int N);
BIGNUM *BN_new(void);
BIGNUM *BN_secure_new(void);
void BN_clear_free(BIGNUM *a);
BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
void BN_swap(BIGNUM *a, BIGNUM *b);
BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
int BN_bn2bin(const BIGNUM *a, unsigned char *to);
int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);




void BN_set_negative(BIGNUM *b, int n);




int BN_is_negative(const BIGNUM *b);

int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
           BN_CTX *ctx);

int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
               BN_CTX *ctx);
int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
                     const BIGNUM *m);
int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
               BN_CTX *ctx);
int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
                     const BIGNUM *m);
int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
               BN_CTX *ctx);
int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
                  BN_CTX *ctx);
int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);

unsigned long BN_mod_word(const BIGNUM *a, unsigned long w);
unsigned long BN_div_word(BIGNUM *a, unsigned long w);
int BN_mul_word(BIGNUM *a, unsigned long w);
int BN_add_word(BIGNUM *a, unsigned long w);
int BN_sub_word(BIGNUM *a, unsigned long w);
int BN_set_word(BIGNUM *a, unsigned long w);
unsigned long BN_get_word(const BIGNUM *a);

int BN_cmp(const BIGNUM *a, const BIGNUM *b);
void BN_free(BIGNUM *a);
int BN_is_bit_set(const BIGNUM *a, int n);
int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
int BN_lshift1(BIGNUM *r, const BIGNUM *a);
int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);

int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
               const BIGNUM *m, BN_CTX *ctx);
int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
                              const BIGNUM *m, BN_CTX *ctx,
                              BN_MONT_CTX *in_mont);
int BN_mod_exp_mont_word(BIGNUM *r, unsigned long a, const BIGNUM *p,
                         const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
                     const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
                     BN_CTX *ctx, BN_MONT_CTX *m_ctx);
int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                      const BIGNUM *m, BN_CTX *ctx);

int BN_mask_bits(BIGNUM *a, int n);

int BN_print_fp(FILE *fp, const BIGNUM *a);

int BN_print(BIO *bio, const BIGNUM *a);
int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
int BN_rshift1(BIGNUM *r, const BIGNUM *a);
void BN_clear(BIGNUM *a);
BIGNUM *BN_dup(const BIGNUM *a);
int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
int BN_set_bit(BIGNUM *a, int n);
int BN_clear_bit(BIGNUM *a, int n);
char *BN_bn2hex(const BIGNUM *a);
char *BN_bn2dec(const BIGNUM *a);
int BN_hex2bn(BIGNUM **a, const char *str);
int BN_dec2bn(BIGNUM **a, const char *str);
int BN_asc2bn(BIGNUM **a, const char *str);
int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);


BIGNUM *BN_mod_inverse(BIGNUM *ret,
                       const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
BIGNUM *BN_mod_sqrt(BIGNUM *ret,
                    const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);

void BN_consttime_swap(unsigned long swap, BIGNUM *a, BIGNUM *b, int nwords);


BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, const BIGNUM *add, const BIGNUM *rem, void (*callback) (int, int, void *), void *cb_arg) __attribute__ ((deprecated));





int BN_is_prime(const BIGNUM *p, int nchecks, void (*callback) (int, int, void *), BN_CTX *ctx, void *cb_arg) __attribute__ ((deprecated));



int BN_is_prime_fasttest(const BIGNUM *p, int nchecks, void (*callback) (int, int, void *), BN_CTX *ctx, void *cb_arg, int do_trial_division) __attribute__ ((deprecated));






int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
                         const BIGNUM *rem, BN_GENCB *cb);
int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
                            int do_trial_division, BN_GENCB *cb);

int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);

int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
                            const BIGNUM *Xp, const BIGNUM *Xp1,
                            const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
                            BN_GENCB *cb);
int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
                              BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
                              BN_CTX *ctx, BN_GENCB *cb);

BN_MONT_CTX *BN_MONT_CTX_new(void);
int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
                          BN_MONT_CTX *mont, BN_CTX *ctx);
int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
                     BN_CTX *ctx);
int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
                       BN_CTX *ctx);
void BN_MONT_CTX_free(BN_MONT_CTX *mont);
int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
                                    const BIGNUM *mod, BN_CTX *ctx);





BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
void BN_BLINDING_free(BN_BLINDING *b);
int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
                          BN_CTX *);

int BN_BLINDING_is_current_thread(BN_BLINDING *b);
void BN_BLINDING_set_current_thread(BN_BLINDING *b);
int BN_BLINDING_lock(BN_BLINDING *b);
int BN_BLINDING_unlock(BN_BLINDING *b);

unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
                                      const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
                                      int (*bn_mod_exp) (BIGNUM *r,
                                                         const BIGNUM *a,
                                                         const BIGNUM *p,
                                                         const BIGNUM *m,
                                                         BN_CTX *ctx,
                                                         BN_MONT_CTX *m_ctx),
                                      BN_MONT_CTX *m_ctx);

void BN_set_params(int mul, int high, int low, int mont) __attribute__ ((deprecated));
int BN_get_params(int which) __attribute__ ((deprecated));


BN_RECP_CTX *BN_RECP_CTX_new(void);
void BN_RECP_CTX_free(BN_RECP_CTX *recp);
int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
                          BN_RECP_CTX *recp, BN_CTX *ctx);
int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                    const BIGNUM *m, BN_CTX *ctx);
int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
                BN_RECP_CTX *recp, BN_CTX *ctx);
# 491 "/usr/include/openssl/bn.h" 3 4
int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);

const BIGNUM *BN_get0_nist_prime_192(void);
const BIGNUM *BN_get0_nist_prime_224(void);
const BIGNUM *BN_get0_nist_prime_256(void);
const BIGNUM *BN_get0_nist_prime_384(void);
const BIGNUM *BN_get0_nist_prime_521(void);

int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a,
                                          const BIGNUM *field, BN_CTX *ctx);

int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
                          const BIGNUM *priv, const unsigned char *message,
                          size_t message_len, BN_CTX *ctx);


BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);


BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
# 533 "/usr/include/openssl/bn.h" 3 4
int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);



}
# 24 "/usr/include/openssl/asn1.h" 2 3 4
# 32 "/usr/include/openssl/asn1.h" 3 4
extern "C" {
# 118 "/usr/include/openssl/asn1.h" 3 4
    struct X509_algor_st;
struct stack_st_X509_ALGOR; typedef int (*sk_X509_ALGOR_compfunc)(const X509_ALGOR * const *a, const X509_ALGOR *const *b); typedef void (*sk_X509_ALGOR_freefunc)(X509_ALGOR *a); typedef X509_ALGOR * (*sk_X509_ALGOR_copyfunc)(const X509_ALGOR *a); static __attribute__((unused)) inline int sk_X509_ALGOR_num(const struct stack_st_X509_ALGOR *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline X509_ALGOR *sk_X509_ALGOR_value(const struct stack_st_X509_ALGOR *sk, int idx) { return (X509_ALGOR *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_X509_ALGOR *sk_X509_ALGOR_new(sk_X509_ALGOR_compfunc compare) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_X509_ALGOR *sk_X509_ALGOR_new_null(void) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_X509_ALGOR *sk_X509_ALGOR_new_reserve(sk_X509_ALGOR_compfunc compare, int n) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_X509_ALGOR_reserve(struct stack_st_X509_ALGOR *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_X509_ALGOR_free(struct stack_st_X509_ALGOR *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_X509_ALGOR_zero(struct stack_st_X509_ALGOR *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline X509_ALGOR *sk_X509_ALGOR_delete(struct stack_st_X509_ALGOR *sk, int i) { return (X509_ALGOR *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline X509_ALGOR *sk_X509_ALGOR_delete_ptr(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return (X509_ALGOR *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_X509_ALGOR_push(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_X509_ALGOR_unshift(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline X509_ALGOR *sk_X509_ALGOR_pop(struct stack_st_X509_ALGOR *sk) { return (X509_ALGOR *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline X509_ALGOR *sk_X509_ALGOR_shift(struct stack_st_X509_ALGOR *sk) { return (X509_ALGOR *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_X509_ALGOR_pop_free(struct stack_st_X509_ALGOR *sk, sk_X509_ALGOR_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_X509_ALGOR_insert(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline X509_ALGOR *sk_X509_ALGOR_set(struct stack_st_X509_ALGOR *sk, int idx, X509_ALGOR *ptr) { return (X509_ALGOR *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_X509_ALGOR_find(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_X509_ALGOR_find_ex(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_X509_ALGOR_sort(struct stack_st_X509_ALGOR *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_X509_ALGOR_is_sorted(const struct stack_st_X509_ALGOR *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_X509_ALGOR * sk_X509_ALGOR_dup(const struct stack_st_X509_ALGOR *sk) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_X509_ALGOR *sk_X509_ALGOR_deep_copy(const struct stack_st_X509_ALGOR *sk, sk_X509_ALGOR_copyfunc copyfunc, sk_X509_ALGOR_freefunc freefunc) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_X509_ALGOR_compfunc sk_X509_ALGOR_set_cmp_func(struct stack_st_X509_ALGOR *sk, sk_X509_ALGOR_compfunc compare) { return (sk_X509_ALGOR_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
# 146 "/usr/include/openssl/asn1.h" 3 4
struct asn1_string_st {
    int length;
    int type;
    unsigned char *data;





    long flags;
};







typedef struct ASN1_ENCODING_st {
    unsigned char *enc;
    long len;
    int modified;
} ASN1_ENCODING;
# 186 "/usr/include/openssl/asn1.h" 3 4
typedef struct asn1_string_table_st {
    int nid;
    long minsize;
    long maxsize;
    unsigned long mask;
    unsigned long flags;
} ASN1_STRING_TABLE;

struct stack_st_ASN1_STRING_TABLE; typedef int (*sk_ASN1_STRING_TABLE_compfunc)(const ASN1_STRING_TABLE * const *a, const ASN1_STRING_TABLE *const *b); typedef void (*sk_ASN1_STRING_TABLE_freefunc)(ASN1_STRING_TABLE *a); typedef ASN1_STRING_TABLE * (*sk_ASN1_STRING_TABLE_copyfunc)(const ASN1_STRING_TABLE *a); static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_num(const struct stack_st_ASN1_STRING_TABLE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_value(const struct stack_st_ASN1_STRING_TABLE *sk, int idx) { return (ASN1_STRING_TABLE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_new(sk_ASN1_STRING_TABLE_compfunc compare) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_new_null(void) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_new_reserve(sk_ASN1_STRING_TABLE_compfunc compare, int n) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_reserve(struct stack_st_ASN1_STRING_TABLE *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_ASN1_STRING_TABLE_free(struct stack_st_ASN1_STRING_TABLE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_STRING_TABLE_zero(struct stack_st_ASN1_STRING_TABLE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_delete(struct stack_st_ASN1_STRING_TABLE *sk, int i) { return (ASN1_STRING_TABLE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_delete_ptr(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return (ASN1_STRING_TABLE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_push(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_unshift(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_pop(struct stack_st_ASN1_STRING_TABLE *sk) { return (ASN1_STRING_TABLE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_shift(struct stack_st_ASN1_STRING_TABLE *sk) { return (ASN1_STRING_TABLE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_STRING_TABLE_pop_free(struct stack_st_ASN1_STRING_TABLE *sk, sk_ASN1_STRING_TABLE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_insert(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_set(struct stack_st_ASN1_STRING_TABLE *sk, int idx, ASN1_STRING_TABLE *ptr) { return (ASN1_STRING_TABLE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_find(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_find_ex(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_ASN1_STRING_TABLE_sort(struct stack_st_ASN1_STRING_TABLE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_ASN1_STRING_TABLE_is_sorted(const struct stack_st_ASN1_STRING_TABLE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_STRING_TABLE * sk_ASN1_STRING_TABLE_dup(const struct stack_st_ASN1_STRING_TABLE *sk) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_deep_copy(const struct stack_st_ASN1_STRING_TABLE *sk, sk_ASN1_STRING_TABLE_copyfunc copyfunc, sk_ASN1_STRING_TABLE_freefunc freefunc) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_ASN1_STRING_TABLE_compfunc sk_ASN1_STRING_TABLE_set_cmp_func(struct stack_st_ASN1_STRING_TABLE *sk, sk_ASN1_STRING_TABLE_compfunc compare) { return (sk_ASN1_STRING_TABLE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
# 210 "/usr/include/openssl/asn1.h" 3 4
typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
typedef struct ASN1_TLC_st ASN1_TLC;

typedef struct ASN1_VALUE_st ASN1_VALUE;
# 277 "/usr/include/openssl/asn1.h" 3 4
typedef void *d2i_of_void(void **,const unsigned char **,long); typedef int i2d_of_void(void *,unsigned char **);
# 318 "/usr/include/openssl/asn1.h" 3 4
typedef const ASN1_ITEM ASN1_ITEM_EXP;
# 438 "/usr/include/openssl/asn1.h" 3 4
struct stack_st_ASN1_INTEGER; typedef int (*sk_ASN1_INTEGER_compfunc)(const ASN1_INTEGER * const *a, const ASN1_INTEGER *const *b); typedef void (*sk_ASN1_INTEGER_freefunc)(ASN1_INTEGER *a); typedef ASN1_INTEGER * (*sk_ASN1_INTEGER_copyfunc)(const ASN1_INTEGER *a); static __attribute__((unused)) inline int sk_ASN1_INTEGER_num(const struct stack_st_ASN1_INTEGER *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_INTEGER *sk_ASN1_INTEGER_value(const struct stack_st_ASN1_INTEGER *sk, int idx) { return (ASN1_INTEGER *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_ASN1_INTEGER *sk_ASN1_INTEGER_new(sk_ASN1_INTEGER_compfunc compare) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_ASN1_INTEGER *sk_ASN1_INTEGER_new_null(void) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_ASN1_INTEGER *sk_ASN1_INTEGER_new_reserve(sk_ASN1_INTEGER_compfunc compare, int n) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_ASN1_INTEGER_reserve(struct stack_st_ASN1_INTEGER *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_ASN1_INTEGER_free(struct stack_st_ASN1_INTEGER *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_INTEGER_zero(struct stack_st_ASN1_INTEGER *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_INTEGER *sk_ASN1_INTEGER_delete(struct stack_st_ASN1_INTEGER *sk, int i) { return (ASN1_INTEGER *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline ASN1_INTEGER *sk_ASN1_INTEGER_delete_ptr(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return (ASN1_INTEGER *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_INTEGER_push(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_INTEGER_unshift(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline ASN1_INTEGER *sk_ASN1_INTEGER_pop(struct stack_st_ASN1_INTEGER *sk) { return (ASN1_INTEGER *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_INTEGER *sk_ASN1_INTEGER_shift(struct stack_st_ASN1_INTEGER *sk) { return (ASN1_INTEGER *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_INTEGER_pop_free(struct stack_st_ASN1_INTEGER *sk, sk_ASN1_INTEGER_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_ASN1_INTEGER_insert(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline ASN1_INTEGER *sk_ASN1_INTEGER_set(struct stack_st_ASN1_INTEGER *sk, int idx, ASN1_INTEGER *ptr) { return (ASN1_INTEGER *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_INTEGER_find(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_INTEGER_find_ex(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_ASN1_INTEGER_sort(struct stack_st_ASN1_INTEGER *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_ASN1_INTEGER_is_sorted(const struct stack_st_ASN1_INTEGER *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_INTEGER * sk_ASN1_INTEGER_dup(const struct stack_st_ASN1_INTEGER *sk) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_INTEGER *sk_ASN1_INTEGER_deep_copy(const struct stack_st_ASN1_INTEGER *sk, sk_ASN1_INTEGER_copyfunc copyfunc, sk_ASN1_INTEGER_freefunc freefunc) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_ASN1_INTEGER_compfunc sk_ASN1_INTEGER_set_cmp_func(struct stack_st_ASN1_INTEGER *sk, sk_ASN1_INTEGER_compfunc compare) { return (sk_ASN1_INTEGER_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }

struct stack_st_ASN1_GENERALSTRING; typedef int (*sk_ASN1_GENERALSTRING_compfunc)(const ASN1_GENERALSTRING * const *a, const ASN1_GENERALSTRING *const *b); typedef void (*sk_ASN1_GENERALSTRING_freefunc)(ASN1_GENERALSTRING *a); typedef ASN1_GENERALSTRING * (*sk_ASN1_GENERALSTRING_copyfunc)(const ASN1_GENERALSTRING *a); static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_num(const struct stack_st_ASN1_GENERALSTRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_value(const struct stack_st_ASN1_GENERALSTRING *sk, int idx) { return (ASN1_GENERALSTRING *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_new(sk_ASN1_GENERALSTRING_compfunc compare) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_new_null(void) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_new_reserve(sk_ASN1_GENERALSTRING_compfunc compare, int n) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_reserve(struct stack_st_ASN1_GENERALSTRING *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_ASN1_GENERALSTRING_free(struct stack_st_ASN1_GENERALSTRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_GENERALSTRING_zero(struct stack_st_ASN1_GENERALSTRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_delete(struct stack_st_ASN1_GENERALSTRING *sk, int i) { return (ASN1_GENERALSTRING *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_delete_ptr(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return (ASN1_GENERALSTRING *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_push(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_unshift(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_pop(struct stack_st_ASN1_GENERALSTRING *sk) { return (ASN1_GENERALSTRING *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_shift(struct stack_st_ASN1_GENERALSTRING *sk) { return (ASN1_GENERALSTRING *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_GENERALSTRING_pop_free(struct stack_st_ASN1_GENERALSTRING *sk, sk_ASN1_GENERALSTRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_insert(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_set(struct stack_st_ASN1_GENERALSTRING *sk, int idx, ASN1_GENERALSTRING *ptr) { return (ASN1_GENERALSTRING *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_find(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_find_ex(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_ASN1_GENERALSTRING_sort(struct stack_st_ASN1_GENERALSTRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_ASN1_GENERALSTRING_is_sorted(const struct stack_st_ASN1_GENERALSTRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_GENERALSTRING * sk_ASN1_GENERALSTRING_dup(const struct stack_st_ASN1_GENERALSTRING *sk) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_deep_copy(const struct stack_st_ASN1_GENERALSTRING *sk, sk_ASN1_GENERALSTRING_copyfunc copyfunc, sk_ASN1_GENERALSTRING_freefunc freefunc) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_ASN1_GENERALSTRING_compfunc sk_ASN1_GENERALSTRING_set_cmp_func(struct stack_st_ASN1_GENERALSTRING *sk, sk_ASN1_GENERALSTRING_compfunc compare) { return (sk_ASN1_GENERALSTRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }

struct stack_st_ASN1_UTF8STRING; typedef int (*sk_ASN1_UTF8STRING_compfunc)(const ASN1_UTF8STRING * const *a, const ASN1_UTF8STRING *const *b); typedef void (*sk_ASN1_UTF8STRING_freefunc)(ASN1_UTF8STRING *a); typedef ASN1_UTF8STRING * (*sk_ASN1_UTF8STRING_copyfunc)(const ASN1_UTF8STRING *a); static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_num(const struct stack_st_ASN1_UTF8STRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_value(const struct stack_st_ASN1_UTF8STRING *sk, int idx) { return (ASN1_UTF8STRING *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_ASN1_UTF8STRING *sk_ASN1_UTF8STRING_new(sk_ASN1_UTF8STRING_compfunc compare) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_ASN1_UTF8STRING *sk_ASN1_UTF8STRING_new_null(void) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_ASN1_UTF8STRING *sk_ASN1_UTF8STRING_new_reserve(sk_ASN1_UTF8STRING_compfunc compare, int n) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_reserve(struct stack_st_ASN1_UTF8STRING *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_ASN1_UTF8STRING_free(struct stack_st_ASN1_UTF8STRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_UTF8STRING_zero(struct stack_st_ASN1_UTF8STRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_delete(struct stack_st_ASN1_UTF8STRING *sk, int i) { return (ASN1_UTF8STRING *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_delete_ptr(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return (ASN1_UTF8STRING *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_push(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_unshift(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_pop(struct stack_st_ASN1_UTF8STRING *sk) { return (ASN1_UTF8STRING *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_shift(struct stack_st_ASN1_UTF8STRING *sk) { return (ASN1_UTF8STRING *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_UTF8STRING_pop_free(struct stack_st_ASN1_UTF8STRING *sk, sk_ASN1_UTF8STRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_insert(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_set(struct stack_st_ASN1_UTF8STRING *sk, int idx, ASN1_UTF8STRING *ptr) { return (ASN1_UTF8STRING *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_find(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_find_ex(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_ASN1_UTF8STRING_sort(struct stack_st_ASN1_UTF8STRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_ASN1_UTF8STRING_is_sorted(const struct stack_st_ASN1_UTF8STRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_UTF8STRING * sk_ASN1_UTF8STRING_dup(const struct stack_st_ASN1_UTF8STRING *sk) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_UTF8STRING *sk_ASN1_UTF8STRING_deep_copy(const struct stack_st_ASN1_UTF8STRING *sk, sk_ASN1_UTF8STRING_copyfunc copyfunc, sk_ASN1_UTF8STRING_freefunc freefunc) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_ASN1_UTF8STRING_compfunc sk_ASN1_UTF8STRING_set_cmp_func(struct stack_st_ASN1_UTF8STRING *sk, sk_ASN1_UTF8STRING_compfunc compare) { return (sk_ASN1_UTF8STRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }

typedef struct asn1_type_st {
    int type;
    union {
        char *ptr;
        ASN1_BOOLEAN boolean;
        ASN1_STRING *asn1_string;
        ASN1_OBJECT *object;
        ASN1_INTEGER *integer;
        ASN1_ENUMERATED *enumerated;
        ASN1_BIT_STRING *bit_string;
        ASN1_OCTET_STRING *octet_string;
        ASN1_PRINTABLESTRING *printablestring;
        ASN1_T61STRING *t61string;
        ASN1_IA5STRING *ia5string;
        ASN1_GENERALSTRING *generalstring;
        ASN1_BMPSTRING *bmpstring;
        ASN1_UNIVERSALSTRING *universalstring;
        ASN1_UTCTIME *utctime;
        ASN1_GENERALIZEDTIME *generalizedtime;
        ASN1_VISIBLESTRING *visiblestring;
        ASN1_UTF8STRING *utf8string;




        ASN1_STRING *set;
        ASN1_STRING *sequence;
        ASN1_VALUE *asn1_value;
    } value;
} ASN1_TYPE;

struct stack_st_ASN1_TYPE; typedef int (*sk_ASN1_TYPE_compfunc)(const ASN1_TYPE * const *a, const ASN1_TYPE *const *b); typedef void (*sk_ASN1_TYPE_freefunc)(ASN1_TYPE *a); typedef ASN1_TYPE * (*sk_ASN1_TYPE_copyfunc)(const ASN1_TYPE *a); static __attribute__((unused)) inline int sk_ASN1_TYPE_num(const struct stack_st_ASN1_TYPE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_TYPE *sk_ASN1_TYPE_value(const struct stack_st_ASN1_TYPE *sk, int idx) { return (ASN1_TYPE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_ASN1_TYPE *sk_ASN1_TYPE_new(sk_ASN1_TYPE_compfunc compare) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_ASN1_TYPE *sk_ASN1_TYPE_new_null(void) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_ASN1_TYPE *sk_ASN1_TYPE_new_reserve(sk_ASN1_TYPE_compfunc compare, int n) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_ASN1_TYPE_reserve(struct stack_st_ASN1_TYPE *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_ASN1_TYPE_free(struct stack_st_ASN1_TYPE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_TYPE_zero(struct stack_st_ASN1_TYPE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_TYPE *sk_ASN1_TYPE_delete(struct stack_st_ASN1_TYPE *sk, int i) { return (ASN1_TYPE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline ASN1_TYPE *sk_ASN1_TYPE_delete_ptr(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return (ASN1_TYPE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_TYPE_push(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_TYPE_unshift(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline ASN1_TYPE *sk_ASN1_TYPE_pop(struct stack_st_ASN1_TYPE *sk) { return (ASN1_TYPE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_TYPE *sk_ASN1_TYPE_shift(struct stack_st_ASN1_TYPE *sk) { return (ASN1_TYPE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_TYPE_pop_free(struct stack_st_ASN1_TYPE *sk, sk_ASN1_TYPE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_ASN1_TYPE_insert(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline ASN1_TYPE *sk_ASN1_TYPE_set(struct stack_st_ASN1_TYPE *sk, int idx, ASN1_TYPE *ptr) { return (ASN1_TYPE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_TYPE_find(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_TYPE_find_ex(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_ASN1_TYPE_sort(struct stack_st_ASN1_TYPE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_ASN1_TYPE_is_sorted(const struct stack_st_ASN1_TYPE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_TYPE * sk_ASN1_TYPE_dup(const struct stack_st_ASN1_TYPE *sk) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_TYPE *sk_ASN1_TYPE_deep_copy(const struct stack_st_ASN1_TYPE *sk, sk_ASN1_TYPE_copyfunc copyfunc, sk_ASN1_TYPE_freefunc freefunc) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_ASN1_TYPE_compfunc sk_ASN1_TYPE_set_cmp_func(struct stack_st_ASN1_TYPE *sk, sk_ASN1_TYPE_compfunc compare) { return (sk_ASN1_TYPE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }

typedef struct stack_st_ASN1_TYPE ASN1_SEQUENCE_ANY;

ASN1_SEQUENCE_ANY *d2i_ASN1_SEQUENCE_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len); int i2d_ASN1_SEQUENCE_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out); extern const ASN1_ITEM ASN1_SEQUENCE_ANY_it;
ASN1_SEQUENCE_ANY *d2i_ASN1_SET_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len); int i2d_ASN1_SET_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out); extern const ASN1_ITEM ASN1_SET_ANY_it;


typedef struct BIT_STRING_BITNAME_st {
    int bitnum;
    const char *lname;
    const char *sname;
} BIT_STRING_BITNAME;
# 518 "/usr/include/openssl/asn1.h" 3 4
ASN1_TYPE *ASN1_TYPE_new(void); void ASN1_TYPE_free(ASN1_TYPE *a); ASN1_TYPE *d2i_ASN1_TYPE(ASN1_TYPE **a, const unsigned char **in, long len); int i2d_ASN1_TYPE(ASN1_TYPE *a, unsigned char **out); extern const ASN1_ITEM ASN1_ANY_it;

int ASN1_TYPE_get(const ASN1_TYPE *a);
void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);
int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value);
int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);

ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t);
void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t);

ASN1_OBJECT *ASN1_OBJECT_new(void);
void ASN1_OBJECT_free(ASN1_OBJECT *a);
int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp);
ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
                             long length);

extern const ASN1_ITEM ASN1_OBJECT_it;

struct stack_st_ASN1_OBJECT; typedef int (*sk_ASN1_OBJECT_compfunc)(const ASN1_OBJECT * const *a, const ASN1_OBJECT *const *b); typedef void (*sk_ASN1_OBJECT_freefunc)(ASN1_OBJECT *a); typedef ASN1_OBJECT * (*sk_ASN1_OBJECT_copyfunc)(const ASN1_OBJECT *a); static __attribute__((unused)) inline int sk_ASN1_OBJECT_num(const struct stack_st_ASN1_OBJECT *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_OBJECT *sk_ASN1_OBJECT_value(const struct stack_st_ASN1_OBJECT *sk, int idx) { return (ASN1_OBJECT *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static __attribute__((unused)) inline struct stack_st_ASN1_OBJECT *sk_ASN1_OBJECT_new(sk_ASN1_OBJECT_compfunc compare) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static __attribute__((unused)) inline struct stack_st_ASN1_OBJECT *sk_ASN1_OBJECT_new_null(void) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_new_null(); } static __attribute__((unused)) inline struct stack_st_ASN1_OBJECT *sk_ASN1_OBJECT_new_reserve(sk_ASN1_OBJECT_compfunc compare, int n) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); } static __attribute__((unused)) inline int sk_ASN1_OBJECT_reserve(struct stack_st_ASN1_OBJECT *sk, int n) { return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); } static __attribute__((unused)) inline void sk_ASN1_OBJECT_free(struct stack_st_ASN1_OBJECT *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_OBJECT_zero(struct stack_st_ASN1_OBJECT *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_OBJECT *sk_ASN1_OBJECT_delete(struct stack_st_ASN1_OBJECT *sk, int i) { return (ASN1_OBJECT *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static __attribute__((unused)) inline ASN1_OBJECT *sk_ASN1_OBJECT_delete_ptr(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return (ASN1_OBJECT *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_OBJECT_push(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_OBJECT_unshift(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline ASN1_OBJECT *sk_ASN1_OBJECT_pop(struct stack_st_ASN1_OBJECT *sk) { return (ASN1_OBJECT *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline ASN1_OBJECT *sk_ASN1_OBJECT_shift(struct stack_st_ASN1_OBJECT *sk) { return (ASN1_OBJECT *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline void sk_ASN1_OBJECT_pop_free(struct stack_st_ASN1_OBJECT *sk, sk_ASN1_OBJECT_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline int sk_ASN1_OBJECT_insert(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static __attribute__((unused)) inline ASN1_OBJECT *sk_ASN1_OBJECT_set(struct stack_st_ASN1_OBJECT *sk, int idx, ASN1_OBJECT *ptr) { return (ASN1_OBJECT *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_OBJECT_find(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline int sk_ASN1_OBJECT_find_ex(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static __attribute__((unused)) inline void sk_ASN1_OBJECT_sort(struct stack_st_ASN1_OBJECT *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static __attribute__((unused)) inline int sk_ASN1_OBJECT_is_sorted(const struct stack_st_ASN1_OBJECT *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_OBJECT * sk_ASN1_OBJECT_dup(const struct stack_st_ASN1_OBJECT *sk) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static __attribute__((unused)) inline struct stack_st_ASN1_OBJECT *sk_ASN1_OBJECT_deep_copy(const struct stack_st_ASN1_OBJECT *sk, sk_ASN1_OBJECT_copyfunc copyfunc, sk_ASN1_OBJECT_freefunc freefunc) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static __attribute__((unused)) inline sk_ASN1_OBJECT_compfunc sk_ASN1_OBJECT_set_cmp_func(struct stack_st_ASN1_OBJECT *sk, sk_ASN1_OBJECT_compfunc compare) { return (sk_ASN1_OBJECT_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }

ASN1_STRING *ASN1_STRING_new(void);
void ASN1_STRING_free(ASN1_STRING *a);
void ASN1_STRING_clear_free(ASN1_STRING *a);
int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);
ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a);
ASN1_STRING *ASN1_STRING_type_new(int type);
int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);




int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);
int ASN1_STRING_length(const ASN1_STRING *x);
void ASN1_STRING_length_set(ASN1_STRING *x, int n);
int ASN1_STRING_type(const ASN1_STRING *x);
unsigned char *ASN1_STRING_data(ASN1_STRING *x) __attribute__ ((deprecated));
const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);

ASN1_BIT_STRING *ASN1_BIT_STRING_new(void); void ASN1_BIT_STRING_free(ASN1_BIT_STRING *a); ASN1_BIT_STRING *d2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **in, long len); int i2d_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_BIT_STRING_it;
int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length);
int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value);
int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n);
int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
                          const unsigned char *flags, int flags_len);

int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
                               BIT_STRING_BITNAME *tbl, int indent);
int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
                            BIT_STRING_BITNAME *tbl);

ASN1_INTEGER *ASN1_INTEGER_new(void); void ASN1_INTEGER_free(ASN1_INTEGER *a); ASN1_INTEGER *d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len); int i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **out); extern const ASN1_ITEM ASN1_INTEGER_it;
ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
                                long length);
ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x);
int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);

ASN1_ENUMERATED *ASN1_ENUMERATED_new(void); void ASN1_ENUMERATED_free(ASN1_ENUMERATED *a); ASN1_ENUMERATED *d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, const unsigned char **in, long len); int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **out); extern const ASN1_ITEM ASN1_ENUMERATED_it;

int ASN1_UTCTIME_check(const ASN1_UTCTIME *a);
ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t);
ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
                               int offset_day, long offset_sec);
int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str);
int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t);

int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a);
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
                                               time_t t);
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
                                               time_t t, int offset_day,
                                               long offset_sec);
int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str);

int ASN1_TIME_diff(int *pday, int *psec,
                   const ASN1_TIME *from, const ASN1_TIME *to);

ASN1_OCTET_STRING *ASN1_OCTET_STRING_new(void); void ASN1_OCTET_STRING_free(ASN1_OCTET_STRING *a); ASN1_OCTET_STRING *d2i_ASN1_OCTET_STRING(ASN1_OCTET_STRING **a, const unsigned char **in, long len); int i2d_ASN1_OCTET_STRING(ASN1_OCTET_STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_OCTET_STRING_it;
ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a);
int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,
                          const ASN1_OCTET_STRING *b);
int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,
                          int len);

ASN1_VISIBLESTRING *ASN1_VISIBLESTRING_new(void); void ASN1_VISIBLESTRING_free(ASN1_VISIBLESTRING *a); ASN1_VISIBLESTRING *d2i_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING **a, const unsigned char **in, long len); int i2d_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_VISIBLESTRING_it;
ASN1_UNIVERSALSTRING *ASN1_UNIVERSALSTRING_new(void); void ASN1_UNIVERSALSTRING_free(ASN1_UNIVERSALSTRING *a); ASN1_UNIVERSALSTRING *d2i_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING **a, const unsigned char **in, long len); int i2d_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_UNIVERSALSTRING_it;
ASN1_UTF8STRING *ASN1_UTF8STRING_new(void); void ASN1_UTF8STRING_free(ASN1_UTF8STRING *a); ASN1_UTF8STRING *d2i_ASN1_UTF8STRING(ASN1_UTF8STRING **a, const unsigned char **in, long len); int i2d_ASN1_UTF8STRING(ASN1_UTF8STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_UTF8STRING_it;
ASN1_NULL *ASN1_NULL_new(void); void ASN1_NULL_free(ASN1_NULL *a); ASN1_NULL *d2i_ASN1_NULL(ASN1_NULL **a, const unsigned char **in, long len); int i2d_ASN1_NULL(ASN1_NULL *a, unsigned char **out); extern const ASN1_ITEM ASN1_NULL_it;
ASN1_BMPSTRING *ASN1_BMPSTRING_new(void); void ASN1_BMPSTRING_free(ASN1_BMPSTRING *a); ASN1_BMPSTRING *d2i_ASN1_BMPSTRING(ASN1_BMPSTRING **a, const unsigned char **in, long len); int i2d_ASN1_BMPSTRING(ASN1_BMPSTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_BMPSTRING_it;

int UTF8_getc(const unsigned char *str, int len, unsigned long *val);
int UTF8_putc(unsigned char *str, int len, unsigned long value);

ASN1_STRING *ASN1_PRINTABLE_new(void); void ASN1_PRINTABLE_free(ASN1_STRING *a); ASN1_STRING *d2i_ASN1_PRINTABLE(ASN1_STRING **a, const unsigned char **in, long len); int i2d_ASN1_PRINTABLE(ASN1_STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_PRINTABLE_it;

ASN1_STRING *DIRECTORYSTRING_new(void); void DIRECTORYSTRING_free(ASN1_STRING *a); ASN1_STRING *d2i_DIRECTORYSTRING(ASN1_STRING **a, const unsigned char **in, long len); int i2d_DIRECTORYSTRING(ASN1_STRING *a, unsigned char **out); extern const ASN1_ITEM DIRECTORYSTRING_it;
ASN1_STRING *DISPLAYTEXT_new(void); void DISPLAYTEXT_free(ASN1_STRING *a); ASN1_STRING *d2i_DISPLAYTEXT(ASN1_STRING **a, const unsigned char **in, long len); int i2d_DISPLAYTEXT(ASN1_STRING *a, unsigned char **out); extern const ASN1_ITEM DISPLAYTEXT_it;
ASN1_PRINTABLESTRING *ASN1_PRINTABLESTRING_new(void); void ASN1_PRINTABLESTRING_free(ASN1_PRINTABLESTRING *a); ASN1_PRINTABLESTRING *d2i_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING **a, const unsigned char **in, long len); int i2d_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_PRINTABLESTRING_it;
ASN1_T61STRING *ASN1_T61STRING_new(void); void ASN1_T61STRING_free(ASN1_T61STRING *a); ASN1_T61STRING *d2i_ASN1_T61STRING(ASN1_T61STRING **a, const unsigned char **in, long len); int i2d_ASN1_T61STRING(ASN1_T61STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_T61STRING_it;
ASN1_IA5STRING *ASN1_IA5STRING_new(void); void ASN1_IA5STRING_free(ASN1_IA5STRING *a); ASN1_IA5STRING *d2i_ASN1_IA5STRING(ASN1_IA5STRING **a, const unsigned char **in, long len); int i2d_ASN1_IA5STRING(ASN1_IA5STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_IA5STRING_it;
ASN1_GENERALSTRING *ASN1_GENERALSTRING_new(void); void ASN1_GENERALSTRING_free(ASN1_GENERALSTRING *a); ASN1_GENERALSTRING *d2i_ASN1_GENERALSTRING(ASN1_GENERALSTRING **a, const unsigned char **in, long len); int i2d_ASN1_GENERALSTRING(ASN1_GENERALSTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_GENERALSTRING_it;
ASN1_UTCTIME *ASN1_UTCTIME_new(void); void ASN1_UTCTIME_free(ASN1_UTCTIME *a); ASN1_UTCTIME *d2i_ASN1_UTCTIME(ASN1_UTCTIME **a, const unsigned char **in, long len); int i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **out); extern const ASN1_ITEM ASN1_UTCTIME_it;
ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_new(void); void ASN1_GENERALIZEDTIME_free(ASN1_GENERALIZEDTIME *a); ASN1_GENERALIZEDTIME *d2i_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME **a, const unsigned char **in, long len); int i2d_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME *a, unsigned char **out); extern const ASN1_ITEM ASN1_GENERALIZEDTIME_it;
ASN1_TIME *ASN1_TIME_new(void); void ASN1_TIME_free(ASN1_TIME *a); ASN1_TIME *d2i_ASN1_TIME(ASN1_TIME **a, const unsigned char **in, long len); int i2d_ASN1_TIME(ASN1_TIME *a, unsigned char **out); extern const ASN1_ITEM ASN1_TIME_it;

extern const ASN1_ITEM ASN1_OCTET_STRING_NDEF_it;

ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);
ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t,
                         int offset_day, long offset_sec);
int ASN1_TIME_check(const ASN1_TIME *t);
ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,
                                                   ASN1_GENERALIZEDTIME **out);
int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str);
int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm);
int ASN1_TIME_normalize(ASN1_TIME *s);
int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t);
int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b);

int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a);

int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
                                const char *sn, const char *ln);

int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a);
int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r);
int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a);
int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r);

int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
long ASN1_INTEGER_get(const ASN1_INTEGER *a);
ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai);
BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn);

int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a);
int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r);


int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai);
BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn);



int ASN1_PRINTABLE_type(const unsigned char *s, int max);

unsigned long ASN1_tag2bit(int tag);


int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
                    int *pclass, long omax);
int ASN1_check_infinite_end(unsigned char **p, long len);
int ASN1_const_check_infinite_end(const unsigned char **p, long len);
void ASN1_put_object(unsigned char **pp, int constructed, int length,
                     int tag, int xclass);
int ASN1_put_eoc(unsigned char **pp);
int ASN1_object_size(int constructed, int length, int tag);


void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x);
# 700 "/usr/include/openssl/asn1.h" 3 4
void *ASN1_item_dup(const ASN1_ITEM *it, void *x);
# 709 "/usr/include/openssl/asn1.h" 3 4
void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x);







void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x);
# 730 "/usr/include/openssl/asn1.h" 3 4
int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x);
int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags);


int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in);

void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x);







void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x);
int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x);
# 757 "/usr/include/openssl/asn1.h" 3 4
int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x);
int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);
int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);
int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a);
int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);
int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);
int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off);
int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
                  unsigned char *buf, int off);
int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent);
int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
                    int dump);
const char *ASN1_tag2str(int tag);



int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s);

int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len);
int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len);
int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num,
                                  unsigned char *data, int len);
int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num,
                                  unsigned char *data, int max_len);

void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it);

ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it,
                            ASN1_OCTET_STRING **oct);

void ASN1_STRING_set_default_mask(unsigned long mask);
int ASN1_STRING_set_default_mask_asc(const char *p);
unsigned long ASN1_STRING_get_default_mask(void);
int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
                       int inform, unsigned long mask);
int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
                        int inform, unsigned long mask,
                        long minsize, long maxsize);

ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out,
                                    const unsigned char *in, int inlen,
                                    int inform, int nid);
ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid);
int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
void ASN1_STRING_TABLE_cleanup(void);




ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,
                          long len, const ASN1_ITEM *it);
int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out,
                       const ASN1_ITEM *it);

void ASN1_add_oid_module(void);
void ASN1_add_stable_module(void);

ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf);
ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf);
int ASN1_str2mask(const char *str, unsigned long *pmask);
# 842 "/usr/include/openssl/asn1.h" 3 4
int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent,
                    const ASN1_ITEM *it, const ASN1_PCTX *pctx);
ASN1_PCTX *ASN1_PCTX_new(void);
void ASN1_PCTX_free(ASN1_PCTX *p);
unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p);
void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags);
unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p);
void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags);
unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p);
void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags);
unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p);
void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags);
unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p);
void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags);

ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx));
void ASN1_SCTX_free(ASN1_SCTX *p);
const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p);
const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p);
unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p);
void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data);
void *ASN1_SCTX_get_app_data(ASN1_SCTX *p);

const BIO_METHOD *BIO_f_asn1(void);

BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);

int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
                        const ASN1_ITEM *it);
int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
                              const char *hdr, const ASN1_ITEM *it);
int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
                     int ctype_nid, int econt_nid,
                     struct stack_st_X509_ALGOR *mdalgs, const ASN1_ITEM *it);
ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);
int SMIME_crlf_copy(BIO *in, BIO *out, int flags);
int SMIME_text(BIO *in, BIO *out);

const ASN1_ITEM *ASN1_ITEM_lookup(const char *name);
const ASN1_ITEM *ASN1_ITEM_get(size_t i);


}
# 16 "/usr/include/openssl/objects.h" 2 3 4
# 1 "/usr/include/openssl/objectserr.h" 1 3 4
# 19 "/usr/include/openssl/objectserr.h" 3 4
extern "C"

int ERR_load_OBJ_strings(void);
# 17 "/usr/include/openssl/objects.h" 2 3 4
# 32 "/usr/include/openssl/objects.h" 3 4
extern "C" {


typedef struct obj_name_st {
    int type;
    int alias;
    const char *name;
    const char *data;
} OBJ_NAME;



int OBJ_NAME_init(void);
int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
                       int (*cmp_func) (const char *, const char *),
                       void (*free_func) (const char *, int, const char *));
const char *OBJ_NAME_get(const char *name, int type);
int OBJ_NAME_add(const char *name, int type, const char *data);
int OBJ_NAME_remove(const char *name, int type);
void OBJ_NAME_cleanup(int type);
void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
                     void *arg);
void OBJ_NAME_do_all_sorted(int type,
                            void (*fn) (const OBJ_NAME *, void *arg),
                            void *arg);

ASN1_OBJECT *OBJ_dup(const ASN1_OBJECT *o);
ASN1_OBJECT *OBJ_nid2obj(int n);
const char *OBJ_nid2ln(int n);
const char *OBJ_nid2sn(int n);
int OBJ_obj2nid(const ASN1_OBJECT *o);
ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name);
int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name);
int OBJ_txt2nid(const char *s);
int OBJ_ln2nid(const char *s);
int OBJ_sn2nid(const char *s);
int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b);
const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
                         int (*cmp) (const void *, const void *));
const void *OBJ_bsearch_ex_(const void *key, const void *base, int num,
                            int size,
                            int (*cmp) (const void *, const void *),
                            int flags);
# 155 "/usr/include/openssl/objects.h" 3 4
int OBJ_new_nid(int num);
int OBJ_add_object(const ASN1_OBJECT *obj);
int OBJ_create(const char *oid, const char *sn, const char *ln);



int OBJ_create_objects(BIO *in);

size_t OBJ_length(const ASN1_OBJECT *obj);
const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj);

int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid);
int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid);
int OBJ_add_sigid(int signid, int dig_id, int pkey_id);
void OBJ_sigid_free(void);



}
# 29 "/usr/include/openssl/evp.h" 2 3 4
# 67 "/usr/include/openssl/evp.h" 3 4
extern "C" {
# 76 "/usr/include/openssl/evp.h" 3 4
EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type);
EVP_MD *EVP_MD_meth_dup(const EVP_MD *md);
void EVP_MD_meth_free(EVP_MD *md);

int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize);
int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize);
int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize);
int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags);
int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx));
int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
                                                     const void *data,
                                                     size_t count));
int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
                                                   unsigned char *md));
int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
                                                 const EVP_MD_CTX *from));
int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx));
int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
                                                 int p1, void *p2));

int EVP_MD_meth_get_input_blocksize(const EVP_MD *md);
int EVP_MD_meth_get_result_size(const EVP_MD *md);
int EVP_MD_meth_get_app_datasize(const EVP_MD *md);
unsigned long EVP_MD_meth_get_flags(const EVP_MD *md);
int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx);
int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
                                                const void *data,
                                                size_t count);
int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
                                               unsigned char *md);
int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
                                              const EVP_MD_CTX *from);
int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx);
int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
                                              int p1, void *p2);
# 185 "/usr/include/openssl/evp.h" 3 4
EVP_CIPHER *EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len);
EVP_CIPHER *EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher);
void EVP_CIPHER_meth_free(EVP_CIPHER *cipher);

int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len);
int EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags);
int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size);
int EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher,
                             int (*init) (EVP_CIPHER_CTX *ctx,
                                          const unsigned char *key,
                                          const unsigned char *iv,
                                          int enc));
int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher,
                                  int (*do_cipher) (EVP_CIPHER_CTX *ctx,
                                                    unsigned char *out,
                                                    const unsigned char *in,
                                                    size_t inl));
int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher,
                                int (*cleanup) (EVP_CIPHER_CTX *));
int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher,
                                        int (*set_asn1_parameters) (EVP_CIPHER_CTX *,
                                                                    ASN1_TYPE *));
int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher,
                                        int (*get_asn1_parameters) (EVP_CIPHER_CTX *,
                                                                    ASN1_TYPE *));
int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher,
                             int (*ctrl) (EVP_CIPHER_CTX *, int type,
                                          int arg, void *ptr));

int (*EVP_CIPHER_meth_get_init(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
                                                          const unsigned char *key,
                                                          const unsigned char *iv,
                                                          int enc);
int (*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
                                                               unsigned char *out,
                                                               const unsigned char *in,
                                                               size_t inl);
int (*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *);
int (*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
                                                                     ASN1_TYPE *);
int (*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
                                                               ASN1_TYPE *);
int (*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
                                                          int type, int arg,
                                                          void *ptr);
# 366 "/usr/include/openssl/evp.h" 3 4
typedef struct {
    unsigned char *out;
    const unsigned char *inp;
    size_t len;
    unsigned int interleave;
} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM;
# 396 "/usr/include/openssl/evp.h" 3 4
typedef struct evp_cipher_info_st {
    const EVP_CIPHER *cipher;
    unsigned char iv[16];
} EVP_CIPHER_INFO;



typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass,
                              int passlen, ASN1_TYPE *param,
                              const EVP_CIPHER *cipher, const EVP_MD *md,
                              int en_de);
# 443 "/usr/include/openssl/evp.h" 3 4
int EVP_MD_type(const EVP_MD *md);


int EVP_MD_pkey_type(const EVP_MD *md);
int EVP_MD_size(const EVP_MD *md);
int EVP_MD_block_size(const EVP_MD *md);
unsigned long EVP_MD_flags(const EVP_MD *md);

const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
                                             const void *data, size_t count);
void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
                              int (*update) (EVP_MD_CTX *ctx,
                                             const void *data, size_t count));



EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx);
void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx);
void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx);

int EVP_CIPHER_nid(const EVP_CIPHER *cipher);

int EVP_CIPHER_block_size(const EVP_CIPHER *cipher);
int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *cipher);
int EVP_CIPHER_key_length(const EVP_CIPHER *cipher);
int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher);
unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher);


const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx);
const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx);
const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx);
unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx);
unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx);
int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx);
void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num);
int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);
void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx);
void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data);
# 524 "/usr/include/openssl/evp.h" 3 4
           int EVP_Cipher(EVP_CIPHER_CTX *c,
                          unsigned char *out,
                          const unsigned char *in, unsigned int inl);
# 537 "/usr/include/openssl/evp.h" 3 4
int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
EVP_MD_CTX *EVP_MD_CTX_new(void);
int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
void EVP_MD_CTX_free(EVP_MD_CTX *ctx);



 int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in);
void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags);
 int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type,
                                 ENGINE *impl);
 int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d,
                                size_t cnt);
 int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
                                  unsigned int *s);
 int EVP_Digest(const void *data, size_t count,
                          unsigned char *md, unsigned int *size,
                          const EVP_MD *type, ENGINE *impl);

 int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in);
 int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
 int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md,
                           unsigned int *s);
 int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md,
                              size_t len);

int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify);
int EVP_read_pw_string_min(char *buf, int minlen, int maxlen,
                           const char *prompt, int verify);
void EVP_set_pw_prompt(const char *prompt);
char *EVP_get_pw_prompt(void);

 int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
                          const unsigned char *salt,
                          const unsigned char *data, int datal, int count,
                          unsigned char *key, unsigned char *iv);

void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags);
void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags);
int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags);

 int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
                           const unsigned char *key, const unsigned char *iv);
           int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,
                                  const EVP_CIPHER *cipher, ENGINE *impl,
                                  const unsigned char *key,
                                  const unsigned char *iv);
           int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
                                 int *outl, const unsigned char *in, int inl);
           int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out,
                                   int *outl);
           int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out,
                                int *outl);

 int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
                           const unsigned char *key, const unsigned char *iv);
           int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,
                                  const EVP_CIPHER *cipher, ENGINE *impl,
                                  const unsigned char *key,
                                  const unsigned char *iv);
           int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
                                 int *outl, const unsigned char *in, int inl);
 int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
                            int *outl);
           int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
                                   int *outl);

 int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
                          const unsigned char *key, const unsigned char *iv,
                          int enc);
           int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,
                                 const EVP_CIPHER *cipher, ENGINE *impl,
                                 const unsigned char *key,
                                 const unsigned char *iv, int enc);
 int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
                            int *outl, const unsigned char *in, int inl);
 int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
                           int *outl);
 int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
                              int *outl);

 int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
                         EVP_PKEY *pkey);

 int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret,
                          size_t *siglen, const unsigned char *tbs,
                          size_t tbslen);

 int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
                           unsigned int siglen, EVP_PKEY *pkey);

 int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret,
                            size_t siglen, const unsigned char *tbs,
                            size_t tbslen);

           int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
                                  const EVP_MD *type, ENGINE *e,
                                  EVP_PKEY *pkey);
 int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
                               size_t *siglen);

 int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
                                const EVP_MD *type, ENGINE *e,
                                EVP_PKEY *pkey);
 int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
                                 size_t siglen);


 int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                        const unsigned char *ek, int ekl,
                        const unsigned char *iv, EVP_PKEY *priv);
 int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);

 int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
                        unsigned char **ek, int *ekl, unsigned char *iv,
                        EVP_PKEY **pubk, int npubk);
 int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);


EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void);
void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX *dctx, EVP_ENCODE_CTX *sctx);
int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX *ctx);
void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
                     const unsigned char *in, int inl);
void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);

void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
                     const unsigned char *in, int inl);
int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned
                    char *out, int *outl);
int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);





EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c);
void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *c);
int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad);
int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);

const BIO_METHOD *BIO_f_md(void);
const BIO_METHOD *BIO_f_base64(void);
const BIO_METHOD *BIO_f_cipher(void);
const BIO_METHOD *BIO_f_reliable(void);
 int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
                          const unsigned char *i, int enc);

const EVP_MD *EVP_md_null(void);

const EVP_MD *EVP_md2(void);


const EVP_MD *EVP_md4(void);


const EVP_MD *EVP_md5(void);
const EVP_MD *EVP_md5_sha1(void);


const EVP_MD *EVP_blake2b512(void);
const EVP_MD *EVP_blake2s256(void);

const EVP_MD *EVP_sha1(void);
const EVP_MD *EVP_sha224(void);
const EVP_MD *EVP_sha256(void);
const EVP_MD *EVP_sha384(void);
const EVP_MD *EVP_sha512(void);
const EVP_MD *EVP_sha512_224(void);
const EVP_MD *EVP_sha512_256(void);
const EVP_MD *EVP_sha3_224(void);
const EVP_MD *EVP_sha3_256(void);
const EVP_MD *EVP_sha3_384(void);
const EVP_MD *EVP_sha3_512(void);
const EVP_MD *EVP_shake128(void);
const EVP_MD *EVP_shake256(void);




const EVP_MD *EVP_ripemd160(void);


const EVP_MD *EVP_whirlpool(void);


const EVP_MD *EVP_sm3(void);

const EVP_CIPHER *EVP_enc_null(void);

const EVP_CIPHER *EVP_des_ecb(void);
const EVP_CIPHER *EVP_des_ede(void);
const EVP_CIPHER *EVP_des_ede3(void);
const EVP_CIPHER *EVP_des_ede_ecb(void);
const EVP_CIPHER *EVP_des_ede3_ecb(void);
const EVP_CIPHER *EVP_des_cfb64(void);

const EVP_CIPHER *EVP_des_cfb1(void);
const EVP_CIPHER *EVP_des_cfb8(void);
const EVP_CIPHER *EVP_des_ede_cfb64(void);

const EVP_CIPHER *EVP_des_ede3_cfb64(void);

const EVP_CIPHER *EVP_des_ede3_cfb1(void);
const EVP_CIPHER *EVP_des_ede3_cfb8(void);
const EVP_CIPHER *EVP_des_ofb(void);
const EVP_CIPHER *EVP_des_ede_ofb(void);
const EVP_CIPHER *EVP_des_ede3_ofb(void);
const EVP_CIPHER *EVP_des_cbc(void);
const EVP_CIPHER *EVP_des_ede_cbc(void);
const EVP_CIPHER *EVP_des_ede3_cbc(void);
const EVP_CIPHER *EVP_desx_cbc(void);
const EVP_CIPHER *EVP_des_ede3_wrap(void);







const EVP_CIPHER *EVP_rc4(void);
const EVP_CIPHER *EVP_rc4_40(void);

const EVP_CIPHER *EVP_rc4_hmac_md5(void);



const EVP_CIPHER *EVP_idea_ecb(void);
const EVP_CIPHER *EVP_idea_cfb64(void);

const EVP_CIPHER *EVP_idea_ofb(void);
const EVP_CIPHER *EVP_idea_cbc(void);


const EVP_CIPHER *EVP_rc2_ecb(void);
const EVP_CIPHER *EVP_rc2_cbc(void);
const EVP_CIPHER *EVP_rc2_40_cbc(void);
const EVP_CIPHER *EVP_rc2_64_cbc(void);
const EVP_CIPHER *EVP_rc2_cfb64(void);

const EVP_CIPHER *EVP_rc2_ofb(void);


const EVP_CIPHER *EVP_bf_ecb(void);
const EVP_CIPHER *EVP_bf_cbc(void);
const EVP_CIPHER *EVP_bf_cfb64(void);

const EVP_CIPHER *EVP_bf_ofb(void);


const EVP_CIPHER *EVP_cast5_ecb(void);
const EVP_CIPHER *EVP_cast5_cbc(void);
const EVP_CIPHER *EVP_cast5_cfb64(void);

const EVP_CIPHER *EVP_cast5_ofb(void);


const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void);

const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);

const EVP_CIPHER *EVP_aes_128_ecb(void);
const EVP_CIPHER *EVP_aes_128_cbc(void);
const EVP_CIPHER *EVP_aes_128_cfb1(void);
const EVP_CIPHER *EVP_aes_128_cfb8(void);
const EVP_CIPHER *EVP_aes_128_cfb128(void);

const EVP_CIPHER *EVP_aes_128_ofb(void);
const EVP_CIPHER *EVP_aes_128_ctr(void);
const EVP_CIPHER *EVP_aes_128_ccm(void);
const EVP_CIPHER *EVP_aes_128_gcm(void);
const EVP_CIPHER *EVP_aes_128_xts(void);
const EVP_CIPHER *EVP_aes_128_wrap(void);
const EVP_CIPHER *EVP_aes_128_wrap_pad(void);

const EVP_CIPHER *EVP_aes_128_ocb(void);

const EVP_CIPHER *EVP_aes_192_ecb(void);
const EVP_CIPHER *EVP_aes_192_cbc(void);
const EVP_CIPHER *EVP_aes_192_cfb1(void);
const EVP_CIPHER *EVP_aes_192_cfb8(void);
const EVP_CIPHER *EVP_aes_192_cfb128(void);

const EVP_CIPHER *EVP_aes_192_ofb(void);
const EVP_CIPHER *EVP_aes_192_ctr(void);
const EVP_CIPHER *EVP_aes_192_ccm(void);
const EVP_CIPHER *EVP_aes_192_gcm(void);
const EVP_CIPHER *EVP_aes_192_wrap(void);
const EVP_CIPHER *EVP_aes_192_wrap_pad(void);

const EVP_CIPHER *EVP_aes_192_ocb(void);

const EVP_CIPHER *EVP_aes_256_ecb(void);
const EVP_CIPHER *EVP_aes_256_cbc(void);
const EVP_CIPHER *EVP_aes_256_cfb1(void);
const EVP_CIPHER *EVP_aes_256_cfb8(void);
const EVP_CIPHER *EVP_aes_256_cfb128(void);

const EVP_CIPHER *EVP_aes_256_ofb(void);
const EVP_CIPHER *EVP_aes_256_ctr(void);
const EVP_CIPHER *EVP_aes_256_ccm(void);
const EVP_CIPHER *EVP_aes_256_gcm(void);
const EVP_CIPHER *EVP_aes_256_xts(void);
const EVP_CIPHER *EVP_aes_256_wrap(void);
const EVP_CIPHER *EVP_aes_256_wrap_pad(void);

const EVP_CIPHER *EVP_aes_256_ocb(void);

const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void);
const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void);
const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void);
const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void);

const EVP_CIPHER *EVP_aria_128_ecb(void);
const EVP_CIPHER *EVP_aria_128_cbc(void);
const EVP_CIPHER *EVP_aria_128_cfb1(void);
const EVP_CIPHER *EVP_aria_128_cfb8(void);
const EVP_CIPHER *EVP_aria_128_cfb128(void);

const EVP_CIPHER *EVP_aria_128_ctr(void);
const EVP_CIPHER *EVP_aria_128_ofb(void);
const EVP_CIPHER *EVP_aria_128_gcm(void);
const EVP_CIPHER *EVP_aria_128_ccm(void);
const EVP_CIPHER *EVP_aria_192_ecb(void);
const EVP_CIPHER *EVP_aria_192_cbc(void);
const EVP_CIPHER *EVP_aria_192_cfb1(void);
const EVP_CIPHER *EVP_aria_192_cfb8(void);
const EVP_CIPHER *EVP_aria_192_cfb128(void);

const EVP_CIPHER *EVP_aria_192_ctr(void);
const EVP_CIPHER *EVP_aria_192_ofb(void);
const EVP_CIPHER *EVP_aria_192_gcm(void);
const EVP_CIPHER *EVP_aria_192_ccm(void);
const EVP_CIPHER *EVP_aria_256_ecb(void);
const EVP_CIPHER *EVP_aria_256_cbc(void);
const EVP_CIPHER *EVP_aria_256_cfb1(void);
const EVP_CIPHER *EVP_aria_256_cfb8(void);
const EVP_CIPHER *EVP_aria_256_cfb128(void);

const EVP_CIPHER *EVP_aria_256_ctr(void);
const EVP_CIPHER *EVP_aria_256_ofb(void);
const EVP_CIPHER *EVP_aria_256_gcm(void);
const EVP_CIPHER *EVP_aria_256_ccm(void);


const EVP_CIPHER *EVP_camellia_128_ecb(void);
const EVP_CIPHER *EVP_camellia_128_cbc(void);
const EVP_CIPHER *EVP_camellia_128_cfb1(void);
const EVP_CIPHER *EVP_camellia_128_cfb8(void);
const EVP_CIPHER *EVP_camellia_128_cfb128(void);

const EVP_CIPHER *EVP_camellia_128_ofb(void);
const EVP_CIPHER *EVP_camellia_128_ctr(void);
const EVP_CIPHER *EVP_camellia_192_ecb(void);
const EVP_CIPHER *EVP_camellia_192_cbc(void);
const EVP_CIPHER *EVP_camellia_192_cfb1(void);
const EVP_CIPHER *EVP_camellia_192_cfb8(void);
const EVP_CIPHER *EVP_camellia_192_cfb128(void);

const EVP_CIPHER *EVP_camellia_192_ofb(void);
const EVP_CIPHER *EVP_camellia_192_ctr(void);
const EVP_CIPHER *EVP_camellia_256_ecb(void);
const EVP_CIPHER *EVP_camellia_256_cbc(void);
const EVP_CIPHER *EVP_camellia_256_cfb1(void);
const EVP_CIPHER *EVP_camellia_256_cfb8(void);
const EVP_CIPHER *EVP_camellia_256_cfb128(void);

const EVP_CIPHER *EVP_camellia_256_ofb(void);
const EVP_CIPHER *EVP_camellia_256_ctr(void);


const EVP_CIPHER *EVP_chacha20(void);

const EVP_CIPHER *EVP_chacha20_poly1305(void);




const EVP_CIPHER *EVP_seed_ecb(void);
const EVP_CIPHER *EVP_seed_cbc(void);
const EVP_CIPHER *EVP_seed_cfb128(void);

const EVP_CIPHER *EVP_seed_ofb(void);
# 965 "/usr/include/openssl/evp.h" 3 4
int EVP_add_cipher(const EVP_CIPHER *cipher);
int EVP_add_digest(const EVP_MD *digest);

const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
const EVP_MD *EVP_get_digestbyname(const char *name);

void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph,
                                   const char *from, const char *to, void *x),
                       void *arg);
void EVP_CIPHER_do_all_sorted(void (*fn)
                               (const EVP_CIPHER *ciph, const char *from,
                                const char *to, void *x), void *arg);

void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph,
                               const char *from, const char *to, void *x),
                   void *arg);
void EVP_MD_do_all_sorted(void (*fn)
                           (const EVP_MD *ciph, const char *from,
                            const char *to, void *x), void *arg);

int EVP_PKEY_decrypt_old(unsigned char *dec_key,
                         const unsigned char *enc_key, int enc_key_len,
                         EVP_PKEY *private_key);
int EVP_PKEY_encrypt_old(unsigned char *enc_key,
                         const unsigned char *key, int key_len,
                         EVP_PKEY *pub_key);
int EVP_PKEY_type(int type);
int EVP_PKEY_id(const EVP_PKEY *pkey);
int EVP_PKEY_base_id(const EVP_PKEY *pkey);
int EVP_PKEY_bits(const EVP_PKEY *pkey);
int EVP_PKEY_security_bits(const EVP_PKEY *pkey);
int EVP_PKEY_size(const EVP_PKEY *pkey);
int EVP_PKEY_set_type(EVP_PKEY *pkey, int type);
int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len);
int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type);

int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e);
ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey);

int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key);
void *EVP_PKEY_get0(const EVP_PKEY *pkey);
const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len);

const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len);


const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len);



struct rsa_st;
int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key);
struct rsa_st *EVP_PKEY_get0_RSA(EVP_PKEY *pkey);
struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);


struct dsa_st;
int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key);
struct dsa_st *EVP_PKEY_get0_DSA(EVP_PKEY *pkey);
struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);


struct dh_st;
int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key);
struct dh_st *EVP_PKEY_get0_DH(EVP_PKEY *pkey);
struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);


struct ec_key_st;
int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key);
struct ec_key_st *EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey);
struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);


EVP_PKEY *EVP_PKEY_new(void);
int EVP_PKEY_up_ref(EVP_PKEY *pkey);
void EVP_PKEY_free(EVP_PKEY *pkey);

EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
                        long length);
int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp);

EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp,
                         long length);
EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp,
                             long length);
int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp);

int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode);
int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);

int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);

int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
                          int indent, ASN1_PCTX *pctx);
int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
                           int indent, ASN1_PCTX *pctx);
int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
                          int indent, ASN1_PCTX *pctx);

int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);

int EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY *pkey,
                                   const unsigned char *pt, size_t ptlen);
size_t EVP_PKEY_get1_tls_encodedpoint(EVP_PKEY *pkey, unsigned char **ppt);

int EVP_CIPHER_type(const EVP_CIPHER *ctx);


int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);


int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);


int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
                       ASN1_TYPE *param, const EVP_CIPHER *cipher,
                       const EVP_MD *md, int en_de);
int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
                           const unsigned char *salt, int saltlen, int iter,
                           int keylen, unsigned char *out);
int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
                      const unsigned char *salt, int saltlen, int iter,
                      const EVP_MD *digest, int keylen, unsigned char *out);
int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
                          ASN1_TYPE *param, const EVP_CIPHER *cipher,
                          const EVP_MD *md, int en_de);


int EVP_PBE_scrypt(const char *pass, size_t passlen,
                   const unsigned char *salt, size_t saltlen,
                   uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
                   unsigned char *key, size_t keylen);

int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
                             int passlen, ASN1_TYPE *param,
                             const EVP_CIPHER *c, const EVP_MD *md, int en_de);


void PKCS5_PBE_add(void);

int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
                       ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
# 1122 "/usr/include/openssl/evp.h" 3 4
int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid,
                         int md_nid, EVP_PBE_KEYGEN *keygen);
int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
                    EVP_PBE_KEYGEN *keygen);
int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid,
                 EVP_PBE_KEYGEN **pkeygen);
void EVP_PBE_cleanup(void);
int EVP_PBE_get(int *ptype, int *ppbe_nid, size_t num);
# 1145 "/usr/include/openssl/evp.h" 3 4
int EVP_PKEY_asn1_get_count(void);
const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx);
const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type);
const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
                                                   const char *str, int len);
int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth);
int EVP_PKEY_asn1_add_alias(int to, int from);
int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id,
                            int *ppkey_flags, const char **pinfo,
                            const char **ppem_str,
                            const EVP_PKEY_ASN1_METHOD *ameth);

const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey);
EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
                                        const char *pem_str,
                                        const char *info);
void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
                        const EVP_PKEY_ASN1_METHOD *src);
void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth);
void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
                              int (*pub_decode) (EVP_PKEY *pk,
                                                 X509_PUBKEY *pub),
                              int (*pub_encode) (X509_PUBKEY *pub,
                                                 const EVP_PKEY *pk),
                              int (*pub_cmp) (const EVP_PKEY *a,
                                              const EVP_PKEY *b),
                              int (*pub_print) (BIO *out,
                                                const EVP_PKEY *pkey,
                                                int indent, ASN1_PCTX *pctx),
                              int (*pkey_size) (const EVP_PKEY *pk),
                              int (*pkey_bits) (const EVP_PKEY *pk));
void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
                               int (*priv_decode) (EVP_PKEY *pk,
                                                   const PKCS8_PRIV_KEY_INFO
                                                   *p8inf),
                               int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8,
                                                   const EVP_PKEY *pk),
                               int (*priv_print) (BIO *out,
                                                  const EVP_PKEY *pkey,
                                                  int indent,
                                                  ASN1_PCTX *pctx));
void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
                             int (*param_decode) (EVP_PKEY *pkey,
                                                  const unsigned char **pder,
                                                  int derlen),
                             int (*param_encode) (const EVP_PKEY *pkey,
                                                  unsigned char **pder),
                             int (*param_missing) (const EVP_PKEY *pk),
                             int (*param_copy) (EVP_PKEY *to,
                                                const EVP_PKEY *from),
                             int (*param_cmp) (const EVP_PKEY *a,
                                               const EVP_PKEY *b),
                             int (*param_print) (BIO *out,
                                                 const EVP_PKEY *pkey,
                                                 int indent,
                                                 ASN1_PCTX *pctx));

void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
                            void (*pkey_free) (EVP_PKEY *pkey));
void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
                            int (*pkey_ctrl) (EVP_PKEY *pkey, int op,
                                              long arg1, void *arg2));
void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth,
                            int (*item_verify) (EVP_MD_CTX *ctx,
                                                const ASN1_ITEM *it,
                                                void *asn,
                                                X509_ALGOR *a,
                                                ASN1_BIT_STRING *sig,
                                                EVP_PKEY *pkey),
                            int (*item_sign) (EVP_MD_CTX *ctx,
                                              const ASN1_ITEM *it,
                                              void *asn,
                                              X509_ALGOR *alg1,
                                              X509_ALGOR *alg2,
                                              ASN1_BIT_STRING *sig));

void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD *ameth,
                              int (*siginf_set) (X509_SIG_INFO *siginf,
                                                 const X509_ALGOR *alg,
                                                 const ASN1_STRING *sig));

void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth,
                             int (*pkey_check) (const EVP_PKEY *pk));

void EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth,
                                    int (*pkey_pub_check) (const EVP_PKEY *pk));

void EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth,
                                   int (*pkey_param_check) (const EVP_PKEY *pk));

void EVP_PKEY_asn1_set_set_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
                                    int (*set_priv_key) (EVP_PKEY *pk,
                                                         const unsigned char
                                                            *priv,
                                                         size_t len));
void EVP_PKEY_asn1_set_set_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
                                   int (*set_pub_key) (EVP_PKEY *pk,
                                                       const unsigned char *pub,
                                                       size_t len));
void EVP_PKEY_asn1_set_get_priv_key(EVP_PKEY_ASN1_METHOD *ameth,
                                    int (*get_priv_key) (const EVP_PKEY *pk,
                                                         unsigned char *priv,
                                                         size_t *len));
void EVP_PKEY_asn1_set_get_pub_key(EVP_PKEY_ASN1_METHOD *ameth,
                                   int (*get_pub_key) (const EVP_PKEY *pk,
                                                       unsigned char *pub,
                                                       size_t *len));

void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
                                     int (*pkey_security_bits) (const EVP_PKEY
                                                                *pk));
# 1330 "/usr/include/openssl/evp.h" 3 4
const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
                             const EVP_PKEY_METHOD *meth);
void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src);
void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth);
size_t EVP_PKEY_meth_get_count(void);
const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx);

EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx);
void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);

int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
                      int cmd, int p1, void *p2);
int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
                          const char *value);
int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype,
                             int cmd, uint64_t value);

int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str);
int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex);

int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md);

int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx);
void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen);

EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
                               const unsigned char *key, int keylen);
EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e,
                                       const unsigned char *priv,
                                       size_t len);
EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e,
                                      const unsigned char *pub,
                                      size_t len);
int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv,
                                 size_t *len);
int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub,
                                size_t *len);

EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv,
                                size_t len, const EVP_CIPHER *cipher);

void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data);
void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx);
EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx);

EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx);

void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);

int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
                  unsigned char *sig, size_t *siglen,
                  const unsigned char *tbs, size_t tbslen);
int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
                    const unsigned char *sig, size_t siglen,
                    const unsigned char *tbs, size_t tbslen);
int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
                            unsigned char *rout, size_t *routlen,
                            const unsigned char *sig, size_t siglen);
int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
                     unsigned char *out, size_t *outlen,
                     const unsigned char *in, size_t inlen);
int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
                     unsigned char *out, size_t *outlen,
                     const unsigned char *in, size_t inlen);

int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);

typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);

int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
int EVP_PKEY_check(EVP_PKEY_CTX *ctx);
int EVP_PKEY_public_check(EVP_PKEY_CTX *ctx);
int EVP_PKEY_param_check(EVP_PKEY_CTX *ctx);

void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);

int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);

void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
                            int (*init) (EVP_PKEY_CTX *ctx));

void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
                            int (*copy) (EVP_PKEY_CTX *dst,
                                         EVP_PKEY_CTX *src));

void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
                               void (*cleanup) (EVP_PKEY_CTX *ctx));

void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
                                int (*paramgen_init) (EVP_PKEY_CTX *ctx),
                                int (*paramgen) (EVP_PKEY_CTX *ctx,
                                                 EVP_PKEY *pkey));

void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
                              int (*keygen_init) (EVP_PKEY_CTX *ctx),
                              int (*keygen) (EVP_PKEY_CTX *ctx,
                                             EVP_PKEY *pkey));

void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
                            int (*sign_init) (EVP_PKEY_CTX *ctx),
                            int (*sign) (EVP_PKEY_CTX *ctx,
                                         unsigned char *sig, size_t *siglen,
                                         const unsigned char *tbs,
                                         size_t tbslen));

void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
                              int (*verify_init) (EVP_PKEY_CTX *ctx),
                              int (*verify) (EVP_PKEY_CTX *ctx,
                                             const unsigned char *sig,
                                             size_t siglen,
                                             const unsigned char *tbs,
                                             size_t tbslen));

void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
                                      int (*verify_recover_init) (EVP_PKEY_CTX
                                                                  *ctx),
                                      int (*verify_recover) (EVP_PKEY_CTX
                                                             *ctx,
                                                             unsigned char
                                                             *sig,
                                                             size_t *siglen,
                                                             const unsigned
                                                             char *tbs,
                                                             size_t tbslen));

void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
                               int (*signctx_init) (EVP_PKEY_CTX *ctx,
                                                    EVP_MD_CTX *mctx),
                               int (*signctx) (EVP_PKEY_CTX *ctx,
                                               unsigned char *sig,
                                               size_t *siglen,
                                               EVP_MD_CTX *mctx));

void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
                                 int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
                                                        EVP_MD_CTX *mctx),
                                 int (*verifyctx) (EVP_PKEY_CTX *ctx,
                                                   const unsigned char *sig,
                                                   int siglen,
                                                   EVP_MD_CTX *mctx));

void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
                               int (*encrypt_init) (EVP_PKEY_CTX *ctx),
                               int (*encryptfn) (EVP_PKEY_CTX *ctx,
                                                 unsigned char *out,
                                                 size_t *outlen,
                                                 const unsigned char *in,
                                                 size_t inlen));

void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
                               int (*decrypt_init) (EVP_PKEY_CTX *ctx),
                               int (*decrypt) (EVP_PKEY_CTX *ctx,
                                               unsigned char *out,
                                               size_t *outlen,
                                               const unsigned char *in,
                                               size_t inlen));

void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
                              int (*derive_init) (EVP_PKEY_CTX *ctx),
                              int (*derive) (EVP_PKEY_CTX *ctx,
                                             unsigned char *key,
                                             size_t *keylen));

void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
                            int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
                                         void *p2),
                            int (*ctrl_str) (EVP_PKEY_CTX *ctx,
                                             const char *type,
                                             const char *value));

void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth,
                             int (*check) (EVP_PKEY *pkey));

void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth,
                                    int (*check) (EVP_PKEY *pkey));

void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth,
                                   int (*check) (EVP_PKEY *pkey));

void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD *pmeth,
                                     int (*digest_custom) (EVP_PKEY_CTX *ctx,
                                                           EVP_MD_CTX *mctx));

void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth,
                            int (**pinit) (EVP_PKEY_CTX *ctx));

void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth,
                            int (**pcopy) (EVP_PKEY_CTX *dst,
                                           EVP_PKEY_CTX *src));

void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth,
                               void (**pcleanup) (EVP_PKEY_CTX *ctx));

void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth,
                                int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
                                int (**pparamgen) (EVP_PKEY_CTX *ctx,
                                                   EVP_PKEY *pkey));

void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth,
                              int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
                              int (**pkeygen) (EVP_PKEY_CTX *ctx,
                                               EVP_PKEY *pkey));

void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD *pmeth,
                            int (**psign_init) (EVP_PKEY_CTX *ctx),
                            int (**psign) (EVP_PKEY_CTX *ctx,
                                           unsigned char *sig, size_t *siglen,
                                           const unsigned char *tbs,
                                           size_t tbslen));

void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD *pmeth,
                              int (**pverify_init) (EVP_PKEY_CTX *ctx),
                              int (**pverify) (EVP_PKEY_CTX *ctx,
                                               const unsigned char *sig,
                                               size_t siglen,
                                               const unsigned char *tbs,
                                               size_t tbslen));

void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD *pmeth,
                                      int (**pverify_recover_init) (EVP_PKEY_CTX
                                                                    *ctx),
                                      int (**pverify_recover) (EVP_PKEY_CTX
                                                               *ctx,
                                                               unsigned char
                                                               *sig,
                                                               size_t *siglen,
                                                               const unsigned
                                                               char *tbs,
                                                               size_t tbslen));

void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD *pmeth,
                               int (**psignctx_init) (EVP_PKEY_CTX *ctx,
                                                      EVP_MD_CTX *mctx),
                               int (**psignctx) (EVP_PKEY_CTX *ctx,
                                                 unsigned char *sig,
                                                 size_t *siglen,
                                                 EVP_MD_CTX *mctx));

void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD *pmeth,
                                 int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
                                                          EVP_MD_CTX *mctx),
                                 int (**pverifyctx) (EVP_PKEY_CTX *ctx,
                                                     const unsigned char *sig,
                                                     int siglen,
                                                     EVP_MD_CTX *mctx));

void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD *pmeth,
                               int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
                               int (**pencryptfn) (EVP_PKEY_CTX *ctx,
                                                   unsigned char *out,
                                                   size_t *outlen,
                                                   const unsigned char *in,
                                                   size_t inlen));

void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD *pmeth,
                               int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
                               int (**pdecrypt) (EVP_PKEY_CTX *ctx,
                                                 unsigned char *out,
                                                 size_t *outlen,
                                                 const unsigned char *in,
                                                 size_t inlen));

void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth,
                              int (**pderive_init) (EVP_PKEY_CTX *ctx),
                              int (**pderive) (EVP_PKEY_CTX *ctx,
                                               unsigned char *key,
                                               size_t *keylen));

void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD *pmeth,
                            int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
                                           void *p2),
                            int (**pctrl_str) (EVP_PKEY_CTX *ctx,
                                               const char *type,
                                               const char *value));

void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth,
                             int (**pcheck) (EVP_PKEY *pkey));

void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth,
                                    int (**pcheck) (EVP_PKEY *pkey));

void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth,
                                   int (**pcheck) (EVP_PKEY *pkey));

void EVP_PKEY_meth_get_digest_custom(EVP_PKEY_METHOD *pmeth,
                                     int (**pdigest_custom) (EVP_PKEY_CTX *ctx,
                                                             EVP_MD_CTX *mctx));
void EVP_add_alg_module(void);



}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 2

# 1 "/usr/include/openssl/hmac.h" 1 3 4
# 13 "/usr/include/openssl/hmac.h" 3 4
# 1 "/usr/include/openssl/opensslconf.h" 1 3 4
# 42 "/usr/include/openssl/opensslconf.h" 3 4
# 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
# 23 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
extern "C" {
# 197 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
}
# 43 "/usr/include/openssl/opensslconf.h" 2 3 4
# 14 "/usr/include/openssl/hmac.h" 2 3 4
# 22 "/usr/include/openssl/hmac.h" 3 4
extern "C" {


size_t HMAC_size(const HMAC_CTX *e);
HMAC_CTX *HMAC_CTX_new(void);
int HMAC_CTX_reset(HMAC_CTX *ctx);
void HMAC_CTX_free(HMAC_CTX *ctx);

int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md) __attribute__ ((deprecated));


           int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
                            const EVP_MD *md, ENGINE *impl);
           int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data,
                           size_t len);
           int HMAC_Final(HMAC_CTX *ctx, unsigned char *md,
                          unsigned int *len);
unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
                    const unsigned char *d, size_t n, unsigned char *md,
                    unsigned int *md_len);
 int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);

void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);


}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 2


# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h"
extern "C" {
  const EVP_MD *EVP_md5(void);
  const EVP_MD *EVP_sha1(void);
  const EVP_MD *EVP_sha256(void);
}


namespace ceph {
  namespace crypto {
    void assert_init();
    void init(CephContext *cct);
    void shutdown(bool shared=true);
  }
}


namespace ceph {
  namespace crypto {

    class DigestException : public std::runtime_error
    {
    public:
      DigestException(const char* what_arg) : runtime_error(what_arg)
 {}
    };

    namespace nss {

      class NSSDigest {
      private:
        PK11Context *ctx;
        size_t digest_size;
      public:
        NSSDigest (SECOidTag _type, size_t _digest_size)
   : digest_size(_digest_size) {
   ctx = PK11_CreateDigestContext(_type);
   if (! ctx) {
     throw DigestException("PK11_CreateDigestContext() failed");
   }
   Restart();
        }
        ~NSSDigest () {
   PK11_DestroyContext(ctx, 1);
 }
 void Restart() {
   SECStatus s;
   s = PK11_DigestBegin(ctx);
   if (s != SECSuccess) {
     throw DigestException("PK11_DigestBegin() failed");
   }
 }
 void Update (const unsigned char *input, size_t length) {
   if (length) {
     SECStatus s;
     s = PK11_DigestOp(ctx, input, length);
     if (s != SECSuccess) {
       throw DigestException("PK11_DigestOp() failed");
     }
   }
 }
 void Final (unsigned char *digest) {
   SECStatus s;
   unsigned int dummy;
   s = PK11_DigestFinal(ctx, digest, &dummy, digest_size);
   if (! (s == SECSuccess) &&
       (dummy == digest_size)) {
     throw DigestException("PK11_DigestFinal() failed");
   }
   Restart();
 }
      };

      class MD5 : public NSSDigest {
      public:
 MD5 () : NSSDigest(SEC_OID_MD5, 16) { }
      };

      class SHA1 : public NSSDigest {
      public:
        SHA1 () : NSSDigest(SEC_OID_SHA1, 20) { }
      };

      class SHA256 : public NSSDigest {
      public:
        SHA256 () : NSSDigest(SEC_OID_SHA256, 32) { }
      };
    }
  }
}



namespace ceph {
  namespace crypto {
    namespace ssl {
      class OpenSSLDigest {
      private:
 EVP_MD_CTX *mpContext;
 const EVP_MD *mpType;
      public:
 OpenSSLDigest (const EVP_MD *_type);
 ~OpenSSLDigest ();
 void Restart();
 void Update (const unsigned char *input, size_t length);
 void Final (unsigned char *digest);
      };

      class MD5 : public OpenSSLDigest {
      public:
 MD5 () : OpenSSLDigest(EVP_md5()) { }
      };

      class SHA1 : public OpenSSLDigest {
      public:
        SHA1 () : OpenSSLDigest(EVP_sha1()) { }
      };

      class SHA256 : public OpenSSLDigest {
      public:
        SHA256 () : OpenSSLDigest(EVP_sha256()) { }
      };
    }
  }
}




namespace ceph {
  namespace crypto::nss {
    class HMAC {
    private:
      PK11SlotInfo *slot;
      PK11SymKey *symkey;
      PK11Context *ctx;
      unsigned int digest_size;
    public:
      HMAC (CK_MECHANISM_TYPE cktype, unsigned int digestsize, const unsigned char *key, size_t length) {
        digest_size = digestsize;
 slot = PK11_GetBestSlot(cktype, 
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 3 4
                                __null
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h"
                                    );
 if (! slot) {
   throw DigestException("PK11_GetBestSlot() failed");
 }
 SECItem keyItem;
 keyItem.type = siBuffer;
 keyItem.data = (unsigned char*)key;
 keyItem.len = length;
 symkey = PK11_ImportSymKey(slot, cktype, PK11_OriginUnwrap,
       0x00000108, &keyItem, 
# 180 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 3 4
                           __null
# 180 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h"
                               );
 if (! symkey) {
   throw DigestException("PK11_ImportSymKey() failed");
 }
 SECItem param;
 param.type = siBuffer;
 param.data = 
# 186 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h" 3 4
             __null
# 186 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h"
                 ;
 param.len = 0;
 ctx = PK11_CreateContextBySymKey(cktype, 0x00000108, symkey, &param);
 if (! ctx) {
   throw DigestException("PK11_CreateContextBySymKey() failed");
 }
 Restart();
      }
      ~HMAC ();
      void Restart() {
 SECStatus s;
 s = PK11_DigestBegin(ctx);
 if (s != SECSuccess) {
   throw DigestException("PK11_DigestBegin() failed");
 }
      }
      void Update (const unsigned char *input, size_t length) {
 SECStatus s;
 s = PK11_DigestOp(ctx, input, length);
 if (s != SECSuccess) {
   throw DigestException("PK11_DigestOp() failed");
 }
      }
      void Final (unsigned char *digest) {
 SECStatus s;
 unsigned int dummy;
 s = PK11_DigestFinal(ctx, digest, &dummy, digest_size);
 if (! (s == SECSuccess) &&
     (dummy == digest_size)) {
   throw DigestException("PK11_DigestFinal() failed");
 }
 Restart();
      }
    };

    class HMACSHA1 : public HMAC {
    public:
      HMACSHA1 (const unsigned char *key, size_t length) : HMAC(0x00000221, 20, key, length) { }
    };

    class HMACSHA256 : public HMAC {
    public:
      HMACSHA256 (const unsigned char *key, size_t length) : HMAC(0x00000251, 32, key, length) { }
    };
  }
}



namespace ceph::crypto::ssl {
# 278 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_crypto.h"
  class HMAC {
  private:
    HMAC_CTX *mpContext;

  public:
    HMAC (const EVP_MD *type, const unsigned char *key, size_t length)
      : mpContext(HMAC_CTX_new()) {
      const auto r = HMAC_Init_ex(mpContext, key, length, type, nullptr);
      if (r != 1) {
 throw DigestException("HMAC_Init_ex() failed");
      }
    }
    ~HMAC () {
      HMAC_CTX_free(mpContext);
    }

    void Restart () {
      const EVP_MD * const type = HMAC_CTX_get_md(mpContext);
      const auto r = HMAC_Init_ex(mpContext, nullptr, 0, type, nullptr);
      if (r != 1) {
 throw DigestException("HMAC_Init_ex() failed");
      }
    }
    void Update (const unsigned char *input, size_t length) {
      if (length) {
        const auto r = HMAC_Update(mpContext, input, length);
 if (r != 1) {
   throw DigestException("HMAC_Update() failed");
 }
      }
    }
    void Final (unsigned char *digest) {
      unsigned int s;
      const auto r = HMAC_Final(mpContext, digest, &s);
      if (r != 1) {
 throw DigestException("HMAC_Final() failed");
      }
    }
  };


  struct HMACSHA1 : public HMAC {
    HMACSHA1 (const unsigned char *key, size_t length)
      : HMAC(EVP_sha1(), key, length) {
    }
  };

  struct HMACSHA256 : public HMAC {
    HMACSHA256 (const unsigned char *key, size_t length)
      : HMAC(EVP_sha256(), key, length) {
    }
  };
}




namespace ceph {
  namespace crypto {
    using ceph::crypto::ssl::SHA256;
    using ceph::crypto::ssl::MD5;
    using ceph::crypto::ssl::SHA1;

    using ceph::crypto::ssl::HMACSHA256;
    using ceph::crypto::ssl::HMACSHA1;
  }
}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref_fwd.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref_fwd.hpp" 3 4

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref_fwd.hpp" 3 4
namespace boost {

    template<typename charT, typename traits = std::char_traits<charT> > class basic_string_ref;
    typedef basic_string_ref<char, std::char_traits<char> > string_ref;
    typedef basic_string_ref<wchar_t, std::char_traits<wchar_t> > wstring_ref;


    typedef basic_string_ref<char16_t, std::char_traits<char16_t> > u16string_ref;



    typedef basic_string_ref<char32_t, std::char_traits<char32_t> > u32string_ref;


}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp" 3 4
namespace boost {

    namespace detail {

        template <typename charT, typename traits>
        class string_ref_traits_eq {
        public:
            string_ref_traits_eq ( charT ch ) : ch_(ch) {}
            bool operator () ( charT val ) const { return traits::eq ( ch_, val ); }
            charT ch_;
            };
        }

    template<typename charT, typename traits>
    class basic_string_ref {
    public:

        typedef charT value_type;
        typedef const charT* pointer;
        typedef const charT& reference;
        typedef const charT& const_reference;
        typedef pointer const_iterator;
        typedef const_iterator iterator;
        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
        typedef const_reverse_iterator reverse_iterator;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;
        static constexpr size_type npos = size_type(-1);


        constexpr basic_string_ref () noexcept
            : ptr_(__null), len_(0) {}



        constexpr basic_string_ref (const basic_string_ref &rhs) noexcept

            = default;




        basic_string_ref& operator=(const basic_string_ref &rhs) noexcept

            = default;
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp" 3 4
        basic_string_ref(const charT* str) noexcept
            : ptr_(str), len_(traits::length(str)) {}

        template<typename Allocator>
        basic_string_ref(const std::basic_string<charT, traits, Allocator>& str)
            : ptr_(str.data()), len_(str.length()) {}
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp" 3 4
        constexpr basic_string_ref(const charT* str, size_type len) noexcept
            : ptr_(str), len_(len) {}


        template<typename Allocator>
        explicit operator std::basic_string<charT, traits, Allocator>() const {
            return std::basic_string<charT, traits, Allocator> ( begin(), end());
            }


        std::basic_string<charT, traits> to_string () const {
            return std::basic_string<charT, traits> ( begin(), end());
            }


        constexpr const_iterator begin() const { return ptr_; }
        constexpr const_iterator cbegin() const { return ptr_; }
        constexpr const_iterator end() const { return ptr_ + len_; }
        constexpr const_iterator cend() const { return ptr_ + len_; }
                const_reverse_iterator rbegin() const { return const_reverse_iterator (end()); }
                const_reverse_iterator crbegin() const { return const_reverse_iterator (end()); }
                const_reverse_iterator rend() const { return const_reverse_iterator (begin()); }
                const_reverse_iterator crend() const { return const_reverse_iterator (begin()); }


        constexpr size_type size() const { return len_; }
        constexpr size_type length() const { return len_; }
        constexpr size_type max_size() const { return len_; }
        constexpr bool empty() const { return len_ == 0; }


        constexpr const charT& operator[](size_type pos) const { return ptr_[pos]; }

        const charT& at(size_t pos) const {
            if ( pos >= len_ )
                ::boost::exception_detail::throw_exception_(std::out_of_range ( "boost::string_ref::at" ),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp",137);
            return ptr_[pos];
            }

        constexpr const charT& front() const { return ptr_[0]; }
        constexpr const charT& back() const { return ptr_[len_-1]; }
        constexpr const charT* data() const { return ptr_; }


        void clear() { len_ = 0; }
        void remove_prefix(size_type n) {
            if ( n > len_ )
                n = len_;
            ptr_ += n;
            len_ -= n;
            }

        void remove_suffix(size_type n) {
            if ( n > len_ )
                n = len_;
            len_ -= n;
            }



        basic_string_ref substr(size_type pos, size_type n=npos) const {
            if ( pos > size())
                ::boost::exception_detail::throw_exception_(std::out_of_range ( "string_ref::substr" ),__PRETTY_FUNCTION__,"/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp",164);
            return basic_string_ref(data() + pos, (std::min)(size() - pos, n));
            }

        int compare(basic_string_ref x) const {
            const int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
            return cmp != 0 ? cmp : ( len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1 );
            }

        bool starts_with(charT c) const { return !empty() && traits::eq ( c, front()); }
        bool starts_with(basic_string_ref x) const {
            return len_ >= x.len_ && traits::compare ( ptr_, x.ptr_, x.len_ ) == 0;
            }

        bool ends_with(charT c) const { return !empty() && traits::eq ( c, back()); }
        bool ends_with(basic_string_ref x) const {
            return len_ >= x.len_ && traits::compare ( ptr_ + len_ - x.len_, x.ptr_, x.len_ ) == 0;
            }

        size_type find(basic_string_ref s) const {
            const_iterator iter = std::search ( this->cbegin (), this->cend (),
                                                s.cbegin (), s.cend (), traits::eq );
            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
            }

        size_type find(charT c) const {
            const_iterator iter = std::find_if ( this->cbegin (), this->cend (),
                                    detail::string_ref_traits_eq<charT, traits> ( c ));
            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
            }

        size_type rfind(basic_string_ref s) const {
            const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (),
                                                s.crbegin (), s.crend (), traits::eq );
            return iter == this->crend () ? npos : (std::distance(iter, this->crend()) - s.size());
            }

        size_type rfind(charT c) const {
            const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (),
                                    detail::string_ref_traits_eq<charT, traits> ( c ));
            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
            }

        size_type find_first_of(charT c) const { return find (c); }
        size_type find_last_of (charT c) const { return rfind (c); }

        size_type find_first_of(basic_string_ref s) const {
            const_iterator iter = std::find_first_of
                ( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
            }

        size_type find_last_of(basic_string_ref s) const {
            const_reverse_iterator iter = std::find_first_of
                ( this->crbegin (), this->crend (), s.cbegin (), s.cend (), traits::eq );
            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
            }

        size_type find_first_not_of(basic_string_ref s) const {
            const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
            return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
            }

        size_type find_first_not_of(charT c) const {
            for ( const_iterator iter = this->cbegin (); iter != this->cend (); ++iter )
                if ( !traits::eq ( c, *iter ))
                    return std::distance ( this->cbegin (), iter );
            return npos;
            }

        size_type find_last_not_of(basic_string_ref s) const {
            const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
            return iter == this->crend () ? npos : (this->size() - 1 - std::distance(this->crbegin(), iter));
            }

        size_type find_last_not_of(charT c) const {
            for ( const_reverse_iterator iter = this->crbegin (); iter != this->crend (); ++iter )
                if ( !traits::eq ( c, *iter ))
                    return this->size() - 1 - std::distance(this->crbegin(), iter);
            return npos;
            }

    private:

        template <typename Iterator>
        Iterator find_not_of ( Iterator first, Iterator last, basic_string_ref s ) const {
            for ( ; first != last ; ++first )
                if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
                    return first;
            return last;
            }



        const charT *ptr_;
        std::size_t len_;
        };




    template<typename charT, typename traits>
    inline bool operator==(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
        if ( x.size () != y.size ()) return false;
        return x.compare(y) == 0;
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator==(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
        return x == basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator==(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) == y;
        }

    template<typename charT, typename traits>
    inline bool operator==(basic_string_ref<charT, traits> x, const charT * y) {
        return x == basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline bool operator==(const charT * x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) == y;
        }


    template<typename charT, typename traits>
    inline bool operator!=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
        if ( x.size () != y.size ()) return true;
        return x.compare(y) != 0;
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator!=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
        return x != basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) != y;
        }

    template<typename charT, typename traits>
    inline bool operator!=(basic_string_ref<charT, traits> x, const charT * y) {
        return x != basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline bool operator!=(const charT * x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) != y;
        }


    template<typename charT, typename traits>
    inline bool operator<(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
        return x.compare(y) < 0;
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator<(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
        return x < basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator<(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) < y;
        }

    template<typename charT, typename traits>
    inline bool operator<(basic_string_ref<charT, traits> x, const charT * y) {
        return x < basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline bool operator<(const charT * x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) < y;
        }


    template<typename charT, typename traits>
    inline bool operator>(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
        return x.compare(y) > 0;
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator>(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
        return x > basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator>(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) > y;
        }

    template<typename charT, typename traits>
    inline bool operator>(basic_string_ref<charT, traits> x, const charT * y) {
        return x > basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline bool operator>(const charT * x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) > y;
        }


    template<typename charT, typename traits>
    inline bool operator<=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
        return x.compare(y) <= 0;
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator<=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
        return x <= basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) <= y;
        }

    template<typename charT, typename traits>
    inline bool operator<=(basic_string_ref<charT, traits> x, const charT * y) {
        return x <= basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline bool operator<=(const charT * x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) <= y;
        }


    template<typename charT, typename traits>
    inline bool operator>=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
        return x.compare(y) >= 0;
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator>=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
        return x >= basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits, typename Allocator>
    inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) >= y;
        }

    template<typename charT, typename traits>
    inline bool operator>=(basic_string_ref<charT, traits> x, const charT * y) {
        return x >= basic_string_ref<charT, traits>(y);
        }

    template<typename charT, typename traits>
    inline bool operator>=(const charT * x, basic_string_ref<charT, traits> y) {
        return basic_string_ref<charT, traits>(x) >= y;
        }

    namespace detail {

        template<class charT, class traits>
        inline void sr_insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
            enum { chunk_size = 8 };
            charT fill_chars[chunk_size];
            std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
            for (; n >= chunk_size && os.good(); n -= chunk_size)
                os.write(fill_chars, static_cast< std::size_t >(chunk_size));
            if (n > 0 && os.good())
                os.write(fill_chars, n);
            }

        template<class charT, class traits>
        void sr_insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
            const std::size_t size = str.size();
            const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
            const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
            if (!align_left) {
                detail::sr_insert_fill_chars(os, alignment_size);
                if (os.good())
                    os.write(str.data(), size);
                }
            else {
                os.write(str.data(), size);
                if (os.good())
                    detail::sr_insert_fill_chars(os, alignment_size);
                }
            }

        }


    template<class charT, class traits>
    inline std::basic_ostream<charT, traits>&
    operator<<(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
        if (os.good()) {
            const std::size_t size = str.size();
            const std::size_t w = static_cast< std::size_t >(os.width());
            if (w <= size)
                os.write(str.data(), size);
            else
                detail::sr_insert_aligned(os, str);
            os.width(0);
            }
        return os;
        }
# 541 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/string_ref.hpp" 3 4
}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/debug.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/debug.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/dout.h" 1
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/dout.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h"
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_fwd.h" 1


       








# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_fwd.h"
class ConfigProxy;
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h" 2

class CephContext;

extern CephContext *g_ceph_context;
ConfigProxy& g_conf();

extern const char *g_assert_file;
extern int g_assert_line;
extern const char *g_assert_func;
extern const char *g_assert_condition;
extern unsigned long long g_assert_thread;
extern char g_assert_thread_name[4096];
extern char g_assert_msg[8096];
extern char g_process_name[
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h" 3 4
                          255 
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h"
                                   + 1];

extern bool g_eio;
extern char g_eio_devname[1024];
extern char g_eio_path[
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h" 3 4
                      4096
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_context.h"
                              ];
extern int g_eio_error;
extern int g_eio_iotype;
extern unsigned long long g_eio_offset;
extern unsigned long long g_eio_length;

extern int note_io_error_event(
  const char *devname,
  const char *path,
  int error,
  int iotype,
  unsigned long long offset,
  unsigned long long length);
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/dout.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 1
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
# 1 "/usr/include/c++/10/any" 1 3
# 32 "/usr/include/c++/10/any" 3
       
# 33 "/usr/include/c++/10/any" 3
# 41 "/usr/include/c++/10/any" 3

# 41 "/usr/include/c++/10/any" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 54 "/usr/include/c++/10/any" 3
  class bad_any_cast : public bad_cast
  {
  public:
    virtual const char* what() const noexcept { return "bad any_cast"; }
  };

  [[gnu::noreturn]] inline void __throw_bad_any_cast()
  {

    throw bad_any_cast{};



  }
# 77 "/usr/include/c++/10/any" 3
  class any
  {

    union _Storage
    {
      constexpr _Storage() : _M_ptr{nullptr} {}


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

      void* _M_ptr;
      aligned_storage<sizeof(_M_ptr), alignof(void*)>::type _M_buffer;
    };

    template<typename _Tp, typename _Safe = is_nothrow_move_constructible<_Tp>,
      bool _Fits = (sizeof(_Tp) <= sizeof(_Storage))
     && (alignof(_Tp) <= alignof(_Storage))>
      using _Internal = std::integral_constant<bool, _Safe::value && _Fits>;

    template<typename _Tp>
      struct _Manager_internal;

    template<typename _Tp>
      struct _Manager_external;

    template<typename _Tp>
      using _Manager = conditional_t<_Internal<_Tp>::value,
         _Manager_internal<_Tp>,
         _Manager_external<_Tp>>;

    template<typename _Tp, typename _Decayed = decay_t<_Tp>>
      using _Decay = enable_if_t<!is_same<_Decayed, any>::value, _Decayed>;


    template <typename _Tp, typename... _Args,
       typename _Mgr = _Manager<_Tp>>
      void __do_emplace(_Args&&... __args)
      {
 reset();
        _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...);
 _M_manager = &_Mgr::_S_manage;
      }



    template <typename _Tp, typename _Up, typename... _Args,
       typename _Mgr = _Manager<_Tp>>
      void __do_emplace(initializer_list<_Up> __il, _Args&&... __args)
      {
 reset();
        _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...);
 _M_manager = &_Mgr::_S_manage;
      }

  public:



    constexpr any() noexcept : _M_manager(nullptr) { }


    any(const any& __other)
    {
      if (!__other.has_value())
 _M_manager = nullptr;
      else
 {
   _Arg __arg;
   __arg._M_any = this;
   __other._M_manager(_Op_clone, &__other, &__arg);
 }
    }






    any(any&& __other) noexcept
    {
      if (!__other.has_value())
 _M_manager = nullptr;
      else
 {
   _Arg __arg;
   __arg._M_any = this;
   __other._M_manager(_Op_xfer, &__other, &__arg);
 }
    }

    template <typename _Res, typename _Tp, typename... _Args>
    using __any_constructible =
      enable_if<__and_<is_copy_constructible<_Tp>,
    is_constructible<_Tp, _Args...>>::value,
    _Res>;

    template <typename _Tp, typename... _Args>
    using __any_constructible_t =
      typename __any_constructible<bool, _Tp, _Args...>::type;


    template <typename _ValueType, typename _Tp = _Decay<_ValueType>,
       typename _Mgr = _Manager<_Tp>,
              __any_constructible_t<_Tp, _ValueType&&> = true,
       enable_if_t<!__is_in_place_type<_Tp>::value, bool> = true>
      any(_ValueType&& __value)
      : _M_manager(&_Mgr::_S_manage)
      {
        _Mgr::_S_create(_M_storage, std::forward<_ValueType>(__value));
      }


    template <typename _ValueType, typename _Tp = _Decay<_ValueType>,
       typename _Mgr = _Manager<_Tp>,
              enable_if_t<__and_v<is_copy_constructible<_Tp>,
      __not_<is_constructible<_Tp, _ValueType&&>>,
      __not_<__is_in_place_type<_Tp>>>,
     bool> = false>
      any(_ValueType&& __value)
      : _M_manager(&_Mgr::_S_manage)
      {
        _Mgr::_S_create(_M_storage, __value);
      }


    template <typename _ValueType, typename... _Args,
       typename _Tp = _Decay<_ValueType>,
       typename _Mgr = _Manager<_Tp>,
              __any_constructible_t<_Tp, _Args&&...> = false>
      explicit
      any(in_place_type_t<_ValueType>, _Args&&... __args)
      : _M_manager(&_Mgr::_S_manage)
      {
        _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...);
      }



    template <typename _ValueType, typename _Up, typename... _Args,
       typename _Tp = _Decay<_ValueType>,
       typename _Mgr = _Manager<_Tp>,
              __any_constructible_t<_Tp, initializer_list<_Up>,
        _Args&&...> = false>
      explicit
      any(in_place_type_t<_ValueType>,
   initializer_list<_Up> __il, _Args&&... __args)
      : _M_manager(&_Mgr::_S_manage)
      {
        _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...);
      }


    ~any() { reset(); }




    any& operator=(const any& __rhs)
    {
      *this = any(__rhs);
      return *this;
    }






    any& operator=(any&& __rhs) noexcept
    {
      if (!__rhs.has_value())
 reset();
      else if (this != &__rhs)
 {
   reset();
   _Arg __arg;
   __arg._M_any = this;
   __rhs._M_manager(_Op_xfer, &__rhs, &__arg);
 }
      return *this;
    }


    template<typename _ValueType>
      enable_if_t<is_copy_constructible<_Decay<_ValueType>>::value, any&>
      operator=(_ValueType&& __rhs)
      {
 *this = any(std::forward<_ValueType>(__rhs));
 return *this;
      }


    template <typename _ValueType, typename... _Args>
      typename __any_constructible<_Decay<_ValueType>&,
       _Decay<_ValueType>, _Args&&...>::type
      emplace(_Args&&... __args)
      {
 __do_emplace<_Decay<_ValueType>>(std::forward<_Args>(__args)...);
 any::_Arg __arg;
 this->_M_manager(any::_Op_access, this, &__arg);
 return *static_cast<_Decay<_ValueType>*>(__arg._M_obj);
      }



    template <typename _ValueType, typename _Up, typename... _Args>
      typename __any_constructible<_Decay<_ValueType>&,
       _Decay<_ValueType>,
       initializer_list<_Up>,
       _Args&&...>::type
      emplace(initializer_list<_Up> __il, _Args&&... __args)
      {
 __do_emplace<_Decay<_ValueType>, _Up>(__il,
           std::forward<_Args>(__args)...);
 any::_Arg __arg;
 this->_M_manager(any::_Op_access, this, &__arg);
 return *static_cast<_Decay<_ValueType>*>(__arg._M_obj);
      }




    void reset() noexcept
    {
      if (has_value())
      {
 _M_manager(_Op_destroy, this, nullptr);
 _M_manager = nullptr;
      }
    }


    void swap(any& __rhs) noexcept
    {
      if (!has_value() && !__rhs.has_value())
 return;

      if (has_value() && __rhs.has_value())
 {
   if (this == &__rhs)
     return;

   any __tmp;
   _Arg __arg;
   __arg._M_any = &__tmp;
   __rhs._M_manager(_Op_xfer, &__rhs, &__arg);
   __arg._M_any = &__rhs;
   _M_manager(_Op_xfer, this, &__arg);
   __arg._M_any = this;
   __tmp._M_manager(_Op_xfer, &__tmp, &__arg);
 }
      else
 {
   any* __empty = !has_value() ? this : &__rhs;
   any* __full = !has_value() ? &__rhs : this;
   _Arg __arg;
   __arg._M_any = __empty;
   __full->_M_manager(_Op_xfer, __full, &__arg);
 }
    }




    bool has_value() const noexcept { return _M_manager != nullptr; }



    const type_info& type() const noexcept
    {
      if (!has_value())
 return typeid(void);
      _Arg __arg;
      _M_manager(_Op_get_type_info, this, &__arg);
      return *__arg._M_typeinfo;
    }


    template<typename _Tp>
      static constexpr bool __is_valid_cast()
      { return __or_<is_reference<_Tp>, is_copy_constructible<_Tp>>::value; }

  private:
    enum _Op {
 _Op_access, _Op_get_type_info, _Op_clone, _Op_destroy, _Op_xfer
    };

    union _Arg
    {
 void* _M_obj;
 const std::type_info* _M_typeinfo;
 any* _M_any;
    };

    void (*_M_manager)(_Op, const any*, _Arg*);
    _Storage _M_storage;

    template<typename _Tp>
      friend void* __any_caster(const any* __any);


    template<typename _Tp>
      struct _Manager_internal
      {
 static void
 _S_manage(_Op __which, const any* __anyp, _Arg* __arg);

 template<typename _Up>
   static void
   _S_create(_Storage& __storage, _Up&& __value)
   {
     void* __addr = &__storage._M_buffer;
     ::new (__addr) _Tp(std::forward<_Up>(__value));
   }

 template<typename... _Args>
   static void
   _S_create(_Storage& __storage, _Args&&... __args)
   {
     void* __addr = &__storage._M_buffer;
     ::new (__addr) _Tp(std::forward<_Args>(__args)...);
   }
      };


    template<typename _Tp>
      struct _Manager_external
      {
 static void
 _S_manage(_Op __which, const any* __anyp, _Arg* __arg);

 template<typename _Up>
   static void
   _S_create(_Storage& __storage, _Up&& __value)
   {
     __storage._M_ptr = new _Tp(std::forward<_Up>(__value));
   }
 template<typename... _Args>
   static void
   _S_create(_Storage& __storage, _Args&&... __args)
   {
     __storage._M_ptr = new _Tp(std::forward<_Args>(__args)...);
   }
      };
  };


  inline void swap(any& __x, any& __y) noexcept { __x.swap(__y); }


  template <typename _Tp, typename... _Args>
    any make_any(_Args&&... __args)
    {
      return any(in_place_type<_Tp>, std::forward<_Args>(__args)...);
    }


  template <typename _Tp, typename _Up, typename... _Args>
    any make_any(initializer_list<_Up> __il, _Args&&... __args)
    {
      return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...);
    }
# 451 "/usr/include/c++/10/any" 3
  template<typename _ValueType>
    inline _ValueType any_cast(const any& __any)
    {
      using _Up = __remove_cvref_t<_ValueType>;
      static_assert(any::__is_valid_cast<_ValueType>(),
   "Template argument must be a reference or CopyConstructible type");
      static_assert(is_constructible_v<_ValueType, const _Up&>,
   "Template argument must be constructible from a const value.");
      auto __p = any_cast<_Up>(&__any);
      if (__p)
 return static_cast<_ValueType>(*__p);
      __throw_bad_any_cast();
    }
# 477 "/usr/include/c++/10/any" 3
  template<typename _ValueType>
    inline _ValueType any_cast(any& __any)
    {
      using _Up = __remove_cvref_t<_ValueType>;
      static_assert(any::__is_valid_cast<_ValueType>(),
   "Template argument must be a reference or CopyConstructible type");
      static_assert(is_constructible_v<_ValueType, _Up&>,
   "Template argument must be constructible from an lvalue.");
      auto __p = any_cast<_Up>(&__any);
      if (__p)
 return static_cast<_ValueType>(*__p);
      __throw_bad_any_cast();
    }

  template<typename _ValueType>
    inline _ValueType any_cast(any&& __any)
    {
      using _Up = __remove_cvref_t<_ValueType>;
      static_assert(any::__is_valid_cast<_ValueType>(),
   "Template argument must be a reference or CopyConstructible type");
      static_assert(is_constructible_v<_ValueType, _Up>,
   "Template argument must be constructible from an rvalue.");
      auto __p = any_cast<_Up>(&__any);
      if (__p)
 return static_cast<_ValueType>(std::move(*__p));
      __throw_bad_any_cast();
    }



  template<typename _Tp>
    void* __any_caster(const any* __any)
    {


      using _Up = remove_cv_t<_Tp>;


      if constexpr (!is_same_v<decay_t<_Up>, _Up>)
 return nullptr;

      else if constexpr (!is_copy_constructible_v<_Up>)
 return nullptr;

      else if (__any->_M_manager == &any::_Manager<_Up>::_S_manage

   || __any->type() == typeid(_Tp)

   )
 {
   any::_Arg __arg;
   __any->_M_manager(any::_Op_access, __any, &__arg);
   return __arg._M_obj;
 }
      return nullptr;
    }
# 546 "/usr/include/c++/10/any" 3
  template<typename _ValueType>
    inline const _ValueType* any_cast(const any* __any) noexcept
    {
      if constexpr (is_object_v<_ValueType>)
 if (__any)
   return static_cast<_ValueType*>(__any_caster<_ValueType>(__any));
      return nullptr;
    }

  template<typename _ValueType>
    inline _ValueType* any_cast(any* __any) noexcept
    {
      if constexpr (is_object_v<_ValueType>)
 if (__any)
   return static_cast<_ValueType*>(__any_caster<_ValueType>(__any));
      return nullptr;
    }


  template<typename _Tp>
    void
    any::_Manager_internal<_Tp>::
    _S_manage(_Op __which, const any* __any, _Arg* __arg)
    {

      auto __ptr = reinterpret_cast<const _Tp*>(&__any->_M_storage._M_buffer);
      switch (__which)
      {
      case _Op_access:
 __arg->_M_obj = const_cast<_Tp*>(__ptr);
 break;
      case _Op_get_type_info:

 __arg->_M_typeinfo = &typeid(_Tp);

 break;
      case _Op_clone:
 ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp(*__ptr);
 __arg->_M_any->_M_manager = __any->_M_manager;
 break;
      case _Op_destroy:
 __ptr->~_Tp();
 break;
      case _Op_xfer:
 ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp
   (std::move(*const_cast<_Tp*>(__ptr)));
 __ptr->~_Tp();
 __arg->_M_any->_M_manager = __any->_M_manager;
 const_cast<any*>(__any)->_M_manager = nullptr;
 break;
      }
    }

  template<typename _Tp>
    void
    any::_Manager_external<_Tp>::
    _S_manage(_Op __which, const any* __any, _Arg* __arg)
    {

      auto __ptr = static_cast<const _Tp*>(__any->_M_storage._M_ptr);
      switch (__which)
      {
      case _Op_access:
 __arg->_M_obj = const_cast<_Tp*>(__ptr);
 break;
      case _Op_get_type_info:

 __arg->_M_typeinfo = &typeid(_Tp);

 break;
      case _Op_clone:
 __arg->_M_any->_M_storage._M_ptr = new _Tp(*__ptr);
 __arg->_M_any->_M_manager = __any->_M_manager;
 break;
      case _Op_destroy:
 delete __ptr;
 break;
      case _Op_xfer:
 __arg->_M_any->_M_storage._M_ptr = __any->_M_storage._M_ptr;
 __arg->_M_any->_M_manager = __any->_M_manager;
 const_cast<any*>(__any)->_M_manager = nullptr;
 break;
      }
    }



  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<>
      struct _Never_valueless_alt<std::any>
      : std::true_type
      { };
  }


}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h" 2







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_object.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_object.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_forward.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_forward.hpp" 3 4
namespace boost
{

namespace detail
{
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/sp_forward.hpp" 3 4
template< class T > T&& sp_forward( T & t ) noexcept
{
    return static_cast< T&& >( t );
}





}

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_object.hpp" 2 3 4






namespace boost
{

namespace detail
{

template< std::size_t N, std::size_t A > struct sp_aligned_storage
{
    union type
    {
        char data_[ N ];
        typename boost::type_with_alignment< A >::type align_;
    };
};

template< class T > class sp_ms_deleter
{
private:

    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;

    bool initialized_;
    storage_type storage_;

private:

    void destroy() noexcept
    {
        if( initialized_ )
        {



            T * p = reinterpret_cast< T* >( storage_.data_ );
            p->~T();







            initialized_ = false;
        }
    }

public:

    sp_ms_deleter() noexcept : initialized_( false )
    {
    }

    template<class A> explicit sp_ms_deleter( A const & ) noexcept : initialized_( false )
    {
    }


    sp_ms_deleter( sp_ms_deleter const & ) noexcept : initialized_( false )
    {
    }

    ~sp_ms_deleter() noexcept
    {
        destroy();
    }

    void operator()( T * ) noexcept
    {
        destroy();
    }

    static void operator_fn( T* ) noexcept
    {
    }

    void * address() noexcept
    {
        return storage_.data_;
    }

    void set_initialized() noexcept
    {
        initialized_ = true;
    }
};

template< class T, class A > class sp_as_deleter
{
private:

    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;

    storage_type storage_;
    A a_;
    bool initialized_;

private:

    void destroy() noexcept
    {
        if( initialized_ )
        {
            T * p = reinterpret_cast< T* >( storage_.data_ );



            std::allocator_traits<A>::destroy( a_, p );







            initialized_ = false;
        }
    }

public:

    sp_as_deleter( A const & a ) noexcept : a_( a ), initialized_( false )
    {
    }


    sp_as_deleter( sp_as_deleter const & r ) noexcept : a_( r.a_), initialized_( false )
    {
    }

    ~sp_as_deleter() noexcept
    {
        destroy();
    }

    void operator()( T * ) noexcept
    {
        destroy();
    }

    static void operator_fn( T* ) noexcept
    {
    }

    void * address() noexcept
    {
        return storage_.data_;
    }

    void set_initialized() noexcept
    {
        initialized_ = true;
    }
};

template< class T > struct sp_if_not_array
{
    typedef boost::shared_ptr< T > type;
};



template< class T > struct sp_if_not_array< T[] >
{
};



template< class T, std::size_t N > struct sp_if_not_array< T[N] >
{
};





}
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_object.hpp" 3 4
template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T;
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T;
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}





template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
{


    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
    A2 a2( a );

    typedef boost::detail::sp_as_deleter< T, A2 > D;

    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
# 284 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_object.hpp" 3 4
    D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
    void * pv = pd->address();



    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );







    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}
# 799 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_object.hpp" 3 4
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_array.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_array.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/allocate_shared_array.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_assign.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/has_trivial_assign.hpp" 3 4
namespace boost {

   template <typename T>
   struct has_trivial_assign : public integral_constant < bool,

      ((__has_trivial_assign(T) ) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<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{};

}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4




namespace boost {
namespace detail {

template<class>
struct sp_if_array { };

template<class T>
struct sp_if_array<T[]> {
    typedef boost::shared_ptr<T[]> type;
};

template<class>
struct sp_if_size_array { };

template<class T, std::size_t N>
struct sp_if_size_array<T[N]> {
    typedef boost::shared_ptr<T[N]> type;
};

template<class>
struct sp_array_element { };

template<class T>
struct sp_array_element<T[]> {
    typedef T type;
};

template<class T, std::size_t N>
struct sp_array_element<T[N]> {
    typedef T type;
};

template<class T>
struct sp_array_scalar {
    typedef T type;
};

template<class T, std::size_t N>
struct sp_array_scalar<T[N]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T, std::size_t N>
struct sp_array_scalar<const T[N]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T, std::size_t N>
struct sp_array_scalar<volatile T[N]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T, std::size_t N>
struct sp_array_scalar<const volatile T[N]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T>
struct sp_array_scalar<T[]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T>
struct sp_array_scalar<const T[]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T>
struct sp_array_scalar<volatile T[]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T>
struct sp_array_scalar<const volatile T[]> {
    typedef typename sp_array_scalar<T>::type type;
};

template<class T>
struct sp_array_count {
    enum {
        value = 1
    };
};

template<class T, std::size_t N>
struct sp_array_count<T[N]> {
    enum {
        value = N * sp_array_count<T>::value
    };
};

template<std::size_t N, std::size_t M>
struct sp_max_size {
    enum {
        value = N < M ? M : N
    };
};

template<std::size_t N, std::size_t M>
struct sp_align_up {
    enum {
        value = (N + M - 1) & ~(M - 1)
    };
};


template<class A, class T>
struct sp_bind_allocator {
    typedef typename std::allocator_traits<A>::template rebind_alloc<T> type;
};







template<class T>
constexpr inline std::size_t
sp_objects(std::size_t size) noexcept
{
    return (size + sizeof(T) - 1) / sizeof(T);
}

template<bool, class = void>
struct sp_enable { };

template<class T>
struct sp_enable<true, T> {
    typedef T type;
};

template<bool E, class A, class T>
inline typename sp_enable<!E && boost::has_trivial_destructor<T>::value>::type
sp_array_destroy(A&, T*, std::size_t) noexcept { }

template<bool E, class A, class T>
inline typename sp_enable<!E &&
    !boost::has_trivial_destructor<T>::value>::type
sp_array_destroy(A&, T* start, std::size_t size)
{
    while (size > 0) {
        start[--size].~T();
    }
}


template<bool E, class A, class T>
inline typename sp_enable<E>::type
sp_array_destroy(A& allocator, T* start, std::size_t size)
{
    while (size > 0) {
        std::allocator_traits<A>::destroy(allocator, start + --size);
    }
}


template<bool E, class A, class T>
inline typename sp_enable<!E &&
    boost::has_trivial_constructor<T>::value &&
    boost::has_trivial_assign<T>::value &&
    boost::has_trivial_destructor<T>::value>::type
sp_array_construct(A&, T* start, std::size_t size)
{
    for (std::size_t i = 0; i < size; ++i) {
        start[i] = T();
    }
}

template<bool E, class A, class T>
inline typename sp_enable<!E &&
    boost::has_trivial_constructor<T>::value &&
    boost::has_trivial_assign<T>::value &&
    boost::has_trivial_destructor<T>::value>::type
sp_array_construct(A&, T* start, std::size_t size, const T* list,
    std::size_t count)
{
    for (std::size_t i = 0; i < size; ++i) {
        start[i] = list[i % count];
    }
}


template<bool E, class A, class T>
inline typename sp_enable<!E &&
    !(boost::has_trivial_constructor<T>::value &&
      boost::has_trivial_assign<T>::value &&
      boost::has_trivial_destructor<T>::value)>::type
sp_array_construct(A& none, T* start, std::size_t size)
{
    std::size_t i = 0;
    try {
        for (; i < size; ++i) {
            ::new(static_cast<void*>(start + i)) T();
        }
    } catch (...) {
        sp_array_destroy<E>(none, start, i);
        throw;
    }
}

template<bool E, class A, class T>
inline typename sp_enable<!E &&
    !(boost::has_trivial_constructor<T>::value &&
      boost::has_trivial_assign<T>::value &&
      boost::has_trivial_destructor<T>::value)>::type
sp_array_construct(A& none, T* start, std::size_t size, const T* list,
    std::size_t count)
{
    std::size_t i = 0;
    try {
        for (; i < size; ++i) {
            ::new(static_cast<void*>(start + i)) T(list[i % count]);
        }
    } catch (...) {
        sp_array_destroy<E>(none, start, i);
        throw;
    }
}
# 266 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
template<bool E, class A, class T>
inline typename sp_enable<E>::type
sp_array_construct(A& allocator, T* start, std::size_t size)
{
    std::size_t i = 0;
    try {
        for (i = 0; i < size; ++i) {
            std::allocator_traits<A>::construct(allocator, start + i);
        }
    } catch (...) {
        sp_array_destroy<E>(allocator, start, i);
        throw;
    }
}

template<bool E, class A, class T>
inline typename sp_enable<E>::type
sp_array_construct(A& allocator, T* start, std::size_t size, const T* list,
    std::size_t count)
{
    std::size_t i = 0;
    try {
        for (i = 0; i < size; ++i) {
            std::allocator_traits<A>::construct(allocator, start + i,
                list[i % count]);
        }
    } catch (...) {
        sp_array_destroy<E>(allocator, start, i);
        throw;
    }
}
# 320 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
template<class A, class T>
inline typename sp_enable<boost::has_trivial_constructor<T>::value>::type
sp_array_default(A&, T*, std::size_t) noexcept { }


template<class A, class T>
inline typename sp_enable<!boost::has_trivial_constructor<T>::value>::type
sp_array_default(A& none, T* start, std::size_t size)
{
    std::size_t i = 0;
    try {
        for (; i < size; ++i) {
            ::new(static_cast<void*>(start + i)) T;
        }
    } catch (...) {
        sp_array_destroy<false>(none, start, i);
        throw;
    }
}
# 350 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
template<class A>
class sp_array_state {
public:
    typedef A type;

    template<class U>
    sp_array_state(const U& _allocator, std::size_t _size) noexcept
        : allocator_(_allocator),
          size_(_size) { }

    A& allocator() noexcept {
        return allocator_;
    }

    std::size_t size() const noexcept {
        return size_;
    }

private:
    A allocator_;
    std::size_t size_;
};

template<class A, std::size_t N>
class sp_size_array_state {
public:
    typedef A type;

    template<class U>
    sp_size_array_state(const U& _allocator, std::size_t) noexcept
        : allocator_(_allocator) { }

    A& allocator() noexcept {
        return allocator_;
    }

    constexpr std::size_t size() const noexcept {
        return N;
    }

private:
    A allocator_;
};


template<class A>
struct sp_use_construct {
    enum {
        value = true
    };
};

template<class T>
struct sp_use_construct<std::allocator<T> > {
    enum {
        value = false
    };
};
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
template<class T, class U>
struct sp_array_alignment {
    enum {
        value = sp_max_size<boost::alignment_of<T>::value,
            boost::alignment_of<U>::value>::value
    };
};

template<class T, class U>
struct sp_array_offset {
    enum {
        value = sp_align_up<sizeof(T), sp_array_alignment<T, U>::value>::value
    };
};

template<class T, class U>
struct sp_array_storage {
    enum {
        value = sp_array_alignment<T, U>::value
    };
    typedef typename boost::type_with_alignment<value>::type type;
};

template<class T, class U>
inline U*
sp_array_start(void* base) noexcept
{
    enum {
        size = sp_array_offset<T, U>::value
    };
    return reinterpret_cast<U*>(static_cast<char*>(base) + size);
}

template<class A, class T>
class sp_array_creator {
    typedef typename A::value_type scalar;

    enum {
        offset = sp_array_offset<T, scalar>::value
    };

    typedef typename sp_array_storage<T, scalar>::type type;

public:
    template<class U>
    sp_array_creator(const U& other, std::size_t size) noexcept
        : other_(other),
          size_(sp_objects<type>(offset + sizeof(scalar) * size)) { }

    T* create() {
        return reinterpret_cast<T*>(other_.allocate(size_));
    }

    void destroy(T* base) {
        other_.deallocate(reinterpret_cast<type*>(base), size_);
    }

private:
    typename sp_bind_allocator<A, type>::type other_;
    std::size_t size_;
};

struct sp_default { };

template<class T, bool E = sp_use_construct<T>::value>
class sp_array_base
    : public sp_counted_base {
    typedef typename T::type allocator;

public:
    typedef typename allocator::value_type type;

    template<class A>
    sp_array_base(const A& other, std::size_t size, type* start)
        : state_(other, size) {
        sp_array_construct<E>(state_.allocator(), start, state_.size());
    }

    template<class A>
    sp_array_base(const A& other, std::size_t size, const type* list,
        std::size_t count, type* start)
        : state_(other, size) {
        sp_array_construct<E>(state_.allocator(), start, state_.size(), list,
            count);
    }

    template<class A>
    sp_array_base(sp_default, const A& other, std::size_t size, type* start)
        : state_(other, size) {
        sp_array_default(state_.allocator(), start, state_.size());
    }

    T& state() noexcept {
        return state_;
    }

    virtual void dispose() {
        sp_array_destroy<E>(state_.allocator(),
            sp_array_start<sp_array_base, type>(this), state_.size());
    }

    virtual void destroy() {
        sp_array_creator<allocator, sp_array_base> other(state_.allocator(),
            state_.size());
        this->~sp_array_base();
        other.destroy(this);
    }

    virtual void* get_deleter(const sp_typeinfo&) {
        return 0;
    }

    virtual void* get_local_deleter(const sp_typeinfo&) {
        return 0;
    }

    virtual void* get_untyped_deleter() {
        return 0;
    }

private:
    T state_;
};

template<class A, class T>
struct sp_array_result {
public:
    template<class U>
    sp_array_result(const U& other, std::size_t size)
        : creator_(other, size),
          result_(creator_.create()) { }

    ~sp_array_result() {
        if (result_) {
            creator_.destroy(result_);
        }
    }

    T* get() const {
        return result_;
    }

    void release() {
        result_ = 0;
    }

private:
    sp_array_result(const sp_array_result&);
    sp_array_result& operator=(const sp_array_result&);

    sp_array_creator<A, T> creator_;
    T* result_;
};

}

template<class T, class A>
inline typename detail::sp_if_array<T>::type
allocate_shared(const A& allocator, std::size_t count)
{
    typedef typename detail::sp_array_element<T>::type type;
    typedef typename detail::sp_array_scalar<T>::type scalar;
    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
    typedef detail::sp_array_state<other> state;
    typedef detail::sp_array_base<state> base;
    std::size_t size = count * detail::sp_array_count<type>::value;
    detail::sp_array_result<other, base> result(allocator, size);
    detail::sp_counted_base* node = result.get();
    scalar* start = detail::sp_array_start<base, scalar>(node);
    ::new(static_cast<void*>(node)) base(allocator, size, start);
    result.release();
    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
        reinterpret_cast<type*>(start), detail::shared_count(node));
}

template<class T, class A>
inline typename detail::sp_if_size_array<T>::type
allocate_shared(const A& allocator)
{
    enum {
        size = detail::sp_array_count<T>::value
    };
    typedef typename detail::sp_array_element<T>::type type;
    typedef typename detail::sp_array_scalar<T>::type scalar;
    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
    typedef detail::sp_size_array_state<other, size> state;
    typedef detail::sp_array_base<state> base;
    detail::sp_array_result<other, base> result(allocator, size);
    detail::sp_counted_base* node = result.get();
    scalar* start = detail::sp_array_start<base, scalar>(node);
    ::new(static_cast<void*>(node)) base(allocator, size, start);
    result.release();
    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
        reinterpret_cast<type*>(start), detail::shared_count(node));
}

template<class T, class A>
inline typename detail::sp_if_array<T>::type
allocate_shared(const A& allocator, std::size_t count,
    const typename detail::sp_array_element<T>::type& value)
{
    typedef typename detail::sp_array_element<T>::type type;
    typedef typename detail::sp_array_scalar<T>::type scalar;
    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
    typedef detail::sp_array_state<other> state;
    typedef detail::sp_array_base<state> base;
    std::size_t size = count * detail::sp_array_count<type>::value;
    detail::sp_array_result<other, base> result(allocator, size);
    detail::sp_counted_base* node = result.get();
    scalar* start = detail::sp_array_start<base, scalar>(node);
    ::new(static_cast<void*>(node)) base(allocator, size,
        reinterpret_cast<const scalar*>(&value),
        detail::sp_array_count<type>::value, start);
    result.release();
    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
        reinterpret_cast<type*>(start), detail::shared_count(node));
}

template<class T, class A>
inline typename detail::sp_if_size_array<T>::type
allocate_shared(const A& allocator,
    const typename detail::sp_array_element<T>::type& value)
{
    enum {
        size = detail::sp_array_count<T>::value
    };
    typedef typename detail::sp_array_element<T>::type type;
    typedef typename detail::sp_array_scalar<T>::type scalar;
    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
    typedef detail::sp_size_array_state<other, size> state;
    typedef detail::sp_array_base<state> base;
    detail::sp_array_result<other, base> result(allocator, size);
    detail::sp_counted_base* node = result.get();
    scalar* start = detail::sp_array_start<base, scalar>(node);
    ::new(static_cast<void*>(node)) base(allocator, size,
        reinterpret_cast<const scalar*>(&value),
        detail::sp_array_count<type>::value, start);
    result.release();
    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
        reinterpret_cast<type*>(start), detail::shared_count(node));
}

template<class T, class A>
inline typename detail::sp_if_array<T>::type
allocate_shared_noinit(const A& allocator, std::size_t count)
{
    typedef typename detail::sp_array_element<T>::type type;
    typedef typename detail::sp_array_scalar<T>::type scalar;
    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
    typedef detail::sp_array_state<other> state;
    typedef detail::sp_array_base<state, false> base;
    std::size_t size = count * detail::sp_array_count<type>::value;
    detail::sp_array_result<other, base> result(allocator, size);
    detail::sp_counted_base* node = result.get();
    scalar* start = detail::sp_array_start<base, scalar>(node);
    ::new(static_cast<void*>(node)) base(detail::sp_default(), allocator,
        size, start);
    result.release();
    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
        reinterpret_cast<type*>(start), detail::shared_count(node));
}

template<class T, class A>
inline typename detail::sp_if_size_array<T>::type
allocate_shared_noinit(const A& allocator)
{
    enum {
        size = detail::sp_array_count<T>::value
    };
    typedef typename detail::sp_array_element<T>::type type;
    typedef typename detail::sp_array_scalar<T>::type scalar;
    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
    typedef detail::sp_size_array_state<other, size> state;
    typedef detail::sp_array_base<state, false> base;
    detail::sp_array_result<other, base> result(allocator, size);
    detail::sp_counted_base* node = result.get();
    scalar* start = detail::sp_array_start<base, scalar>(node);
    ::new(static_cast<void*>(node)) base(detail::sp_default(), allocator,
        size, start);
    result.release();
    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
        reinterpret_cast<type*>(start), detail::shared_count(node));
}

}
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared_array.hpp" 2 3 4

namespace boost {

template<class T>
inline typename detail::sp_if_size_array<T>::type
make_shared()
{
    return boost::allocate_shared<T>(std::allocator<typename
        detail::sp_array_scalar<T>::type>());
}

template<class T>
inline typename detail::sp_if_size_array<T>::type
make_shared(const typename detail::sp_array_element<T>::type& value)
{
    return boost::allocate_shared<T>(std::allocator<typename
        detail::sp_array_scalar<T>::type>(), value);
}

template<class T>
inline typename detail::sp_if_array<T>::type
make_shared(std::size_t size)
{
    return boost::allocate_shared<T>(std::allocator<typename
        detail::sp_array_scalar<T>::type>(), size);
}

template<class T>
inline typename detail::sp_if_array<T>::type
make_shared(std::size_t size,
    const typename detail::sp_array_element<T>::type& value)
{
    return boost::allocate_shared<T>(std::allocator<typename
        detail::sp_array_scalar<T>::type>(), size, value);
}

template<class T>
inline typename detail::sp_if_size_array<T>::type
make_shared_noinit()
{
    return allocate_shared_noinit<T>(std::allocator<typename
        detail::sp_array_scalar<T>::type>());
}

template<class T>
inline typename detail::sp_if_array<T>::type
make_shared_noinit(std::size_t size)
{
    return allocate_shared_noinit<T>(std::allocator<typename
        detail::sp_array_scalar<T>::type>(), size);
}

}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/make_shared.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h" 2


# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
namespace ceph {

namespace _any {
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
inline constexpr std::size_t dynamic = ~0;
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
enum class op { type, destroy };
template<typename T>
inline void op_func(const op o, void* p) noexcept {
  static const std::type_info& type = typeid(T);
  switch (o) {
  case op::type:
    *(reinterpret_cast<const std::type_info**>(p)) = &type;
    break;
  case op::destroy:
    reinterpret_cast<T*>(p)->~T();
    break;
  }
}
using func_t = void (*)(const op, void* p) noexcept;
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
template<typename D, typename storage_t>
class base {






  static constexpr std::size_t capacity = D::capacity;

  void* ptr() const noexcept {
    static_assert(
      noexcept(static_cast<const D*>(this)->ptr()) &&
      std::is_same_v<decltype(static_cast<const D*>(this)->ptr()), void*>,
      "‘void* ptr() const noexcept’ missing from superclass");
    return static_cast<const D*>(this)->ptr();
  }

  void* alloc_storage(const std::size_t z) {
    static_assert(
      std::is_same_v<decltype(static_cast<D*>(this)->alloc_storage(z)), void*>,
      "‘void* alloc_storage(const size_t)’ missing from superclass.");
    return static_cast<D*>(this)->alloc_storage(z);
  }

  void free_storage() noexcept {
    static_assert(
      noexcept(static_cast<D*>(this)->free_storage()) &&
      std::is_void_v<decltype(static_cast<D*>(this)->free_storage())>,
      "‘void free_storage() noexcept’ missing from superclass.");
    static_cast<D*>(this)->free_storage();
  }
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
  template<class T>
  struct is_in_place_type_helper : std::false_type {};
  template<class T>
  struct is_in_place_type_helper<std::in_place_type_t<T>> : std::true_type {};

  template<class T>
  static constexpr bool is_in_place_type_v =
    is_in_place_type_helper<std::decay_t<T>>::value;







  template<typename T>
  using value_condition_t = std::enable_if_t<
    !std::is_same_v<std::decay_t<T>, D> &&
    !is_in_place_type_v<std::decay_t<T>>>;





  template<typename T>
  static constexpr bool value_noexcept_v =
    std::is_nothrow_constructible_v<std::decay_t<T>, T> && capacity != dynamic;



  template<typename T, typename... Args>
  using in_place_condition_t = std::enable_if_t<std::is_constructible_v<
        std::decay_t<T>, Args...>>;




  template<typename T, typename... Args>
  static constexpr bool in_place_noexcept_v =
    std::is_nothrow_constructible_v<std::decay_t<T>, Args...> &&
    capacity != dynamic;

private:
# 191 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
  func_t func = nullptr;




  template<typename T, typename ...Args>
  std::decay_t<T>& construct(Args&& ...args) {
    using Td = std::decay_t<T>;
    static_assert(capacity == dynamic || sizeof(Td) <= capacity,
    "Supplied type is too large for this specialization.");
    try {
      func = &op_func<Td>;
      return *new (reinterpret_cast<Td*>(alloc_storage(sizeof(Td))))
 Td(std::forward<Args>(args)...);
    } catch (...) {
      reset();
      throw;
    }
  }

protected:





  storage_t storage;

public:

  base() noexcept = default;
  ~base() noexcept {
    reset();
  }

protected:


  base(const base& rhs) noexcept : func(rhs.func) {
    if constexpr (std::is_copy_assignable_v<storage_t>) {
      storage = rhs.storage;
    }
  }
  base& operator =(const base& rhs) noexcept {
    reset();
    func = rhs.func;
    if constexpr (std::is_copy_assignable_v<storage_t>) {
      storage = rhs.storage;
    }
    return *this;
  }

  base(base&& rhs) noexcept : func(std::move(rhs.func)) {
    if constexpr (std::is_move_assignable_v<storage_t>) {
      storage = std::move(rhs.storage);
    }
    rhs.func = nullptr;
  }
  base& operator =(base&& rhs) noexcept {
    reset();
    func = rhs.func;
    if constexpr (std::is_move_assignable_v<storage_t>) {
      storage = std::move(rhs.storage);
    }
    rhs.func = nullptr;
    return *this;
  }

public:




  template<typename T,
    typename = value_condition_t<T>>
  base(T&& t) noexcept(value_noexcept_v<T>) {
    construct<T>(std::forward<T>(t));
  }



  template<typename T,
           typename = value_condition_t<T>>
  base& operator =(T&& t) noexcept(value_noexcept_v<T>) {
    reset();
    construct<T>(std::forward<T>(t));
    return *this;
  }
# 314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
  template<typename T,
           typename... Args,
           typename = in_place_condition_t<T, Args...>>
  base(std::in_place_type_t<T>,
       Args&& ...args) noexcept(in_place_noexcept_v<T, Args...>) {
    construct<T>(std::forward<Args>(args)...);
  }



  template<typename T,
           typename... Args,
           typename = in_place_condition_t<T>>
  std::decay_t<T>& emplace(Args&& ...args) noexcept(in_place_noexcept_v<
          T, Args...>) {
    reset();
    return construct<T>(std::forward<Args>(args)...);
  }

  template<typename T,
           typename U,
           typename... Args,
           typename = in_place_condition_t<T, std::initializer_list<U>,
        Args...>>
  base(std::in_place_type_t<T>,
       std::initializer_list<U> i,
       Args&& ...args) noexcept(in_place_noexcept_v<T, std::initializer_list<U>,
    Args...>) {
    construct<T>(i, std::forward<Args>(args)...);
  }



  template<typename T,
           typename U,
           typename... Args,
           typename = in_place_condition_t<T, std::initializer_list<U>,
        Args...>>
  std::decay_t<T>& emplace(std::initializer_list<U> i,
                           Args&& ...args) noexcept(in_place_noexcept_v<T,
          std::initializer_list<U>,
          Args...>) {
    reset();
    return construct<T>(i,std::forward<Args>(args)...);
  }



  void reset() noexcept {
    if (has_value()) {
      func(op::destroy, ptr());
      func = nullptr;
    }
    free_storage();
  }

  template<typename U = storage_t,
    typename = std::enable_if<std::is_swappable_v<storage_t>>>
  void swap(base& rhs) {
    using std::swap;
    swap(func, rhs.func);
    swap(storage, rhs.storage);
  }




  bool has_value() const noexcept {
    return !!func;
  }



  const std::type_info& type() const noexcept {
    if (has_value()) {
      const std::type_info* t;
      func(op::type, reinterpret_cast<void*>(&t));
      return *t;
    } else {
      return typeid(void);
    }
  }

  template<typename T, typename U, typename V>
  friend inline void* cast_helper(const base<U, V>& b) noexcept;
};






template<typename T, typename U, typename V>
inline void* cast_helper(const base<U, V>& b) noexcept {
  if (b.func && ((&op_func<T> == b.func) ||
   (b.type() == typeid(T)))) {
    return b.ptr();
  } else {
    return nullptr;
  }
}
}
# 427 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
template<typename T, typename U, typename V>
inline T* any_cast(_any::base<U, V>* a) noexcept {
  if (a) {
    return static_cast<T*>(_any::cast_helper<std::decay_t<T>>(*a));
  }
  return nullptr;
}

template<typename T, typename U, typename V>
inline const T* any_cast(const _any::base<U, V>* a) noexcept {
  if (a) {
    return static_cast<T*>(_any::cast_helper<std::decay_t<T>>(*a));
  }
  return nullptr;
}




template<typename T, typename U, typename V>
inline T any_cast(_any::base<U, V>& a) {
  static_assert(std::is_reference_v<T> ||
                std::is_copy_constructible_v<T>,
                "The supplied type must be either a reference or "
                "copy constructible.");
  auto p = any_cast<std::decay_t<T>>(&a);
  if (p) {
    return static_cast<T>(*p);
  }
  throw std::bad_any_cast();
}

template<typename T, typename U, typename V>
inline T any_cast(const _any::base<U, V>& a) {
  static_assert(std::is_reference_v<T> ||
                std::is_copy_constructible_v<T>,
                "The supplied type must be either a reference or "
                "copy constructible.");
  auto p = any_cast<std::decay_t<T>>(&a);
  if (p) {
    return static_cast<T>(*p);
  }
  throw std::bad_any_cast();
}

template<typename T, typename U, typename V>
inline std::enable_if_t<(std::is_move_constructible_v<T> ||
    std::is_copy_constructible_v<T>) &&
   !std::is_rvalue_reference_v<T>, T>
any_cast(_any::base<U, V>&& a) {
  auto p = any_cast<std::decay_t<T>>(&a);
  if (p) {
    return std::move((*p));
  }
  throw std::bad_any_cast();
}

template<typename T, typename U, typename V>
inline std::enable_if_t<std::is_rvalue_reference_v<T>, T>
any_cast(_any::base<U, V>&& a) {
  auto p = any_cast<std::decay_t<T>>(&a);
  if (p) {
    return static_cast<T>(*p);
  }
  throw std::bad_any_cast();
}
# 510 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
template<std::size_t S>
class immobile_any : public _any::base<immobile_any<S>,
           std::aligned_storage_t<S>> {
  using base = _any::base<immobile_any<S>, std::aligned_storage_t<S>>;
  friend base;

  using _any::base<immobile_any<S>, std::aligned_storage_t<S>>::storage;







  static constexpr std::size_t capacity = S;
  void* ptr() const noexcept {
    return const_cast<void*>(static_cast<const void*>(&storage));
  }
  void* alloc_storage(std::size_t) noexcept {
    return ptr();
  }
  void free_storage() noexcept {}

  static_assert(capacity != _any::dynamic,
  "That is not a valid size for an immobile_any.");

public:

  immobile_any() noexcept = default;

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

  using base::base;
  using base::operator =;

  void swap(immobile_any&) = delete;
};

template<typename T, std::size_t S, typename... Args>
inline immobile_any<S> make_immobile_any(Args&& ...args) {
  return immobile_any<S>(std::in_place_type<T>, std::forward<Args>(args)...);
}

template<typename T, std::size_t S, typename U, typename... Args>
inline immobile_any<S> make_immobile_any(std::initializer_list<U> i, Args&& ...args) {
  return immobile_any<S>(std::in_place_type<T>, i, std::forward<Args>(args)...);
}
# 578 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
class unique_any : public _any::base<unique_any, std::unique_ptr<std::byte[]>> {
  using base = _any::base<unique_any, std::unique_ptr<std::byte[]>>;
  friend base;

  using base::storage;







  static constexpr std::size_t capacity = _any::dynamic;
  void* ptr() const noexcept {
    return static_cast<void*>(storage.get());
    return nullptr;
  }

  void* alloc_storage(const std::size_t z) {
    storage.reset(new std::byte[z]);
    return ptr();
  }

  void free_storage() noexcept {
    storage.reset();
  }

public:

  unique_any() noexcept = default;
  ~unique_any() noexcept = default;

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




  unique_any(unique_any&& rhs) noexcept = default;
  unique_any& operator =(unique_any&& rhs) = default;

  using base::base;
  using base::operator =;
};

inline void swap(unique_any& lhs, unique_any& rhs) noexcept {
  lhs.swap(rhs);
}

template<typename T, typename... Args>
inline unique_any make_unique_any(Args&& ...args) {
  return unique_any(std::in_place_type<T>, std::forward<Args>(args)...);
}

template<typename T, typename U, typename... Args>
inline unique_any make_unique_any(std::initializer_list<U> i, Args&& ...args) {
  return unique_any(std::in_place_type<T>, i, std::forward<Args>(args)...);
}
# 645 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
class shared_any : public _any::base<shared_any, boost::shared_ptr<std::byte[]>> {
  using base = _any::base<shared_any, boost::shared_ptr<std::byte[]>>;
  friend base;

  using base::storage;
# 660 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/any.h"
  static constexpr std::size_t capacity = _any::dynamic;
  void* ptr() const noexcept {
    return static_cast<void*>(storage.get());
  }

  void* alloc_storage(std::size_t n) {
    storage = boost::make_shared_noinit<std::byte[]>(n);
    return ptr();
  }

  void free_storage() noexcept {
    storage.reset();
  }

public:

  shared_any() noexcept = default;
  ~shared_any() noexcept = default;

  shared_any(const shared_any& rhs) noexcept = default;
  shared_any& operator =(const shared_any&) noexcept = default;

  shared_any(shared_any&& rhs) noexcept = default;
  shared_any& operator =(shared_any&& rhs) noexcept = default;

  using base::base;
  using base::operator =;
};

inline void swap(shared_any& lhs, shared_any& rhs) noexcept {
  lhs.swap(rhs);
}

template<typename T, typename... Args>
inline shared_any make_shared_any(Args&& ...args) {
  return shared_any(std::in_place_type<T>, std::forward<Args>(args)...);
}

template<typename T, typename U, typename... Args>
inline shared_any make_shared_any(std::initializer_list<U> i, Args&& ...args) {
  return shared_any(std::in_place_type<T>, i, std::forward<Args>(args)...);
}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/cmdparse.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/cmdparse.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Formatter.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/cmdparse.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/BackTrace.h" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/BackTrace.h"
# 1 "/usr/include/execinfo.h" 1 3 4
# 23 "/usr/include/execinfo.h" 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)
     throw () __attribute__ ((__nonnull__ (1)));




extern void backtrace_symbols_fd (void *const *__array, int __size, int __fd)
     throw () __attribute__ ((__nonnull__ (1)));

}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/BackTrace.h" 2

# 1 "/usr/include/c++/10/stdlib.h" 1 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/BackTrace.h" 2


# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/BackTrace.h"
namespace ceph {

class Formatter;

struct BackTrace {
  const static int max = 100;

  int skip;
  void *array[max]{};
  size_t size;
  char **strings;

  explicit BackTrace(int s) : skip(s) {

    size = backtrace(array, max);
    strings = backtrace_symbols(array, size);





  }
  ~BackTrace() {
    free(strings);
  }

  BackTrace(const BackTrace& other);
  const BackTrace& operator=(const BackTrace& other);

  void print(std::ostream& out) const;
  void dump(Formatter *f) const;
};

inline std::ostream& operator<<(std::ostream& out, const BackTrace& bt) {
  bt.print(out);
  return out;
}

}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/cmdparse.h" 2

class CephContext;

typedef boost::variant<std::string,
         bool,
         int64_t,
         double,
         std::vector<std::string>,
         std::vector<int64_t>,
         std::vector<double>> cmd_vartype;
typedef std::map<std::string, cmd_vartype, std::less<>> cmdmap_t;

std::string cmddesc_get_prefix(const std::string &cmddesc);
std::string cmddesc_get_prenautilus_compat(const std::string &cmddesc);
void dump_cmd_to_json(ceph::Formatter *f, uint64_t features,
                      const std::string& cmd);
void dump_cmd_and_help_to_json(ceph::Formatter *f,
          uint64_t features,
          const std::string& secname,
          const std::string& cmd,
          const std::string& helptext);
void dump_cmddesc_to_json(ceph::Formatter *jf,
            uint64_t features,
            const std::string& secname,
            const std::string& cmdsig,
            const std::string& helptext,
            const std::string& module,
            const std::string& perm,
            uint64_t flags);
bool cmdmap_from_json(std::vector<std::string> cmd, cmdmap_t *mapp,
        std::stringstream &ss);
void cmdmap_dump(const cmdmap_t &cmdmap, ceph::Formatter *f);
void handle_bad_get(CephContext *cct, const std::string& k, const char *name);

std::string cmd_vartype_stringify(const cmd_vartype& v);

struct bad_cmd_get : public std::exception {
  std::string desc;
  bad_cmd_get(const std::string& f, const cmdmap_t& cmdmap) {
    desc = "bad or missing field '" + f + "'";
  }
  const char *what() const throw() override {
    return desc.c_str();
  }
};

bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
  const std::string& k, bool& val);

template <typename T>
bool cmd_getval(CephContext *cct, const cmdmap_t& cmdmap,
  const std::string& k, T& val)
{
  if (cmdmap.count(k)) {
    try {
      val = boost::get<T>(cmdmap.find(k)->second);
      return true;
    } catch (boost::bad_get&) {
      throw bad_cmd_get(k, cmdmap);
    }
  }
  return false;
}



template <typename T>
bool cmd_getval(
  CephContext *cct, const cmdmap_t& cmdmap, const std::string& k,
  T& val, const T& defval)
{
  if (cmdmap.count(k)) {
    try {
      val = boost::get<T>(cmdmap.find(k)->second);
      return true;
    } catch (boost::bad_get&) {
      throw bad_cmd_get(k, cmdmap);
    }
  } else {
    val = defval;
    return true;
  }
}

template <typename T>
void
cmd_putval(CephContext *cct, cmdmap_t& cmdmap, const std::string& k, const T& val)
{
  cmdmap[k] = val;
}

bool validate_cmd(CephContext* cct,
    const std::string& desc,
    const cmdmap_t& cmdmap,
    std::ostream& os);
extern int parse_osd_id(const char *s, std::ostream *pss);
extern long parse_pos_long(const char *s, std::ostream *pss = 
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/cmdparse.h" 3 4
                                                             __null
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/cmdparse.h"
                                                                 );
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/code_environment.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/code_environment.h"
enum code_environment_t {
  CODE_ENVIRONMENT_UTILITY = 0,
  CODE_ENVIRONMENT_DAEMON = 1,
  CODE_ENVIRONMENT_LIBRARY = 2,
  CODE_ENVIRONMENT_UTILITY_NODOUT = 3,
};





extern "C" code_environment_t g_code_env;
extern "C" const char *code_environment_to_str(enum code_environment_t e);
std::ostream &operator<<(std::ostream &oss, const enum code_environment_t e);
extern "C" int get_process_name(char *buf, int len);
std::string get_process_name_cpp();
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 2




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h" 1


       


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h" 1
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ConfUtils.h" 1
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ConfUtils.h"
class ConfLine {
public:
  ConfLine(const std::string &key_, const std::string &val_,
    const std::string &newsection_, const std::string &comment_, int line_no_);
  bool operator<(const ConfLine &rhs) const;
  friend std::ostream &operator<<(std::ostream& oss, const ConfLine &l);

  std::string key, val, newsection;
};

class ConfSection {
public:
  typedef std::set <ConfLine>::const_iterator const_line_iter_t;

  std::set <ConfLine> lines;
};

class ConfFile {
public:
  typedef std::map <std::string, ConfSection>::iterator section_iter_t;
  typedef std::map <std::string, ConfSection>::const_iterator const_section_iter_t;

  ConfFile();
  ~ConfFile();
  void clear();
  int parse_file(const std::string &fname, std::deque<std::string> *errors, std::ostream *warnings);
  int parse_bufferlist(ceph::bufferlist *bl, std::deque<std::string> *errors, std::ostream *warnings);
  int read(const std::string &section, const std::string &key,
       std::string &val) const;

  const_section_iter_t sections_begin() const;
  const_section_iter_t sections_end() const;

  static void trim_whitespace(std::string &str, bool strip_internal);
  static std::string normalize_key_name(const std::string &key);
  friend std::ostream &operator<<(std::ostream &oss, const ConfFile &cf);

private:
  void load_from_buffer(const char *buf, size_t sz,
   std::deque<std::string> *errors, std::ostream *warnings);
  static ConfLine* process_line(int line_no, const char *line,
           std::deque<std::string> *errors);

  std::map <std::string, ConfSection> sections;
};
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/SubsystemMap.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/SubsystemMap.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/likely.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/SubsystemMap.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys_types.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys_types.h"
enum ceph_subsys_id_t {
  ceph_subsys_,



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys.h"

ceph_subsys_lockdep,
ceph_subsys_context,
ceph_subsys_crush,
ceph_subsys_mds,
ceph_subsys_mds_balancer,
ceph_subsys_mds_locker,
ceph_subsys_mds_log,
ceph_subsys_mds_log_expire,
ceph_subsys_mds_migrator,
ceph_subsys_buffer,
ceph_subsys_timer,
ceph_subsys_filer,
ceph_subsys_striper,
ceph_subsys_objecter,
ceph_subsys_rados,
ceph_subsys_rbd,
ceph_subsys_rbd_mirror,
ceph_subsys_rbd_replay,
ceph_subsys_journaler,
ceph_subsys_objectcacher,
ceph_subsys_client,
ceph_subsys_osd,
ceph_subsys_optracker,
ceph_subsys_objclass,
ceph_subsys_filestore,
ceph_subsys_journal,
ceph_subsys_ms,
ceph_subsys_mon,
ceph_subsys_monc,
ceph_subsys_paxos,
ceph_subsys_tp,
ceph_subsys_auth,
ceph_subsys_crypto,
ceph_subsys_finisher,
ceph_subsys_reserver,
ceph_subsys_heartbeatmap,
ceph_subsys_perfcounter,
ceph_subsys_rgw,
ceph_subsys_rgw_sync,
ceph_subsys_civetweb,
ceph_subsys_javaclient,
ceph_subsys_asok,
ceph_subsys_throttle,
ceph_subsys_refs,
ceph_subsys_xio,
ceph_subsys_compressor,
ceph_subsys_bluestore,
ceph_subsys_bluefs,
ceph_subsys_bdev,
ceph_subsys_kstore,
ceph_subsys_rocksdb,
ceph_subsys_leveldb,
ceph_subsys_memdb,
ceph_subsys_kinetic,
ceph_subsys_fuse,
ceph_subsys_mgr,
ceph_subsys_mgrc,
ceph_subsys_dpdk,
ceph_subsys_eventtrace,
ceph_subsys_prioritycache,
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys_types.h" 2


  ceph_subsys_max
};

constexpr static std::size_t ceph_subsys_get_num() {
  return static_cast<std::size_t>(ceph_subsys_max);
}

struct ceph_subsys_item_t {
  const char* name;
  uint8_t log_level;
  uint8_t gather_level;
};

constexpr static std::array<ceph_subsys_item_t, ceph_subsys_get_num()>
ceph_subsys_get_as_array() {





  return {
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys.h"
ceph_subsys_item_t{ "none", 0, 5 },
ceph_subsys_item_t{ "lockdep", 0, 1 },
ceph_subsys_item_t{ "context", 0, 1 },
ceph_subsys_item_t{ "crush", 1, 1 },
ceph_subsys_item_t{ "mds", 1, 5 },
ceph_subsys_item_t{ "mds_balancer", 1, 5 },
ceph_subsys_item_t{ "mds_locker", 1, 5 },
ceph_subsys_item_t{ "mds_log", 1, 5 },
ceph_subsys_item_t{ "mds_log_expire", 1, 5 },
ceph_subsys_item_t{ "mds_migrator", 1, 5 },
ceph_subsys_item_t{ "buffer", 0, 1 },
ceph_subsys_item_t{ "timer", 0, 1 },
ceph_subsys_item_t{ "filer", 0, 1 },
ceph_subsys_item_t{ "striper", 0, 1 },
ceph_subsys_item_t{ "objecter", 0, 1 },
ceph_subsys_item_t{ "rados", 0, 5 },
ceph_subsys_item_t{ "rbd", 0, 5 },
ceph_subsys_item_t{ "rbd_mirror", 0, 5 },
ceph_subsys_item_t{ "rbd_replay", 0, 5 },
ceph_subsys_item_t{ "journaler", 0, 5 },
ceph_subsys_item_t{ "objectcacher", 0, 5 },
ceph_subsys_item_t{ "client", 0, 5 },
ceph_subsys_item_t{ "osd", 1, 5 },
ceph_subsys_item_t{ "optracker", 0, 5 },
ceph_subsys_item_t{ "objclass", 0, 5 },
ceph_subsys_item_t{ "filestore", 1, 3 },
ceph_subsys_item_t{ "journal", 1, 3 },
ceph_subsys_item_t{ "ms", 0, 0 },
ceph_subsys_item_t{ "mon", 1, 5 },
ceph_subsys_item_t{ "monc", 0, 10 },
ceph_subsys_item_t{ "paxos", 1, 5 },
ceph_subsys_item_t{ "tp", 0, 5 },
ceph_subsys_item_t{ "auth", 1, 5 },
ceph_subsys_item_t{ "crypto", 1, 5 },
ceph_subsys_item_t{ "finisher", 1, 1 },
ceph_subsys_item_t{ "reserver", 1, 1 },
ceph_subsys_item_t{ "heartbeatmap", 1, 5 },
ceph_subsys_item_t{ "perfcounter", 1, 5 },
ceph_subsys_item_t{ "rgw", 1, 5 },
ceph_subsys_item_t{ "rgw_sync", 1, 5 },
ceph_subsys_item_t{ "civetweb", 1, 10 },
ceph_subsys_item_t{ "javaclient", 1, 5 },
ceph_subsys_item_t{ "asok", 1, 5 },
ceph_subsys_item_t{ "throttle", 1, 1 },
ceph_subsys_item_t{ "refs", 0, 0 },
ceph_subsys_item_t{ "xio", 1, 5 },
ceph_subsys_item_t{ "compressor", 1, 5 },
ceph_subsys_item_t{ "bluestore", 1, 5 },
ceph_subsys_item_t{ "bluefs", 1, 5 },
ceph_subsys_item_t{ "bdev", 1, 3 },
ceph_subsys_item_t{ "kstore", 1, 5 },
ceph_subsys_item_t{ "rocksdb", 4, 5 },
ceph_subsys_item_t{ "leveldb", 4, 5 },
ceph_subsys_item_t{ "memdb", 4, 5 },
ceph_subsys_item_t{ "kinetic", 1, 5 },
ceph_subsys_item_t{ "fuse", 1, 5 },
ceph_subsys_item_t{ "mgr", 1, 5 },
ceph_subsys_item_t{ "mgrc", 1, 5 },
ceph_subsys_item_t{ "dpdk", 1, 5 },
ceph_subsys_item_t{ "eventtrace", 1, 5 },
ceph_subsys_item_t{ "prioritycache", 1, 5 },
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys_types.h" 2
  };


}

constexpr static std::uint8_t
ceph_subsys_get_max_default_level(const std::size_t subidx) {
  const auto item = ceph_subsys_get_as_array()[subidx];
  return std::max(item.log_level, item.gather_level);
}




constexpr static std::size_t strlen_ct(const char* const s) {
  std::size_t l = 0;
  while (s[l] != '\0') {
    ++l;
  }
  return l;
}

constexpr static std::size_t ceph_subsys_max_name_length() {
  return std::max({




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys.h"
strlen_ct("none"),
strlen_ct("lockdep"),
strlen_ct("context"),
strlen_ct("crush"),
strlen_ct("mds"),
strlen_ct("mds_balancer"),
strlen_ct("mds_locker"),
strlen_ct("mds_log"),
strlen_ct("mds_log_expire"),
strlen_ct("mds_migrator"),
strlen_ct("buffer"),
strlen_ct("timer"),
strlen_ct("filer"),
strlen_ct("striper"),
strlen_ct("objecter"),
strlen_ct("rados"),
strlen_ct("rbd"),
strlen_ct("rbd_mirror"),
strlen_ct("rbd_replay"),
strlen_ct("journaler"),
strlen_ct("objectcacher"),
strlen_ct("client"),
strlen_ct("osd"),
strlen_ct("optracker"),
strlen_ct("objclass"),
strlen_ct("filestore"),
strlen_ct("journal"),
strlen_ct("ms"),
strlen_ct("mon"),
strlen_ct("monc"),
strlen_ct("paxos"),
strlen_ct("tp"),
strlen_ct("auth"),
strlen_ct("crypto"),
strlen_ct("finisher"),
strlen_ct("reserver"),
strlen_ct("heartbeatmap"),
strlen_ct("perfcounter"),
strlen_ct("rgw"),
strlen_ct("rgw_sync"),
strlen_ct("civetweb"),
strlen_ct("javaclient"),
strlen_ct("asok"),
strlen_ct("throttle"),
strlen_ct("refs"),
strlen_ct("xio"),
strlen_ct("compressor"),
strlen_ct("bluestore"),
strlen_ct("bluefs"),
strlen_ct("bdev"),
strlen_ct("kstore"),
strlen_ct("rocksdb"),
strlen_ct("leveldb"),
strlen_ct("memdb"),
strlen_ct("kinetic"),
strlen_ct("fuse"),
strlen_ct("mgr"),
strlen_ct("mgrc"),
strlen_ct("dpdk"),
strlen_ct("eventtrace"),
strlen_ct("prioritycache"),
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/subsys_types.h" 2


  });
}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/SubsystemMap.h" 2



namespace ceph {
namespace logging {

class SubsystemMap {



  std::array<uint8_t, ceph_subsys_get_num()> m_gather_levels;




  std::vector<ceph_subsys_item_t> m_subsys;

  friend class Log;

public:
  SubsystemMap() {
    constexpr auto s = ceph_subsys_get_as_array();
    m_subsys.reserve(s.size());

    std::size_t i = 0;
    for (const ceph_subsys_item_t& item : s) {
      m_subsys.emplace_back(item);
      m_gather_levels[i++] = std::max(item.log_level, item.gather_level);
    }
  }

  constexpr static std::size_t get_num() {
    return ceph_subsys_get_num();
  }

  constexpr static std::size_t get_max_subsys_len() {
    return ceph_subsys_max_name_length();
  }

  int get_log_level(unsigned subsys) const {
    if (subsys >= get_num())
      subsys = 0;
    return m_subsys[subsys].log_level;
  }

  int get_gather_level(unsigned subsys) const {
    if (subsys >= get_num())
      subsys = 0;
    return m_subsys[subsys].gather_level;
  }


  constexpr const char* get_name(unsigned subsys) const {
    if (subsys >= get_num())
      subsys = 0;
    return ceph_subsys_get_as_array()[subsys].name;
  }

  template <unsigned SubV, int LvlV>
  bool should_gather() const {
    static_assert(SubV < get_num(), "wrong subsystem ID");
    static_assert(LvlV >= -1 && LvlV <= 200);

    if constexpr (LvlV <= 0) {



      return true;
    } else {


      return __builtin_expect((LvlV <= static_cast<int>(m_gather_levels[SubV])),(LvlV <= ceph_subsys_get_max_default_level(SubV)))
                                                      ;
    }
  }
  bool should_gather(const unsigned sub, int level) const {
    do { static const ceph::assert_data assert_data_ctx = {"sub < m_subsys.size()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/SubsystemMap.h", 89, __PRETTY_FUNCTION__}; ((sub < m_subsys.size()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    return level <= static_cast<int>(m_gather_levels[sub]);
  }

  void set_log_level(unsigned subsys, uint8_t log)
  {
    do { static const ceph::assert_data assert_data_ctx = {"subsys < m_subsys.size()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/SubsystemMap.h", 95, __PRETTY_FUNCTION__}; ((subsys < m_subsys.size()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    m_subsys[subsys].log_level = log;
    m_gather_levels[subsys] =
      std::max(log, m_subsys[subsys].gather_level);
  }

  void set_gather_level(unsigned subsys, uint8_t gather)
  {
    do { static const ceph::assert_data assert_data_ctx = {"subsys < m_subsys.size()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/SubsystemMap.h", 103, __PRETTY_FUNCTION__}; ((subsys < m_subsys.size()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    m_subsys[subsys].gather_level = gather;
    m_gather_levels[subsys] =
      std::max(m_subsys[subsys].log_level, gather);
  }
};

}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/options.h" 1



       





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/str_list.h" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/str_list.h"
namespace ceph {



template <typename Func>
void for_each_substr(std::string_view s, const char *delims, Func&& f)
{
  auto pos = s.find_first_not_of(delims);
  while (pos != s.npos) {
    s.remove_prefix(pos);
    auto end = s.find_first_of(delims);
    f(s.substr(0, end));
    pos = s.find_first_not_of(delims, end);
  }
}

}







extern void get_str_list(const std::string& str,
    std::list<std::string>& str_list);
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/str_list.h"
extern void get_str_list(const std::string& str,
                         const char *delims,
    std::list<std::string>& str_list);

std::list<std::string> get_str_list(const std::string& str,
                                    const char *delims = ";,= \t");







extern void get_str_vec(const std::string& str,
    std::vector<std::string>& str_vec);
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/str_list.h"
extern void get_str_vec(const std::string& str,
                         const char *delims,
    std::vector<std::string>& str_vec);

std::vector<std::string> get_str_vec(const std::string& str,
                                     const char *delims = ";,= \t");






extern void get_str_set(const std::string& str,
   std::set<std::string>& str_list);
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/str_list.h"
template<class Compare = std::less<std::string> >
void get_str_set(const std::string& str,
                 const char *delims,
                 std::set<std::string, Compare>& str_list)
{
  str_list.clear();
  for_each_substr(str, delims, [&str_list] (auto token) {
                  str_list.emplace(token.begin(), token.end());
                  });
}

std::set<std::string> get_str_set(const std::string& str,
                                  const char *delims = ";,= \t");
# 116 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/str_list.h"
inline std::string str_join(const std::vector<std::string>& v, const std::string& sep)
{
  if (v.empty())
    return std::string();
  std::vector<std::string>::const_iterator i = v.begin();
  std::string r = *i;
  for (++i; i != v.end(); ++i) {
    r += sep;
    r += *i;
  }
  return r;
}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/options.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 1
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_features.h" 1
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_features.h"
const static uint64_t CEPH_FEATURE_UID = (1ULL<<0); const static uint64_t CEPH_FEATUREMASK_UID = (1ULL<<0 | (0ull));
const static uint64_t CEPH_FEATURE_NOSRCADDR = (1ULL<<1); const static uint64_t CEPH_FEATUREMASK_NOSRCADDR = (1ULL<<1 | (0ull));

const static uint64_t CEPH_FEATURE_SERVER_NAUTILUS = (1ULL<<2); const static uint64_t CEPH_FEATUREMASK_SERVER_NAUTILUS = (1ULL<<2 | ((1ull<<57)|(1ull<<28)));
const static uint64_t CEPH_FEATURE_FLOCK = (1ULL<<3); const static uint64_t CEPH_FEATUREMASK_FLOCK = (1ULL<<3 | (0ull));
const static uint64_t CEPH_FEATURE_SUBSCRIBE2 = (1ULL<<4); const static uint64_t CEPH_FEATUREMASK_SUBSCRIBE2 = (1ULL<<4 | (0ull));
const static uint64_t CEPH_FEATURE_MONNAMES = (1ULL<<5); const static uint64_t CEPH_FEATUREMASK_MONNAMES = (1ULL<<5 | (0ull));
const static uint64_t CEPH_FEATURE_RECONNECT_SEQ = (1ULL<<6); const static uint64_t CEPH_FEATUREMASK_RECONNECT_SEQ = (1ULL<<6 | (0ull));
const static uint64_t CEPH_FEATURE_DIRLAYOUTHASH = (1ULL<<7); const static uint64_t CEPH_FEATUREMASK_DIRLAYOUTHASH = (1ULL<<7 | (0ull));
const static uint64_t CEPH_FEATURE_OBJECTLOCATOR = (1ULL<<8); const static uint64_t CEPH_FEATUREMASK_OBJECTLOCATOR = (1ULL<<8 | (0ull));
const static uint64_t CEPH_FEATURE_PGID64 = (1ULL<<9); const static uint64_t CEPH_FEATUREMASK_PGID64 = (1ULL<<9 | (0ull));
const static uint64_t CEPH_FEATURE_INCSUBOSDMAP = (1ULL<<10); const static uint64_t CEPH_FEATUREMASK_INCSUBOSDMAP = (1ULL<<10 | (0ull));
const static uint64_t CEPH_FEATURE_PGPOOL3 = (1ULL<<11); const static uint64_t CEPH_FEATUREMASK_PGPOOL3 = (1ULL<<11 | (0ull));
const static uint64_t CEPH_FEATURE_OSDREPLYMUX = (1ULL<<12); const static uint64_t CEPH_FEATUREMASK_OSDREPLYMUX = (1ULL<<12 | (0ull));
const static uint64_t CEPH_FEATURE_OSDENC = (1ULL<<13); const static uint64_t CEPH_FEATUREMASK_OSDENC = (1ULL<<13 | (0ull));

const static uint64_t CEPH_FEATURE_SERVER_KRAKEN = (1ULL<<14); const static uint64_t CEPH_FEATUREMASK_SERVER_KRAKEN = (1ULL<<14 | (1ull<<57));
const static uint64_t CEPH_FEATURE_MONENC = (1ULL<<15); const static uint64_t CEPH_FEATUREMASK_MONENC = (1ULL<<15 | (0ull));

const static uint64_t CEPH_FEATURE_SERVER_O = (1ULL<<16); const static uint64_t CEPH_FEATUREMASK_SERVER_O = (1ULL<<16 | ((1ull<<57)|(1ull<<28)));

const static uint64_t CEPH_FEATURE_OS_PERF_STAT_NS = (1ULL<<17); const static uint64_t CEPH_FEATUREMASK_OS_PERF_STAT_NS = (1ULL<<17 | ((1ull<<57)|(1ull<<28)));
const static uint64_t CEPH_FEATURE_CRUSH_TUNABLES = (1ULL<<18); const static uint64_t CEPH_FEATUREMASK_CRUSH_TUNABLES = (1ULL<<18 | (0ull));

const static uint64_t CEPH_FEATURE_OSD_PGLOG_HARDLIMIT = (1ULL<<19); const static uint64_t CEPH_FEATUREMASK_OSD_PGLOG_HARDLIMIT = (1ULL<<19 | (1ull<<57));




const static uint64_t CEPH_FEATURE_SERVER_LUMINOUS = (1ULL<<21); const static uint64_t CEPH_FEATUREMASK_SERVER_LUMINOUS = (1ULL<<21 | (1ull<<57));
const static uint64_t CEPH_FEATURE_RESEND_ON_SPLIT = (1ULL<<21); const static uint64_t CEPH_FEATUREMASK_RESEND_ON_SPLIT = (1ULL<<21 | (1ull<<57));
const static uint64_t CEPH_FEATURE_RADOS_BACKOFF = (1ULL<<21); const static uint64_t CEPH_FEATUREMASK_RADOS_BACKOFF = (1ULL<<21 | (1ull<<57));
const static uint64_t CEPH_FEATURE_OSDMAP_PG_UPMAP = (1ULL<<21); const static uint64_t CEPH_FEATUREMASK_OSDMAP_PG_UPMAP = (1ULL<<21 | (1ull<<57));
const static uint64_t CEPH_FEATURE_CRUSH_CHOOSE_ARGS = (1ULL<<21); const static uint64_t CEPH_FEATUREMASK_CRUSH_CHOOSE_ARGS = (1ULL<<21 | (1ull<<57));


const static uint64_t CEPH_FEATURE_MSG_AUTH = (1ULL<<23); const static uint64_t CEPH_FEATUREMASK_MSG_AUTH = (1ULL<<23 | (0ull));

const static uint64_t CEPH_FEATURE_RECOVERY_RESERVATION_2 = (1ULL<<24); const static uint64_t CEPH_FEATUREMASK_RECOVERY_RESERVATION_2 = (1ULL<<24 | (1ull<<57));
const static uint64_t CEPH_FEATURE_CRUSH_TUNABLES2 = (1ULL<<25); const static uint64_t CEPH_FEATUREMASK_CRUSH_TUNABLES2 = (1ULL<<25 | (0ull));
const static uint64_t CEPH_FEATURE_CREATEPOOLID = (1ULL<<26); const static uint64_t CEPH_FEATUREMASK_CREATEPOOLID = (1ULL<<26 | (0ull));
const static uint64_t CEPH_FEATURE_REPLY_CREATE_INODE = (1ULL<<27); const static uint64_t CEPH_FEATUREMASK_REPLY_CREATE_INODE = (1ULL<<27 | (0ull));

const static uint64_t CEPH_FEATURE_SERVER_MIMIC = (1ULL<<28); const static uint64_t CEPH_FEATUREMASK_SERVER_MIMIC = (1ULL<<28 | (1ull<<57));
const static uint64_t CEPH_FEATURE_MDSENC = (1ULL<<29); const static uint64_t CEPH_FEATUREMASK_MDSENC = (1ULL<<29 | (0ull));
const static uint64_t CEPH_FEATURE_OSDHASHPSPOOL = (1ULL<<30); const static uint64_t CEPH_FEATUREMASK_OSDHASHPSPOOL = (1ULL<<30 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_MON_SINGLE_PAXOS = (1ULL<<31); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_MON_SINGLE_PAXOS = (1ULL<<31 | (0ull));






const static uint64_t CEPH_FEATURE_OSD_CACHEPOOL = (1ULL<<35); const static uint64_t CEPH_FEATUREMASK_OSD_CACHEPOOL = (1ULL<<35 | (0ull));
const static uint64_t CEPH_FEATURE_CRUSH_V2 = (1ULL<<36); const static uint64_t CEPH_FEATUREMASK_CRUSH_V2 = (1ULL<<36 | (0ull));
const static uint64_t CEPH_FEATURE_EXPORT_PEER = (1ULL<<37); const static uint64_t CEPH_FEATUREMASK_EXPORT_PEER = (1ULL<<37 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_OSD_ERASURE_CODES = (1ULL<<38); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_OSD_ERASURE_CODES = (1ULL<<38 | (0ull));
const static uint64_t CEPH_FEATURE_OSDMAP_ENC = (1ULL<<39); const static uint64_t CEPH_FEATUREMASK_OSDMAP_ENC = (1ULL<<39 | (0ull));
const static uint64_t CEPH_FEATURE_MDS_INLINE_DATA = (1ULL<<40); const static uint64_t CEPH_FEATUREMASK_MDS_INLINE_DATA = (1ULL<<40 | (0ull));
const static uint64_t CEPH_FEATURE_CRUSH_TUNABLES3 = (1ULL<<41); const static uint64_t CEPH_FEATUREMASK_CRUSH_TUNABLES3 = (1ULL<<41 | (0ull));
const static uint64_t CEPH_FEATURE_OSD_PRIMARY_AFFINITY = (1ULL<<41); const static uint64_t CEPH_FEATUREMASK_OSD_PRIMARY_AFFINITY = (1ULL<<41 | (0ull));
const static uint64_t CEPH_FEATURE_MSGR_KEEPALIVE2 = (1ULL<<42); const static uint64_t CEPH_FEATUREMASK_MSGR_KEEPALIVE2 = (1ULL<<42 | (0ull));
const static uint64_t CEPH_FEATURE_OSD_POOLRESEND = (1ULL<<43); const static uint64_t CEPH_FEATUREMASK_OSD_POOLRESEND = (1ULL<<43 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_ERASURE_CODE_PLUGINS_V2 = (1ULL<<44); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_ERASURE_CODE_PLUGINS_V2 = (1ULL<<44 | (0ull));


const static uint64_t CEPH_FEATURE_OSD_FADVISE_FLAGS = (1ULL<<46); const static uint64_t CEPH_FEATUREMASK_OSD_FADVISE_FLAGS = (1ULL<<46 | (0ull));




const static uint64_t CEPH_FEATURE_MDS_QUOTA = (1ULL<<47); const static uint64_t CEPH_FEATUREMASK_MDS_QUOTA = (1ULL<<47 | (0ull));
const static uint64_t CEPH_FEATURE_CRUSH_V4 = (1ULL<<48); const static uint64_t CEPH_FEATUREMASK_CRUSH_V4 = (1ULL<<48 | (0ull));



const static uint64_t DEPRECATED_CEPH_FEATURE_MON_METADATA = (1ULL<<50); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_MON_METADATA = (1ULL<<50 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_OSD_BITWISE_HOBJ_SORT = (1ULL<<51); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_OSD_BITWISE_HOBJ_SORT = (1ULL<<51 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_OSD_PROXY_WRITE_FEATURES = (1ULL<<52); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_OSD_PROXY_WRITE_FEATURES = (1ULL<<52 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_ERASURE_CODE_PLUGINS_V3 = (1ULL<<53); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_ERASURE_CODE_PLUGINS_V3 = (1ULL<<53 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_OSD_HITSET_GMT = (1ULL<<54); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_OSD_HITSET_GMT = (1ULL<<54 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_HAMMER_0_94_4 = (1ULL<<55); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_HAMMER_0_94_4 = (1ULL<<55 | (0ull));
const static uint64_t CEPH_FEATURE_NEW_OSDOP_ENCODING = (1ULL<<56); const static uint64_t CEPH_FEATUREMASK_NEW_OSDOP_ENCODING = (1ULL<<56 | (0ull));
const static uint64_t CEPH_FEATURE_MON_STATEFUL_SUB = (1ULL<<57); const static uint64_t CEPH_FEATUREMASK_MON_STATEFUL_SUB = (1ULL<<57 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_MON_ROUTE_OSDMAP = (1ULL<<57); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_MON_ROUTE_OSDMAP = (1ULL<<57 | (0ull));
const static uint64_t CEPH_FEATURE_SERVER_JEWEL = (1ULL<<57); const static uint64_t CEPH_FEATUREMASK_SERVER_JEWEL = (1ULL<<57 | (0ull));
const static uint64_t CEPH_FEATURE_CRUSH_TUNABLES5 = (1ULL<<58); const static uint64_t CEPH_FEATUREMASK_CRUSH_TUNABLES5 = (1ULL<<58 | (0ull));
const static uint64_t CEPH_FEATURE_NEW_OSDOPREPLY_ENCODING = (1ULL<<58); const static uint64_t CEPH_FEATUREMASK_NEW_OSDOPREPLY_ENCODING = (1ULL<<58 | (0ull));
const static uint64_t CEPH_FEATURE_FS_FILE_LAYOUT_V2 = (1ULL<<58); const static uint64_t CEPH_FEATUREMASK_FS_FILE_LAYOUT_V2 = (1ULL<<58 | (0ull));
const static uint64_t CEPH_FEATURE_FS_BTIME = (1ULL<<59); const static uint64_t CEPH_FEATUREMASK_FS_BTIME = (1ULL<<59 | (0ull));
const static uint64_t CEPH_FEATURE_FS_CHANGE_ATTR = (1ULL<<59); const static uint64_t CEPH_FEATUREMASK_FS_CHANGE_ATTR = (1ULL<<59 | (0ull));
const static uint64_t CEPH_FEATURE_MSG_ADDR2 = (1ULL<<59); const static uint64_t CEPH_FEATUREMASK_MSG_ADDR2 = (1ULL<<59 | (0ull));
const static uint64_t CEPH_FEATURE_OSD_RECOVERY_DELETES = (1ULL<<60); const static uint64_t CEPH_FEATUREMASK_OSD_RECOVERY_DELETES = (1ULL<<60 | (0ull));
const static uint64_t CEPH_FEATURE_CEPHX_V2 = (1ULL<<61); const static uint64_t CEPH_FEATUREMASK_CEPHX_V2 = (1ULL<<61 | (0ull));

const static uint64_t CEPH_FEATURE_RESERVED = (1ULL<<62); const static uint64_t CEPH_FEATUREMASK_RESERVED = (1ULL<<62 | (0ull));
const static uint64_t DEPRECATED_CEPH_FEATURE_RESERVED_BROKEN = (1ULL<<63); const static uint64_t DEPRECATED_CEPH_FEATUREMASK_RESERVED_BROKEN = (1ULL<<63 | (0ull));
# 272 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/ceph_features.h"
static inline void ____build_time_check_for_reserved_bits(void) {
 (void)(sizeof(int[((((CEPH_FEATURE_UID | CEPH_FEATURE_NOSRCADDR | CEPH_FEATURE_FLOCK | CEPH_FEATURE_SUBSCRIBE2 | CEPH_FEATURE_MONNAMES | CEPH_FEATURE_RECONNECT_SEQ | CEPH_FEATURE_DIRLAYOUTHASH | CEPH_FEATURE_OBJECTLOCATOR | CEPH_FEATURE_PGID64 | CEPH_FEATURE_INCSUBOSDMAP | CEPH_FEATURE_PGPOOL3 | CEPH_FEATURE_OSDREPLYMUX | CEPH_FEATURE_OSDENC | CEPH_FEATURE_MONENC | CEPH_FEATURE_CRUSH_TUNABLES | CEPH_FEATURE_MSG_AUTH | CEPH_FEATURE_CRUSH_TUNABLES2 | CEPH_FEATURE_CREATEPOOLID | CEPH_FEATURE_REPLY_CREATE_INODE | CEPH_FEATURE_MDSENC | CEPH_FEATURE_OSDHASHPSPOOL | CEPH_FEATURE_NEW_OSDOP_ENCODING | CEPH_FEATURE_NEW_OSDOPREPLY_ENCODING | DEPRECATED_CEPH_FEATURE_MON_SINGLE_PAXOS | CEPH_FEATURE_OSD_CACHEPOOL | CEPH_FEATURE_CRUSH_V2 | CEPH_FEATURE_EXPORT_PEER | DEPRECATED_CEPH_FEATURE_OSD_ERASURE_CODES | CEPH_FEATURE_OSDMAP_ENC | CEPH_FEATURE_MDS_INLINE_DATA | CEPH_FEATURE_CRUSH_TUNABLES3 | CEPH_FEATURE_OSD_PRIMARY_AFFINITY | CEPH_FEATURE_MSGR_KEEPALIVE2 | CEPH_FEATURE_OSD_POOLRESEND | DEPRECATED_CEPH_FEATURE_ERASURE_CODE_PLUGINS_V2 | CEPH_FEATURE_OSD_FADVISE_FLAGS | CEPH_FEATURE_MDS_QUOTA | CEPH_FEATURE_CRUSH_V4 | DEPRECATED_CEPH_FEATURE_MON_METADATA | DEPRECATED_CEPH_FEATURE_OSD_BITWISE_HOBJ_SORT | DEPRECATED_CEPH_FEATURE_ERASURE_CODE_PLUGINS_V3 | DEPRECATED_CEPH_FEATURE_OSD_PROXY_WRITE_FEATURES | DEPRECATED_CEPH_FEATURE_OSD_HITSET_GMT | DEPRECATED_CEPH_FEATURE_HAMMER_0_94_4 | CEPH_FEATURE_MON_STATEFUL_SUB | DEPRECATED_CEPH_FEATURE_MON_ROUTE_OSDMAP | CEPH_FEATURE_CRUSH_TUNABLES5 | CEPH_FEATURE_SERVER_JEWEL | CEPH_FEATURE_FS_FILE_LAYOUT_V2 | CEPH_FEATURE_SERVER_KRAKEN | CEPH_FEATURE_FS_BTIME | CEPH_FEATURE_FS_CHANGE_ATTR | CEPH_FEATURE_MSG_ADDR2 | CEPH_FEATURE_SERVER_LUMINOUS | CEPH_FEATURE_RESEND_ON_SPLIT | CEPH_FEATURE_RADOS_BACKOFF | CEPH_FEATURE_OSD_RECOVERY_DELETES | CEPH_FEATURE_SERVER_MIMIC | CEPH_FEATURE_RECOVERY_RESERVATION_2 | CEPH_FEATURE_SERVER_NAUTILUS | CEPH_FEATURE_CEPHX_V2 | CEPH_FEATURE_OSD_PGLOG_HARDLIMIT | 0ULL) & (CEPH_FEATURE_RESERVED | DEPRECATED_CEPH_FEATURE_RESERVED_BROKEN)) == 0)==0) ? -1 : 0]))

                                                       ;
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/blobhash.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/blobhash.h"
class blobhash {
public:
  uint32_t operator()(const char *p, unsigned len) {
    static rjhash<uint32_t> H;
    uint32_t acc = 0;
    while (len >= sizeof(acc)) {
      acc ^= *(uint32_t*)p;
      p += sizeof(uint32_t);
      len -= sizeof(uint32_t);
    }
    int sh = 0;
    while (len) {
      acc ^= (uint32_t)*p << sh;
      sh += 8;
      len--;
      p++;
    }
    return H(acc);
  }
};
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/encoding.h" 1
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 2



namespace ceph {
  class Formatter;
}

extern ostream& operator<<(ostream& out, const sockaddr_storage &ss);
extern ostream& operator<<(ostream& out, const sockaddr *sa);

typedef uint8_t entity_type_t;

class entity_name_t {
public:
  entity_type_t _type;
  int64_t _num;

public:
  static const int TYPE_MON = 0x01;
  static const int TYPE_MDS = 0x02;
  static const int TYPE_OSD = 0x04;
  static const int TYPE_CLIENT = 0x08;
  static const int TYPE_MGR = 0x10;

  static const int64_t NEW = -1;


  entity_name_t() : _type(0), _num(0) { }
  entity_name_t(int t, int64_t n) : _type(t), _num(n) { }
  explicit entity_name_t(const ceph_entity_name &n) :
    _type(n.type), _num(n.num) { }


  static entity_name_t MON(int64_t i=NEW) { return entity_name_t(TYPE_MON, i); }
  static entity_name_t MDS(int64_t i=NEW) { return entity_name_t(TYPE_MDS, i); }
  static entity_name_t OSD(int64_t i=NEW) { return entity_name_t(TYPE_OSD, i); }
  static entity_name_t CLIENT(int64_t i=NEW) { return entity_name_t(TYPE_CLIENT, i); }
  static entity_name_t MGR(int64_t i=NEW) { return entity_name_t(TYPE_MGR, i); }

  int64_t num() const { return _num; }
  int type() const { return _type; }
  const char *type_str() const {
    return ceph_entity_type_name(type());
  }

  bool is_new() const { return num() < 0; }

  bool is_client() const { return type() == TYPE_CLIENT; }
  bool is_mds() const { return type() == TYPE_MDS; }
  bool is_osd() const { return type() == TYPE_OSD; }
  bool is_mon() const { return type() == TYPE_MON; }
  bool is_mgr() const { return type() == TYPE_MGR; }

  operator ceph_entity_name() const {
    ceph_entity_name n = { _type, init_le64(_num) };
    return n;
  }

  bool parse(const string& s) {
    const char *start = s.c_str();
    char *end;
    bool got = parse(start, &end);
    return got && end == start + s.length();
  }
  bool parse(const char *start, char **end) {
    if (strstr(start, "mon.") == start) {
      _type = TYPE_MON;
      start += 4;
    } else if (strstr(start, "osd.") == start) {
      _type = TYPE_OSD;
      start += 4;
    } else if (strstr(start, "mds.") == start) {
      _type = TYPE_MDS;
      start += 4;
    } else if (strstr(start, "client.") == start) {
      _type = TYPE_CLIENT;
      start += 7;
    } else if (strstr(start, "mgr.") == start) {
      _type = TYPE_MGR;
      start += 4;
    } else {
      return false;
    }
    if (isspace(*start))
      return false;
    _num = strtoll(start, end, 10);
    if (*end == 
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
               __null 
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                    || *end == start)
      return false;
    return true;
  }

  static void _denc_start(size_t& p, __u8 *struct_v, __u8 *struct_compat, char **, uint32_t *) { p += 2 + 4; } static void _denc_finish(size_t& p, __u8 *struct_v, __u8 *struct_compat, char **, uint32_t *) { } static void _denc_start(bufferlist::contiguous_appender& p, __u8 *struct_v, __u8 *struct_compat, char **len_pos, uint32_t *start_oob_off) { denc(*struct_v, p); denc(*struct_compat, p); *len_pos = p.get_pos_add(4); *start_oob_off = p.get_out_of_band_offset(); } static void _denc_finish(bufferlist::contiguous_appender& p, __u8 *struct_v, __u8 *struct_compat, char **len_pos, uint32_t *start_oob_off) { *(ceph_le32*)*len_pos = p.get_pos() - *len_pos - sizeof(uint32_t) + p.get_out_of_band_offset() - *start_oob_off; } static void _denc_start(buffer::ptr::const_iterator& p, __u8 *struct_v, __u8 *struct_compat, char **start_pos, uint32_t *struct_len) { denc(*struct_v, p); denc(*struct_compat, p); denc(*struct_len, p); *start_pos = const_cast<char*>(p.get_pos()); } static void _denc_finish(buffer::ptr::const_iterator& p, __u8 *struct_v, __u8 *struct_compat, char **start_pos, uint32_t *struct_len) { const char *pos = p.get_pos(); char *end = *start_pos + *struct_len; do { static const ceph::assert_data assert_data_ctx = {"pos <= end", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h", 117, __PRETTY_FUNCTION__}; ((pos <= end) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false); if (pos < end) { p.advance(end - pos); } } void bound_encode(size_t& p) const { _denc_friend(*this, p); } void encode(bufferlist::contiguous_appender& p) const { ; _denc_friend(*this, p); ; } void decode(buffer::ptr::const_iterator& p) { _denc_friend(*this, p); } template<typename T, typename P> friend std::enable_if_t<std::is_same_v<T, entity_name_t> || std::is_same_v<T, const entity_name_t>> _denc_friend(T& v, P& p) {
    denc(v._type, p);
    denc(v._num, p);
  }
  void dump(Formatter *f) const;

  static void generate_test_instances(list<entity_name_t*>& o);
};
template<> struct denc_traits<entity_name_t> { static constexpr bool supported = true; static constexpr bool featured = false; static constexpr bool bounded = false; static constexpr bool need_contiguous = !_denc::has_legacy_denc<entity_name_t>::value; static void bound_encode(const entity_name_t& v, size_t& p, uint64_t f=0) { v.bound_encode(p); } static void encode(const entity_name_t& v, buffer::list::contiguous_appender& p, uint64_t f=0) { v.encode(p); } static void decode(entity_name_t& v, buffer::ptr::const_iterator& p, uint64_t f=0) { v.decode(p); } };

inline bool operator== (const entity_name_t& l, const entity_name_t& r) {
  return (l.type() == r.type()) && (l.num() == r.num()); }
inline bool operator!= (const entity_name_t& l, const entity_name_t& r) {
  return (l.type() != r.type()) || (l.num() != r.num()); }
inline bool operator< (const entity_name_t& l, const entity_name_t& r) {
  return (l.type() < r.type()) || (l.type() == r.type() && l.num() < r.num()); }

inline std::ostream& operator<<(std::ostream& out, const entity_name_t& addr) {

  if (addr.is_new() || addr.num() < 0)
    return out << addr.type_str() << ".?";
  else
    return out << addr.type_str() << '.' << addr.num();
}
inline std::ostream& operator<<(std::ostream& out, const ceph_entity_name& addr) {
  return out << entity_name_t{addr.type, static_cast<int64_t>(addr.num)};
}

namespace std {
  template<> struct hash< entity_name_t >
  {
    size_t operator()( const entity_name_t &m ) const
    {
      return rjhash32(m.type() ^ m.num());
    }
  };
}


struct ceph_sockaddr_storage {
  ceph_le16 ss_family;
  __u8 __ss_padding[128 - sizeof(ceph_le16)];

  void encode(bufferlist& bl) const {
    struct ceph_sockaddr_storage ss = *this;
    ss.ss_family = 
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                  __bswap_16 (
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                  ss.ss_family
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                  )
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                     ;
    ::encode_raw(ss, bl);
  }

  void decode(bufferlist::const_iterator& bl) {
    struct ceph_sockaddr_storage ss;
    ::decode_raw(ss, bl);
    ss.ss_family = 
# 169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                  __bswap_16 (
# 169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                  ss.ss_family
# 169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                  )
# 169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                     ;
    *this = ss;
  }
} __attribute__ ((__packed__));
inline void encode(const ceph_sockaddr_storage &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(ceph_sockaddr_storage &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }




static inline void encode(const sockaddr_storage& a, bufferlist& bl) {

  struct sockaddr_storage ss = a;
  ss.ss_family = 
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                __bswap_16 (
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                ss.ss_family
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                )
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                   ;
  ::encode_raw(ss, bl);
# 201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
}
static inline void decode(sockaddr_storage& a, bufferlist::const_iterator& bl) {

  ::decode_raw(a, bl);
  a.ss_family = 
# 205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
               __bswap_16 (
# 205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
               a.ss_family
# 205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
               )
# 205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                 ;
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
}







struct entity_addr_t {
  typedef enum {
    TYPE_NONE = 0,
    TYPE_LEGACY = 1,
    TYPE_MSGR2 = 2,
    TYPE_ANY = 3,
  } type_t;
  static const type_t TYPE_DEFAULT = TYPE_MSGR2;
  static std::string_view get_type_name(int t) {
    switch (t) {
    case TYPE_NONE: return "none";
    case TYPE_LEGACY: return "v1";
    case TYPE_MSGR2: return "v2";
    case TYPE_ANY: return "any";
    default: return "???";
    }
  };

  __u32 type;
  __u32 nonce;
  union {
    sockaddr sa;
    sockaddr_in sin;
    sockaddr_in6 sin6;
  } u;

  entity_addr_t() : type(0), nonce(0) {
    memset(&u, 0, sizeof(u));
  }
  entity_addr_t(__u32 _type, __u32 _nonce) : type(_type), nonce(_nonce) {
    memset(&u, 0, sizeof(u));
  }
  explicit entity_addr_t(const ceph_entity_addr &o) {
    type = o.type;
    nonce = o.nonce;
    memcpy(&u, &o.in_addr, sizeof(u));

    u.sa.sa_family = 
# 269 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                    __bswap_16 (
# 269 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                    u.sa.sa_family
# 269 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                    )
# 269 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                         ;

  }

  uint32_t get_type() const { return type; }
  void set_type(uint32_t t) { type = t; }
  bool is_legacy() const { return type == TYPE_LEGACY; }
  bool is_msgr2() const { return type == TYPE_MSGR2; }
  bool is_any() const { return type == TYPE_ANY; }

  __u32 get_nonce() const { return nonce; }
  void set_nonce(__u32 n) { nonce = n; }

  int get_family() const {
    return u.sa.sa_family;
  }
  void set_family(int f) {
    u.sa.sa_family = f;
  }

  bool is_ipv4() const {
    return u.sa.sa_family == 
# 290 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                            2
# 290 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                   ;
  }
  bool is_ipv6() const {
    return u.sa.sa_family == 
# 293 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                            10
# 293 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                    ;
  }

  sockaddr_in &in4_addr() {
    return u.sin;
  }
  const sockaddr_in &in4_addr() const{
    return u.sin;
  }
  sockaddr_in6 &in6_addr(){
    return u.sin6;
  }
  const sockaddr_in6 &in6_addr() const{
    return u.sin6;
  }
  const sockaddr *get_sockaddr() const {
    return &u.sa;
  }
  size_t get_sockaddr_len() const {
    switch (u.sa.sa_family) {
    case 
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        2
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
               :
      return sizeof(u.sin);
    case 
# 315 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        10
# 315 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                :
      return sizeof(u.sin6);
    }
    return sizeof(u);
  }
  bool set_sockaddr(const struct sockaddr *sa)
  {
    switch (sa->sa_family) {
    case 
# 323 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        2
# 323 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
               :

      memset(&u, 0, sizeof(u));
      memcpy(&u.sin, sa, sizeof(u.sin));
      break;
    case 
# 328 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        10
# 328 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                :

      memset(&u, 0, sizeof(u));
      memcpy(&u.sin6, sa, sizeof(u.sin6));
      break;
    case 
# 333 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        0
# 333 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                 :
      memset(&u, 0, sizeof(u));
      break;
    default:
      return false;
    }
    return true;
  }

  sockaddr_storage get_sockaddr_storage() const {
    sockaddr_storage ss;
    memcpy(&ss, &u, sizeof(u));
    memset((char*)&ss + sizeof(u), 0, sizeof(ss) - sizeof(u));
    return ss;
  }

  void set_in4_quad(int pos, int val) {
    u.sin.sin_family = 
# 350 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                      2
# 350 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                             ;
    unsigned char *ipq = (unsigned char*)&u.sin.sin_addr.s_addr;
    ipq[pos] = val;
  }
  void set_port(int port) {
    switch (u.sa.sa_family) {
    case 
# 356 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        2
# 356 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
               :
      u.sin.sin_port = 
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                      __bswap_16 (
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                      port
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                      )
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                 ;
      break;
    case 
# 359 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        10
# 359 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                :
      u.sin6.sin6_port = 
# 360 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                        __bswap_16 (
# 360 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                        port
# 360 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                        )
# 360 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                   ;
      break;
    default:
      __ceph_abort( "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h", 363, __PRETTY_FUNCTION__, "abort() called");
    }
  }
  int get_port() const {
    switch (u.sa.sa_family) {
    case 
# 368 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        2
# 368 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
               :
      return 
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
            __bswap_16 (
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
            u.sin.sin_port
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
            )
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                 ;
      break;
    case 
# 371 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        10
# 371 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                :
      return 
# 372 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
            __bswap_16 (
# 372 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
            u.sin6.sin6_port
# 372 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
            )
# 372 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                   ;
      break;
    }
    return 0;
  }

  operator ceph_entity_addr() const {
    ceph_entity_addr a;
    a.type = 0;
    a.nonce = nonce;
    a.in_addr = get_sockaddr_storage();

    a.in_addr.ss_family = 
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                         __bswap_16 (
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                         a.in_addr.ss_family
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                         )
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                                   ;

    return a;
  }

  bool probably_equals(const entity_addr_t &o) const {
    if (get_port() != o.get_port())
      return false;
    if (get_nonce() != o.get_nonce())
      return false;
    if (is_blank_ip() || o.is_blank_ip())
      return true;
    if (memcmp(&u, &o.u, sizeof(u)) == 0)
      return true;
    return false;
  }

  bool is_same_host(const entity_addr_t &o) const {
    if (u.sa.sa_family != o.u.sa.sa_family)
      return false;
    if (u.sa.sa_family == 
# 404 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                         2
# 404 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                )
      return u.sin.sin_addr.s_addr == o.u.sin.sin_addr.s_addr;
    if (u.sa.sa_family == 
# 406 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                         10
# 406 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                 )
      return memcmp(u.sin6.sin6_addr.
# 407 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                                    __in6_u.__u6_addr8
# 407 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                           ,
      o.u.sin6.sin6_addr.
# 408 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                        __in6_u.__u6_addr8
# 408 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                               ,
      sizeof(u.sin6.sin6_addr.
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                             __in6_u.__u6_addr8
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                    )) == 0;
    return false;
  }

  bool is_blank_ip() const {
    switch (u.sa.sa_family) {
    case 
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        2
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
               :
      return u.sin.sin_addr.s_addr == 
# 416 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                                     ((in_addr_t) 0x00000000)
# 416 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                               ;
    case 
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        10
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                :
      return memcmp(&u.sin6.sin6_addr, &in6addr_any, sizeof(in6addr_any)) == 0;
    default:
      return true;
    }
  }

  bool is_ip() const {
    switch (u.sa.sa_family) {
    case 
# 426 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        2
# 426 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
               :
    case 
# 427 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
        10
# 427 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                :
      return true;
    default:
      return false;
    }
  }

  std::string ip_only_to_str() const;

  std::string get_legacy_str() const {
    ostringstream ss;
    ss << get_sockaddr() << "/" << get_nonce();
    return ss.str();
  }

  bool parse(const char *s, const char **end = 0, int type=0);

  void decode_legacy_addr_after_marker(bufferlist::const_iterator& bl)
  {
    using ceph::decode;
    __u8 marker;
    __u16 rest;
    decode(marker, bl);
    decode(rest, bl);
    decode(nonce, bl);
    sockaddr_storage ss;
    decode(ss, bl);
    set_sockaddr((sockaddr*)&ss);
    if (get_family() == 
# 455 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h" 3 4
                       0
# 455 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/msg/msg_types.h"
                                ) {
      type = TYPE_NONE;
    } else {
      type = TYPE_LEGACY;
    }
  }





  void encode(bufferlist& bl, uint64_t features) const {
    using ceph::encode;
    if ((features & CEPH_FEATURE_MSG_ADDR2) == 0) {
      encode((__u32)0, bl);
      encode(nonce, bl);
      sockaddr_storage ss = get_sockaddr_storage();
      encode(ss, bl);
      return;
    }
    encode((__u8)1, bl);
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    if ((((features) & (CEPH_FEATUREMASK_SERVER_NAUTILUS)) == (CEPH_FEATUREMASK_SERVER_NAUTILUS))) {
      encode(type, bl);
    } else {



      auto t = type;
      if (t == TYPE_ANY) {
 t = TYPE_LEGACY;
      }
      encode(t, bl);
    }
    encode(nonce, bl);
    __u32 elen = get_sockaddr_len();



    encode(elen, bl);
    if (elen) {
      uint16_t ss_family = u.sa.sa_family;

      encode(ss_family, bl);
      elen -= sizeof(u.sa.sa_family);
      bl.append(u.sa.sa_data, elen);
    }
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ceph::decode;
    __u8 marker;
    decode(marker, bl);
    if (marker == 0) {
      decode_legacy_addr_after_marker(bl);
      return;
    }
    if (marker != 1)
      throw buffer::malformed_input("entity_addr_t marker != 1");
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(type, bl);
    decode(nonce, bl);
    __u32 elen;
    decode(elen, bl);
    if (elen) {



      uint16_t ss_family;
      if (elen < sizeof(ss_family)) {
 throw buffer::malformed_input("elen smaller than family len");
      }
      decode(ss_family, bl);
      u.sa.sa_family = ss_family;
      elen -= sizeof(ss_family);
      if (elen > get_sockaddr_len() - sizeof(u.sa.sa_family)) {
 throw buffer::malformed_input("elen exceeds sockaddr len");
      }
      bl.copy(elen, u.sa.sa_data);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;

  static void generate_test_instances(list<entity_addr_t*>& o);
};
inline void encode(const entity_addr_t &c, ::ceph::bufferlist &bl, uint64_t features) { ; c.encode(bl, features); ; } inline void decode(entity_addr_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

ostream& operator<<(ostream& out, const entity_addr_t &addr);

inline bool operator==(const entity_addr_t& a, const entity_addr_t& b) { return memcmp(&a, &b, sizeof(a)) == 0; }
inline bool operator!=(const entity_addr_t& a, const entity_addr_t& b) { return memcmp(&a, &b, sizeof(a)) != 0; }
inline bool operator<(const entity_addr_t& a, const entity_addr_t& b) { return memcmp(&a, &b, sizeof(a)) < 0; }
inline bool operator<=(const entity_addr_t& a, const entity_addr_t& b) { return memcmp(&a, &b, sizeof(a)) <= 0; }
inline bool operator>(const entity_addr_t& a, const entity_addr_t& b) { return memcmp(&a, &b, sizeof(a)) > 0; }
inline bool operator>=(const entity_addr_t& a, const entity_addr_t& b) { return memcmp(&a, &b, sizeof(a)) >= 0; }

namespace std {
  template<> struct hash< entity_addr_t >
  {
    size_t operator()( const entity_addr_t& x ) const
    {
      static blobhash H;
      return H((const char*)&x, sizeof(x));
    }
  };
}

struct entity_addrvec_t {
  vector<entity_addr_t> v;

  entity_addrvec_t() {}
  explicit entity_addrvec_t(const entity_addr_t& a) : v({ a }) {}

  unsigned size() const { return v.size(); }
  bool empty() const { return v.empty(); }

  entity_addr_t legacy_addr() const {
    for (auto& a : v) {
      if (a.type == entity_addr_t::TYPE_LEGACY) {
 return a;
      }
    }
    return entity_addr_t();
  }
  entity_addr_t as_legacy_addr() const {
    for (auto& a : v) {
      if (a.is_legacy()) {
 return a;
      }
      if (a.is_any()) {
 auto b = a;
 b.set_type(entity_addr_t::TYPE_LEGACY);
 return b;
      }
    }

    auto a = front();
    a.set_type(entity_addr_t::TYPE_LEGACY);
    return a;
  }
  entity_addr_t front() const {
    if (!v.empty()) {
      return v.front();
    }
    return entity_addr_t();
  }
  entity_addr_t legacy_or_front_addr() const {
    for (auto& a : v) {
      if (a.type == entity_addr_t::TYPE_LEGACY) {
 return a;
      }
    }
    if (!v.empty()) {
      return v.front();
    }
    return entity_addr_t();
  }
  string get_legacy_str() const {
    return legacy_or_front_addr().get_legacy_str();
  }

  entity_addr_t msgr2_addr() const {
    for (auto &a : v) {
      if (a.type == entity_addr_t::TYPE_MSGR2) {
        return a;
      }
    }
    return entity_addr_t();
  }
  bool has_msgr2() const {
    for (auto& a : v) {
      if (a.is_msgr2()) {
 return true;
      }
    }
    return false;
  }

  bool parse(const char *s, const char **end = 0);

  void get_ports(set<int> *ports) const {
    for (auto& a : v) {
      ports->insert(a.get_port());
    }
  }
  set<int> get_ports() const {
    set<int> r;
    get_ports(&r);
    return r;
  }

  void encode(bufferlist& bl, uint64_t features) const;
  void decode(bufferlist::const_iterator& bl);
  void dump(Formatter *f) const;
  static void generate_test_instances(list<entity_addrvec_t*>& ls);

  bool legacy_equals(const entity_addrvec_t& o) const {
    if (v == o.v) {
      return true;
    }
    if (v.size() == 1 &&
 front().is_legacy() &&
 front() == o.legacy_addr()) {
      return true;
    }
    if (o.v.size() == 1 &&
 o.front().is_legacy() &&
 o.front() == legacy_addr()) {
      return true;
    }
    return false;
  }

  bool probably_equals(const entity_addrvec_t& o) const {
    for (unsigned i = 0; i < v.size(); ++i) {
      if (!v[i].probably_equals(o.v[i])) {
 return false;
      }
    }
    return true;
  }
  bool contains(const entity_addr_t& a) const {
    for (auto& i : v) {
      if (a == i) {
 return true;
      }
    }
    return false;
  }
  bool is_same_host(const entity_addr_t& a) const {
    for (auto& i : v) {
      if (i.is_same_host(a)) {
 return true;
      }
    }
    return false;
  }

  friend ostream& operator<<(ostream& out, const entity_addrvec_t& av) {
    if (av.v.empty()) {
      return out;
    } else if (av.v.size() == 1) {
      return out << av.v[0];
    } else {
      return out << av.v;
    }
  }

  friend bool operator==(const entity_addrvec_t& l, const entity_addrvec_t& r) {
    return l.v == r.v;
  }
  friend bool operator!=(const entity_addrvec_t& l, const entity_addrvec_t& r) {
    return l.v != r.v;
  }
  friend bool operator<(const entity_addrvec_t& l, const entity_addrvec_t& r) {
    return l.v < r.v;
  }
};
inline void encode(const entity_addrvec_t &c, ::ceph::bufferlist &bl, uint64_t features) { ; c.encode(bl, features); ; } inline void decode(entity_addrvec_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); };

namespace std {
  template<> struct hash< entity_addrvec_t >
  {
    size_t operator()( const entity_addrvec_t& x ) const
    {
      static blobhash H;
      size_t r = 0;
      for (auto& i : x.v) {
 r += H((const char*)&i, sizeof(i));
      }
      return r;
    }
  };
}




struct entity_inst_t {
  entity_name_t name;
  entity_addr_t addr;
  entity_inst_t() {}
  entity_inst_t(entity_name_t n, const entity_addr_t& a) : name(n), addr(a) {}

  entity_inst_t(const ceph_entity_inst& i) : name(i.name), addr(i.addr) { }
  entity_inst_t(const ceph_entity_name& n, const ceph_entity_addr &a) : name(n), addr(a) {}
  operator ceph_entity_inst() {
    ceph_entity_inst i = {name, addr};
    return i;
  }

  void encode(bufferlist& bl, uint64_t features) const {
    using ceph::encode;
    encode(name, bl);
    encode(addr, bl, features);
  }
  void decode(bufferlist::const_iterator& bl) {
    using ceph::decode;
    decode(name, bl);
    decode(addr, bl);
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<entity_inst_t*>& o);
};
inline void encode(const entity_inst_t &c, ::ceph::bufferlist &bl, uint64_t features) { ; c.encode(bl, features); ; } inline void decode(entity_inst_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }


inline bool operator==(const entity_inst_t& a, const entity_inst_t& b) {
  return a.name == b.name && a.addr == b.addr;
}
inline bool operator!=(const entity_inst_t& a, const entity_inst_t& b) {
  return a.name != b.name || a.addr != b.addr;
}
inline bool operator<(const entity_inst_t& a, const entity_inst_t& b) {
  return a.name < b.name || (a.name == b.name && a.addr < b.addr);
}
inline bool operator<=(const entity_inst_t& a, const entity_inst_t& b) {
  return a.name < b.name || (a.name == b.name && a.addr <= b.addr);
}
inline bool operator>(const entity_inst_t& a, const entity_inst_t& b) { return b < a; }
inline bool operator>=(const entity_inst_t& a, const entity_inst_t& b) { return b <= a; }

namespace std {
  template<> struct hash< entity_inst_t >
  {
    size_t operator()( const entity_inst_t& x ) const
    {
      static hash< entity_name_t > H;
      static hash< entity_addr_t > I;
      return H(x.name) ^ I(x.addr);
    }
  };
}


inline ostream& operator<<(ostream& out, const entity_inst_t &i)
{
  return out << i.name << " " << i.addr;
}
inline ostream& operator<<(ostream& out, const ceph_entity_inst &i)
{
  entity_inst_t n = i;
  return out << n;
}
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/options.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/uuid.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/options.h" 2

struct Option {
  enum type_t {
    TYPE_UINT = 0,
    TYPE_INT = 1,
    TYPE_STR = 2,
    TYPE_FLOAT = 3,
    TYPE_BOOL = 4,
    TYPE_ADDR = 5,
    TYPE_ADDRVEC = 6,
    TYPE_UUID = 7,
    TYPE_SIZE = 8,
    TYPE_SECS = 9,
  };

  static const char *type_to_c_type_str(type_t t) {
    switch (t) {
    case TYPE_UINT: return "uint64_t";
    case TYPE_INT: return "int64_t";
    case TYPE_STR: return "std::string";
    case TYPE_FLOAT: return "double";
    case TYPE_BOOL: return "bool";
    case TYPE_ADDR: return "entity_addr_t";
    case TYPE_ADDRVEC: return "entity_addrvec_t";
    case TYPE_UUID: return "uuid_d";
    case TYPE_SIZE: return "size_t";
    case TYPE_SECS: return "secs";
    default: return "unknown";
    }
  }
  static const char *type_to_str(type_t t) {
    switch (t) {
    case TYPE_UINT: return "uint";
    case TYPE_INT: return "int";
    case TYPE_STR: return "str";
    case TYPE_FLOAT: return "float";
    case TYPE_BOOL: return "bool";
    case TYPE_ADDR: return "addr";
    case TYPE_ADDRVEC: return "addrvec";
    case TYPE_UUID: return "uuid";
    case TYPE_SIZE: return "size";
    case TYPE_SECS: return "secs";
    default: return "unknown";
    }
  }
  static int str_to_type(const std::string& s) {
    if (s == "uint") {
      return TYPE_UINT;
    }
    if (s == "int") {
      return TYPE_INT;
    }
    if (s == "str") {
      return TYPE_STR;
    }
    if (s == "float") {
      return TYPE_FLOAT;
    }
    if (s == "bool") {
      return TYPE_BOOL;
    }
    if (s == "addr") {
      return TYPE_ADDR;
    }
    if (s == "addrvec") {
      return TYPE_ADDRVEC;
    }
    if (s == "uuid") {
      return TYPE_UUID;
    }
    if (s == "size") {
      return TYPE_SIZE;
    }
    if (s == "secs") {
      return TYPE_SECS;
    }
    return -1;
  }






  enum level_t {
    LEVEL_BASIC = 0,
    LEVEL_ADVANCED = 1,
    LEVEL_DEV = 2,
    LEVEL_UNKNOWN = 3,
  };

  static const char *level_to_str(level_t l) {
    switch (l) {
      case LEVEL_BASIC: return "basic";
      case LEVEL_ADVANCED: return "advanced";
      case LEVEL_DEV: return "dev";
      default: return "unknown";
    }
  }

  enum flag_t {
    FLAG_RUNTIME = 0x1,
    FLAG_NO_MON_UPDATE = 0x2,
    FLAG_STARTUP = 0x4,
    FLAG_CLUSTER_CREATE = 0x8,
    FLAG_CREATE = 0x10,
    FLAG_MGR = 0x20,
    FLAG_MINIMAL_CONF = 0x40,
  };

  struct size_t {
    std::size_t value;
    operator uint64_t() const {
      return static_cast<uint64_t>(value);
    }
    bool operator==(const size_t& rhs) const {
      return value == rhs.value;
    }
  };

  using value_t = boost::variant<
    boost::blank,
    std::string,
    uint64_t,
    int64_t,
    double,
    bool,
    entity_addr_t,
    entity_addrvec_t,
    std::chrono::seconds,
    size_t,
    uuid_d>;
  const std::string name;
  const type_t type;
  const level_t level;

  std::string desc;
  std::string long_desc;

  unsigned flags = 0;

  int subsys = -1;

  value_t value;
  value_t daemon_value;

  static std::string to_str(const value_t& v);







  std::vector<const char*> services;






  std::vector<const char*> tags;

  std::vector<const char*> see_also;

  value_t min, max;
  std::vector<const char*> enum_allowed;
# 188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/options.h"
  typedef std::function<int(std::string *, std::string *)> validator_fn_t;
  validator_fn_t validator;

  Option(std::string const &name, type_t t, level_t l)
    : name(name), type(t), level(l)
  {



    switch (type) {
    case TYPE_INT:
      value = int64_t(0); break;
    case TYPE_UINT:
      value = uint64_t(0); break;
    case TYPE_STR:
      value = std::string(""); break;
    case TYPE_FLOAT:
      value = 0.0; break;
    case TYPE_BOOL:
      value = false; break;
    case TYPE_ADDR:
      value = entity_addr_t(); break;
    case TYPE_ADDRVEC:
      value = entity_addrvec_t(); break;
    case TYPE_UUID:
      value = uuid_d(); break;
    case TYPE_SIZE:
      value = size_t{0}; break;
    case TYPE_SECS:
      value = std::chrono::seconds{0}; break;
    default:
      __ceph_abort( "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/options.h", 219, __PRETTY_FUNCTION__, "abort() called");
    }
  }

  void dump_value(const char *field_name, const value_t &v, Formatter *f) const;


  int pre_validate(std::string *new_value, std::string *err) const;


  int validate(const Option::value_t &new_value, std::string *err) const;


  Option& set_value(value_t& v, const char *new_value) {
    v = std::string(new_value);
    return *this;
  }


  template<typename T>
  using is_not_integer = std::enable_if<!std::is_integral<T>::value ||
     std::is_same<T, bool>::value, int>;
  template<typename T>
  using is_integer = std::enable_if<std::is_integral<T>::value &&
        !std::is_same<T, bool>::value, int>;
  template<typename T, typename is_not_integer<T>::type = 0>
  Option& set_value(value_t& v, const T& new_value) {
    v = new_value;
    return *this;
  }




  template<typename T, typename is_integer<T>::type = 0>
  Option& set_value(value_t& v, T new_value) {
    switch (type) {
    case TYPE_INT:
      v = int64_t(new_value); break;
    case TYPE_UINT:
      v = uint64_t(new_value); break;
    case TYPE_FLOAT:
      v = double(new_value); break;
    case TYPE_BOOL:
      v = bool(new_value); break;
    case TYPE_SIZE:
      v = size_t{static_cast<std::size_t>(new_value)}; break;
    case TYPE_SECS:
      v = std::chrono::seconds{new_value}; break;
    default:
      std::cerr << "Bad type in set_value: " << name << ": "
                << typeid(T).name() << std::endl;
      __ceph_abort( "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/options.h", 271, __PRETTY_FUNCTION__, "abort() called");
    }
    return *this;
  }


  int parse_value(
    const std::string& raw_val,
    value_t *out,
    std::string *error_message,
    std::string *normalized_value=nullptr) const;

  template<typename T>
  Option& set_default(const T& v) {
    return set_value(value, v);
  }

  template<typename T>
  Option& set_daemon_default(const T& v) {
    return set_value(daemon_value, v);
  }
  Option& add_tag(const char* tag) {
    tags.push_back(tag);
    return *this;
  }
  Option& add_tag(const std::initializer_list<const char*>& ts) {
    tags.insert(tags.end(), ts);
    return *this;
  }
  Option& add_service(const char* service) {
    services.push_back(service);
    return *this;
  }
  Option& add_service(const std::initializer_list<const char*>& ss) {
    services.insert(services.end(), ss);
    return *this;
  }
  Option& add_see_also(const char* t) {
    see_also.push_back(t);
    return *this;
  }
  Option& add_see_also(const std::initializer_list<const char*>& ts) {
    see_also.insert(see_also.end(), ts);
    return *this;
  }
  Option& set_description(const char* new_desc) {
    desc = new_desc;
    return *this;
  }
  Option& set_long_description(const char* new_desc) {
    long_desc = new_desc;
    return *this;
  }

  template<typename T>
  Option& set_min(const T& mi) {
    set_value(min, mi);
    return *this;
  }

  template<typename T>
  Option& set_min_max(const T& mi, const T& ma) {
    set_value(min, mi);
    set_value(max, ma);
    return *this;
  }

  Option& set_enum_allowed(const std::vector<const char*>& allowed)
  {
    enum_allowed = allowed;
    return *this;
  }

  Option &set_flag(flag_t f) {
    flags |= f;
    return *this;
  }
  Option &set_flags(flag_t f) {
    flags |= f;
    return *this;
  }

  Option &set_validator(const validator_fn_t &validator_)
  {
    validator = validator_;
    return *this;
  }

  Option &set_subsys(int s) {
    subsys = s;
    return *this;
  }

  void dump(Formatter *f) const;
  void print(ostream *out) const;

  bool has_flag(flag_t f) const {
    return flags & f;
  }






  bool can_update_at_runtime() const
  {
    return
      (has_flag(FLAG_RUNTIME)
       || (!has_flag(FLAG_MGR)
    && (type == TYPE_BOOL || type == TYPE_INT
        || type == TYPE_UINT || type == TYPE_FLOAT
        || type == TYPE_SIZE || type == TYPE_SECS)))
      && !has_flag(FLAG_STARTUP)
      && !has_flag(FLAG_CLUSTER_CREATE)
      && !has_flag(FLAG_CREATE);
  }
};

extern const std::vector<Option> ceph_options;
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_tracker.h" 1


       
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_tracker.h"
class ConfigTracker {
public:
  virtual ~ConfigTracker() = default;
  virtual bool is_tracking(const std::string& name) const = 0;
};
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_values.h" 1


       







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/entity_name.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/entity_name.h"
# 1 "/usr/include/ifaddrs.h" 1 3 4
# 25 "/usr/include/ifaddrs.h" 3 4

# 25 "/usr/include/ifaddrs.h" 3 4
extern "C" {



struct ifaddrs
{
  struct ifaddrs *ifa_next;

  char *ifa_name;
  unsigned int ifa_flags;

  struct sockaddr *ifa_addr;
  struct sockaddr *ifa_netmask;
  union
  {




    struct sockaddr *ifu_broadaddr;
    struct sockaddr *ifu_dstaddr;
  } ifa_ifu;
# 56 "/usr/include/ifaddrs.h" 3 4
  void *ifa_data;
};
# 66 "/usr/include/ifaddrs.h" 3 4
extern int getifaddrs (struct ifaddrs **__ifap) throw ();


extern void freeifaddrs (struct ifaddrs *__ifa) throw ();

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/entity_name.h" 2
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/entity_name.h"

# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/entity_name.h"
struct EntityName
{
  void encode(bufferlist& bl) const {
    using ceph::encode;
    encode(type, bl);
    encode(id, bl);
  }
  void decode(bufferlist::const_iterator& bl) {
    using ceph::decode;
    uint32_t type_;
    std::string id_;
    decode(type_, bl);
    decode(id_, bl);
    set(type_, id_);
  }

  const std::string& to_str() const;
  const char *to_cstr() const;
  bool from_str(const std::string& s);
  void set(uint32_t type_, const std::string &id_);
  int set(const std::string &type_, const std::string &id_);
  void set_type(uint32_t type_);
  int set_type(const char *type);
  void set_id(const std::string &id_);
  void set_name(entity_name_t n);

  const char* get_type_str() const;

  uint32_t get_type() const { return type; }
  bool is_osd() const { return get_type() == 0x04; }
  bool is_mgr() const { return get_type() == 0x10; }
  bool is_mds() const { return get_type() == 0x02; }
  bool is_client() const { return get_type() == 0x08; }
  bool is_mon() const { return get_type() == 0x01; }

  const char * get_type_name() const;
  const std::string &get_id() const;
  bool has_default_id() const;

  static std::string get_valid_types_as_str();
  static uint32_t str_to_ceph_entity_type(std::string_view);

  friend bool operator<(const EntityName& a, const EntityName& b);
  friend std::ostream& operator<<(std::ostream& out, const EntityName& n);
  friend bool operator==(const EntityName& a, const EntityName& b);
  friend bool operator!=(const EntityName& a, const EntityName& b);

private:
  struct str_to_entity_type_t {
    uint32_t type;
    const char *str;
  };
  static const std::array<str_to_entity_type_t, 6> STR_TO_ENTITY_TYPE;

  uint32_t type = 0;
  std::string id;
  std::string type_id;
};

inline void encode(const EntityName &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(EntityName &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

inline bool operator==(const EntityName &l, const EntityName &r) { return l.type == r.type && l.id == r.id; } inline bool operator!=(const EntityName &l, const EntityName &r) { return l.type != r.type || l.id != r.id; }
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_values.h" 2







class ConfigValues {
  using values_t = std::map<std::string, map<int32_t,Option::value_t>>;
  values_t values;

  friend struct md_config_t;

public:
  EntityName name;

  string cluster;
  ceph::logging::SubsystemMap subsys;
  bool no_mon_config = false;
  bool log_early = false;


  using changed_set_t = std::set<std::string>;
  changed_set_t changed;
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_values.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/legacy_config_opts.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/legacy_config_opts.h"
public: std::string host;
public: entity_addr_t public_addr;
public: entity_addr_t public_bind_addr;
public: entity_addr_t cluster_addr;
public: std::string public_network;
public: std::string cluster_network;
public: bool lockdep;
public: bool lockdep_force_backtrace;
public: std::string run_dir;
public: std::string admin_socket;
public: std::string admin_socket_mode;

public: bool daemonize;
public: std::string setuser;
public: std::string setgroup;
public: std::string setuser_match_path;
public: std::string pid_file;
public: std::string chdir;
public: std::string restapi_log_level;
public: std::string restapi_base_url;
public: bool fatal_signal_handlers;
public: std::string crash_dir;
protected: std::string erasure_code_dir;

public: std::string log_file;
public: int64_t log_max_new;
public: int64_t log_max_recent;
public: bool log_to_file;
public: bool log_to_stderr;
public: bool err_to_stderr;
public: bool log_to_syslog;
public: bool err_to_syslog;
public: bool log_flush_on_exit;
public: double log_stop_at_utilization;
public: bool log_to_graylog;
public: bool err_to_graylog;
public: std::string log_graylog_host;
public: int64_t log_graylog_port;






public: std::string clog_to_monitors;
public: std::string clog_to_syslog;
public: std::string clog_to_syslog_level;
public: std::string clog_to_syslog_facility;
public: std::string clog_to_graylog;
public: std::string clog_to_graylog_host;
public: std::string clog_to_graylog_port;

public: std::string mon_cluster_log_to_syslog;
public: std::string mon_cluster_log_to_syslog_level;
public: std::string mon_cluster_log_to_syslog_facility;
public: bool mon_cluster_log_to_file;
public: std::string mon_cluster_log_file;
public: std::string mon_cluster_log_file_level;
public: std::string mon_cluster_log_to_graylog;
public: std::string mon_cluster_log_to_graylog_host;
public: std::string mon_cluster_log_to_graylog_port;

public: std::string enable_experimental_unrecoverable_data_corrupting_features;

protected: std::string plugin_dir;

public: bool xio_trace_mempool;
public: bool xio_trace_msgcnt;
public: bool xio_trace_xcon;
public: int64_t xio_queue_depth;
public: int64_t xio_mp_min;
public: int64_t xio_mp_max_64;
public: int64_t xio_mp_max_256;
public: int64_t xio_mp_max_1k;
public: int64_t xio_mp_max_page;
public: int64_t xio_mp_max_hint;
public: int64_t xio_portal_threads;
public: int64_t xio_max_conns_per_portal;
public: std::string xio_transport_type;
public: int64_t xio_max_send_inline;

public: bool compressor_zlib_isal;
public: int64_t compressor_zlib_level;

public: bool qat_compressor_enabled;

public: std::string plugin_crypto_accelerator;

public: bool mempool_debug;



public: std::string key;
public: std::string keyfile;
public: std::string keyring;
public: int64_t heartbeat_interval;
public: std::string heartbeat_file;
public: int64_t heartbeat_inject_failure;
public: bool perf;

protected: std::string ms_type;
public: std::string ms_public_type;
public: std::string ms_cluster_type;
public: bool ms_learn_addr_from_peer;
public: bool ms_tcp_nodelay;
public: int64_t ms_tcp_rcvbuf;
public: uint64_t ms_tcp_prefetch_max_size;
public: double ms_initial_backoff;
public: double ms_max_backoff;
public: bool ms_crc_data;
public: bool ms_crc_header;
public: bool ms_die_on_bad_msg;
public: bool ms_die_on_unhandled_msg;
public: bool ms_die_on_old_message;
public: bool ms_die_on_skipped_message;
public: bool ms_die_on_bug;
public: uint64_t ms_dispatch_throttle_bytes;
public: bool ms_bind_ipv6;
public: int64_t ms_bind_port_min;
public: int64_t ms_bind_port_max;
public: int64_t ms_bind_retry_count;
public: int64_t ms_bind_retry_delay;
public: bool ms_bind_before_connect;
public: int64_t ms_tcp_listen_backlog;
public: uint64_t ms_rwthread_stack_bytes;
public: uint64_t ms_connection_ready_timeout;
public: uint64_t ms_connection_idle_timeout;
public: uint64_t ms_pq_max_tokens_per_priority;
public: uint64_t ms_pq_min_cost;
public: uint64_t ms_inject_socket_failures;
protected: std::string ms_inject_delay_type;
public: std::string ms_inject_delay_msg_type;
public: double ms_inject_delay_max;
public: double ms_inject_delay_probability;
public: double ms_inject_internal_delays;
public: bool ms_dump_on_send;
public: int64_t ms_dump_corrupt_message_level;
public: uint64_t ms_async_op_threads;
public: uint64_t ms_async_max_op_threads;
public: std::string ms_async_rdma_device_name;
public: bool ms_async_rdma_enable_hugepage;
public: int64_t ms_async_rdma_buffer_size;
public: uint64_t ms_async_rdma_send_buffers;

public: uint64_t ms_async_rdma_receive_buffers;

public: uint64_t ms_async_rdma_receive_queue_len;

public: bool ms_async_rdma_support_srq;
public: uint64_t ms_async_rdma_port_num;
public: uint64_t ms_async_rdma_polling_us;
public: std::string ms_async_rdma_local_gid;
public: int64_t ms_async_rdma_roce_ver;
public: int64_t ms_async_rdma_sl;
public: int64_t ms_async_rdma_dscp;


public: bool ms_async_rdma_cm;
public: std::string ms_async_rdma_type;



public: int64_t ms_max_accept_failures;

public: int64_t ms_dpdk_port_id;
protected: std::string ms_dpdk_coremask;
public: std::string ms_dpdk_memory_channel;
public: std::string ms_dpdk_hugepages;
public: std::string ms_dpdk_pmd;
protected: std::string ms_dpdk_host_ipv4_addr;
protected: std::string ms_dpdk_gateway_ipv4_addr;
protected: std::string ms_dpdk_netmask_ipv4_addr;
public: bool ms_dpdk_lro;
public: bool ms_dpdk_hw_flow_control;

public: double ms_dpdk_hw_queue_weight;
public: bool ms_dpdk_debug_allow_loopback;
public: int64_t ms_dpdk_rx_buffer_count_per_core;

public: bool inject_early_sigterm;

public: std::string mon_data;
public: std::string mon_initial_members;
public: bool mon_compact_on_start;
public: bool mon_compact_on_bootstrap;
public: bool mon_compact_on_trim;
public: int64_t mon_osd_cache_size;

public: uint64_t mon_osd_cache_size_min;
public: uint64_t mon_memory_target;
public: bool mon_memory_autotune;
public: int64_t mon_cpu_threads;
public: int64_t mon_osd_mapping_pgs_per_chunk;
public: int64_t mon_clean_pg_upmaps_per_chunk;
public: int64_t mon_osd_max_creating_pgs;
public: int64_t mon_tick_interval;
public: int64_t mon_session_timeout;
public: double mon_subscribe_interval;
public: double mon_delta_reset_interval;
public: int64_t mon_osd_laggy_halflife;
public: double mon_osd_laggy_weight;
public: int64_t mon_osd_laggy_max_interval;
public: bool mon_osd_adjust_heartbeat_grace;
public: bool mon_osd_adjust_down_out_interval;
public: bool mon_osd_auto_mark_in;
public: bool mon_osd_auto_mark_auto_out_in;
public: bool mon_osd_auto_mark_new_in;
public: int64_t mon_osd_destroyed_out_interval;
public: int64_t mon_osd_down_out_interval;
public: double mon_osd_min_up_ratio;
public: double mon_osd_min_in_ratio;
public: double mon_osd_warn_op_age;
public: double mon_osd_err_op_age_ratio;
public: bool mon_osd_prime_pg_temp;
public: double mon_osd_prime_pg_temp_max_time;
public: double mon_osd_prime_pg_temp_max_estimate;
public: double mon_election_timeout;
public: double mon_lease;
public: double mon_lease_renew_interval_factor;
public: double mon_lease_ack_timeout_factor;
public: double mon_accept_timeout_factor;

public: double mon_clock_drift_allowed;
public: double mon_clock_drift_warn_backoff;
public: double mon_timecheck_interval;
public: double mon_timecheck_skew_interval;
public: double mon_pg_check_down_all_threshold;
public: double mon_cache_target_full_warn_ratio;
public: double mon_osd_full_ratio;
public: double mon_osd_backfillfull_ratio;
public: double mon_osd_nearfull_ratio;
public: std::string mon_osd_initial_require_min_compat_client;
public: bool mon_allow_pool_delete;
public: bool mon_fake_pool_delete;
public: uint64_t mon_globalid_prealloc;
public: int64_t mon_osd_report_timeout;
public: bool mon_warn_on_legacy_crush_tunables;
public: std::string mon_crush_min_required_version;
public: bool mon_warn_on_crush_straw_calc_version_zero;
public: bool mon_warn_on_osd_down_out_interval_zero;
public: bool mon_warn_on_cache_pools_without_hit_sets;
public: bool mon_warn_on_misplaced;
public: int64_t mon_min_osdmap_epochs;
public: int64_t mon_max_log_epochs;
public: int64_t mon_max_mdsmap_epochs;
public: int64_t mon_max_osd;
public: double mon_probe_timeout;
public: uint64_t mon_client_bytes;
public: uint64_t mon_log_max_summary;
public: uint64_t mon_daemon_bytes;
public: int64_t mon_max_log_entries_per_event;
public: uint64_t mon_reweight_min_pgs_per_osd;
public: uint64_t mon_reweight_min_bytes_per_osd;
public: int64_t mon_reweight_max_osds;
public: double mon_reweight_max_change;
public: bool mon_health_to_clog;
public: int64_t mon_health_to_clog_interval;
public: double mon_health_to_clog_tick_interval;
public: int64_t mon_data_avail_crit;
public: int64_t mon_data_avail_warn;
public: uint64_t mon_data_size_warn;
public: double mon_warn_pg_not_scrubbed_ratio;
public: double mon_warn_pg_not_deep_scrubbed_ratio;
public: int64_t mon_scrub_interval;
public: int64_t mon_scrub_timeout;
public: int64_t mon_scrub_max_keys;
public: double mon_scrub_inject_crc_mismatch;
public: double mon_scrub_inject_missing_keys;
public: int64_t mon_config_key_max_entry_size;
public: double mon_sync_timeout;
public: uint64_t mon_sync_max_payload_size;
public: bool mon_sync_debug;
public: double mon_inject_sync_get_chunk_delay;
public: int64_t mon_osd_force_trim_to;
public: int64_t mon_mds_force_trim_to;
public: bool mon_mds_skip_sanity;
public: int64_t mon_osd_snap_trim_queue_warn_on;


public: bool mon_debug_deprecated_as_obsolete;


public: bool mon_debug_dump_transactions;
public: bool mon_debug_dump_json;
public: std::string mon_debug_dump_location;
public: bool mon_debug_no_require_mimic;
public: bool mon_debug_no_require_bluestore_for_ec_overwrites;
public: bool mon_debug_no_initial_persistent_features;
public: double mon_inject_transaction_delay_max;
public: double mon_inject_transaction_delay_probability;

public: int64_t mon_sync_provider_kill_at;
public: int64_t mon_sync_requester_kill_at;
public: bool mon_force_quorum_join;
public: std::string mon_keyvaluedb;


public: bool mon_debug_unsafe_allow_tier_with_nonempty_snaps;
public: double mon_osd_blacklist_default_expire;
public: bool mon_osd_crush_smoke_test;

public: int64_t paxos_stash_full_interval;
public: int64_t paxos_max_join_drift;
public: double paxos_propose_interval;
public: double paxos_min_wait;
public: int64_t paxos_min;
public: int64_t paxos_trim_min;
public: int64_t paxos_trim_max;
public: int64_t paxos_service_trim_min;
public: int64_t paxos_service_trim_max;
public: int64_t paxos_kill_at;
public: std::string auth_cluster_required;
public: std::string auth_service_required;
public: std::string auth_client_required;
public: std::string auth_supported;
public: int64_t max_rotating_auth_attempts;
public: bool cephx_require_signatures;
public: bool cephx_cluster_require_signatures;
public: bool cephx_service_require_signatures;
public: int64_t cephx_require_version;
public: int64_t cephx_cluster_require_version;
public: int64_t cephx_service_require_version;
public: bool cephx_sign_messages;
public: double auth_mon_ticket_ttl;
public: double auth_service_ticket_ttl;
public: bool auth_debug;
public: uint64_t mon_client_hunt_parallel;
public: double mon_client_hunt_interval;
public: double mon_client_ping_interval;
public: double mon_client_ping_timeout;
public: double mon_client_hunt_interval_backoff;
public: double mon_client_hunt_interval_max_multiple;
public: int64_t mon_client_max_log_entries_per_message;
public: int64_t mon_client_directed_command_retry;
public: int64_t client_cache_size;
public: double client_cache_mid;
public: bool client_use_random_mds;
public: double client_mount_timeout;
public: double client_tick_interval;
public: std::string client_trace;
public: int64_t client_readahead_min;
public: int64_t client_readahead_max_bytes;
public: int64_t client_readahead_max_periods;
public: bool client_reconnect_stale;
public: std::string client_snapdir;
public: int64_t client_mount_uid;
public: int64_t client_mount_gid;
public: int64_t client_notify_timeout;
public: int64_t osd_client_watch_timeout;
public: int64_t client_caps_release_delay;
public: bool client_quota_df;
public: bool client_oc;
public: int64_t client_oc_size;
public: int64_t client_oc_max_dirty;
public: int64_t client_oc_target_dirty;
public: double client_oc_max_dirty_age;
public: int64_t client_oc_max_objects;
public: bool client_debug_getattr_caps;
public: bool client_debug_force_sync_read;
public: int64_t client_debug_inject_tick_delay;
public: uint64_t client_max_inline_size;
public: bool client_inject_release_failure;
public: bool client_inject_fixed_oldest_tid;
public: std::string client_metadata;
public: std::string client_acl_type;
public: bool client_permissions;
public: bool client_dirsize_rbytes;

public: bool client_try_dentry_invalidate;
public: bool client_check_pool_perm;
public: bool client_use_faked_inos;

public: std::string crush_location;
public: std::string crush_location_hook;
public: int64_t crush_location_hook_timeout;

public: double objecter_tick_interval;
public: double objecter_timeout;
public: uint64_t objecter_inflight_op_bytes;
public: uint64_t objecter_inflight_ops;
public: uint64_t objecter_completion_locks_per_session;
public: bool objecter_inject_no_watch_ping;
public: bool objecter_retry_writes_after_first_reply;
public: bool objecter_debug_inject_relock_delay;


public: uint64_t filer_max_purge_ops;

public: uint64_t filer_max_truncate_ops;

public: std::string mds_data;

public: uint64_t mds_max_xattr_pairs_size;
public: uint64_t mds_max_file_recover;
public: int64_t mds_dir_max_commit_size;
public: int64_t mds_dir_keys_per_op;
public: double mds_decay_halflife;
public: double mds_beacon_interval;
public: double mds_beacon_grace;
public: bool mds_enforce_unique_name;

public: bool mds_session_blacklist_on_timeout;
public: bool mds_session_blacklist_on_evict;

public: uint64_t mds_sessionmap_keys_per_op;
public: double mds_freeze_tree_timeout;
public: int64_t mds_health_summarize_threshold;
public: double mds_reconnect_timeout;

public: double mds_tick_interval;
public: double mds_dirstat_min_interval;
public: double mds_scatter_nudge_interval;
public: int64_t mds_client_prealloc_inos;
public: bool mds_early_reply;
public: int64_t mds_default_dir_hash;
public: bool mds_log_pause;
public: bool mds_log_skip_corrupt_events;
public: int64_t mds_log_max_events;
public: int64_t mds_log_events_per_segment;
public: int64_t mds_log_segment_size;
public: uint64_t mds_log_max_segments;
public: bool mds_bal_export_pin;
public: double mds_bal_sample_interval;
public: double mds_bal_replicate_threshold;
public: double mds_bal_unreplicate_threshold;
public: int64_t mds_bal_split_size;
public: double mds_bal_split_rd;
public: double mds_bal_split_wr;
public: int64_t mds_bal_split_bits;
public: int64_t mds_bal_merge_size;
public: int64_t mds_bal_fragment_size_max;
public: double mds_bal_fragment_fast_factor;
public: double mds_bal_idle_threshold;
public: int64_t mds_bal_max;
public: int64_t mds_bal_max_until;
public: int64_t mds_bal_mode;
public: double mds_bal_min_rebalance;
public: double mds_bal_min_start;
public: double mds_bal_need_min;
public: double mds_bal_need_max;
public: double mds_bal_midchunk;
public: double mds_bal_minchunk;
public: double mds_bal_target_decay;
public: double mds_replay_interval;
public: int64_t mds_shutdown_check;
public: int64_t mds_thrash_exports;
public: int64_t mds_thrash_fragments;
public: bool mds_dump_cache_on_map;
public: bool mds_dump_cache_after_rejoin;
public: bool mds_verify_scatter;
public: bool mds_debug_scatterstat;
public: bool mds_debug_frag;
public: bool mds_debug_auth_pins;
public: bool mds_debug_subtrees;
public: int64_t mds_kill_mdstable_at;
public: int64_t mds_kill_export_at;
public: int64_t mds_kill_import_at;
public: int64_t mds_kill_link_at;
public: int64_t mds_kill_rename_at;
public: int64_t mds_kill_openc_at;
public: int64_t mds_kill_journal_expire_at;
public: int64_t mds_kill_journal_replay_at;
public: uint64_t mds_journal_format;
public: int64_t mds_kill_create_at;
public: double mds_inject_traceless_reply_probability;


public: bool mds_wipe_sessions;
public: bool mds_wipe_ino_prealloc;
public: int64_t mds_skip_ino;
public: bool mds_enable_op_tracker;
public: uint64_t mds_op_history_size;
public: uint64_t mds_op_history_duration;
public: double mds_op_complaint_time;
public: int64_t mds_op_log_threshold;
public: uint64_t mds_snap_min_uid;
public: uint64_t mds_snap_max_uid;
public: bool mds_snap_rstat;
public: uint64_t mds_verify_backtrace;

public: uint64_t mds_max_completed_flushes;
public: uint64_t mds_max_completed_requests;

public: uint64_t mds_action_on_write_error;
public: double mds_mon_shutdown_timeout;


public: uint64_t mds_max_purge_files;

public: uint64_t mds_max_purge_ops;

public: double mds_max_purge_ops_per_pg;

public: double mds_purge_queue_busy_flush_period;

public: int64_t mds_root_ino_uid;
public: int64_t mds_root_ino_gid;

public: int64_t mds_max_scrub_ops_in_progress;


public: int64_t mds_damage_table_max_entries;


public: uint64_t mds_client_writeable_range_max_inc_objs;


public: bool osd_check_max_object_name_len_on_startup;


public: uint64_t osd_max_backfills;


public: int64_t osd_min_recovery_priority;


public: double osd_backfill_retry_interval;


public: double osd_recovery_retry_interval;


public: int64_t osd_agent_max_ops;
public: int64_t osd_agent_max_low_ops;
public: double osd_agent_min_evict_effort;
public: double osd_agent_quantize_effort;
public: double osd_agent_delay_time;


public: bool osd_find_best_info_ignore_history_les;


public: int64_t osd_agent_hist_halflife;



public: double osd_agent_slop;

public: uuid_d osd_uuid;
public: std::string osd_data;
public: std::string osd_journal;
public: int64_t osd_journal_size;
public: bool osd_journal_flush_on_shutdown;





public: uint64_t osd_os_flags;
public: int64_t osd_max_write_size;
public: uint64_t osd_max_pgls;
public: uint64_t osd_client_message_size_cap;
public: uint64_t osd_client_message_cap;
public: bool osd_crush_update_weight_set;
public: int64_t osd_crush_chooseleaf_type;
public: bool osd_pool_use_gmt_hitset;
public: bool osd_crush_update_on_start;
public: bool osd_class_update_on_start;
public: double osd_crush_initial_weight;
public: std::string osd_erasure_code_plugins;


public: bool osd_allow_recovery_below_min_size;

public: bool osd_pool_default_ec_fast_read;
public: int64_t osd_pool_default_flags;
public: bool osd_pool_default_flag_hashpspool;
public: bool osd_pool_default_flag_nodelete;
public: bool osd_pool_default_flag_nopgchange;
public: bool osd_pool_default_flag_nosizechange;
public: double osd_pool_default_hit_set_bloom_fpp;
public: double osd_pool_default_cache_target_dirty_ratio;
public: double osd_pool_default_cache_target_dirty_high_ratio;
public: double osd_pool_default_cache_target_full_ratio;
public: int64_t osd_pool_default_cache_min_flush_age;
public: int64_t osd_pool_default_cache_min_evict_age;
public: int64_t osd_pool_default_cache_max_evict_check_size;
public: int64_t osd_hit_set_min_size;
public: int64_t osd_hit_set_max_size;
public: std::string osd_hit_set_namespace;


public: uint64_t osd_tier_promote_max_objects_sec;
public: uint64_t osd_tier_promote_max_bytes_sec;

public: int64_t osd_objecter_finishers;

public: bool osd_map_dedup;
public: int64_t osd_map_cache_size;
public: int64_t osd_map_message_max;
public: size_t osd_map_message_max_bytes;
public: int64_t osd_map_share_max_epochs;
public: double osd_inject_bad_map_crc_probability;
public: bool osd_inject_failure_on_pg_removal;

public: int64_t osd_max_markdown_period;
public: int64_t osd_max_markdown_count;

public: uint64_t osd_op_pq_max_tokens_per_priority;
public: uint64_t osd_op_pq_min_cost;
public: bool osd_recover_clone_overlap;
public: int64_t osd_op_num_threads_per_shard;
public: int64_t osd_op_num_threads_per_shard_hdd;
public: int64_t osd_op_num_threads_per_shard_ssd;
public: int64_t osd_op_num_shards;
public: int64_t osd_op_num_shards_hdd;
public: int64_t osd_op_num_shards_ssd;
# 631 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/legacy_config_opts.h"
public: std::string osd_op_queue;

public: std::string osd_op_queue_cut_off;


public: double osd_op_queue_mclock_client_op_res;
public: double osd_op_queue_mclock_client_op_wgt;
public: double osd_op_queue_mclock_client_op_lim;
public: double osd_op_queue_mclock_osd_rep_op_res;
public: double osd_op_queue_mclock_osd_rep_op_wgt;
public: double osd_op_queue_mclock_osd_rep_op_lim;
public: double osd_op_queue_mclock_snap_res;
public: double osd_op_queue_mclock_snap_wgt;
public: double osd_op_queue_mclock_snap_lim;
public: double osd_op_queue_mclock_recov_res;
public: double osd_op_queue_mclock_recov_wgt;
public: double osd_op_queue_mclock_recov_lim;
public: double osd_op_queue_mclock_scrub_res;
public: double osd_op_queue_mclock_scrub_wgt;
public: double osd_op_queue_mclock_scrub_lim;
public: double osd_op_queue_mclock_pg_delete_res;
public: double osd_op_queue_mclock_pg_delete_wgt;
public: double osd_op_queue_mclock_pg_delete_lim;
public: double osd_op_queue_mclock_peering_event_res;
public: double osd_op_queue_mclock_peering_event_wgt;
public: double osd_op_queue_mclock_peering_event_lim;
public: double osd_op_queue_mclock_anticipation_timeout;

public: bool osd_ignore_stale_divergent_priors;




public: bool osd_read_ec_check_for_errors;



public: int64_t osd_recover_clone_overlap_limit;
public: int64_t osd_debug_feed_pullee;

public: int64_t osd_backfill_scan_min;
public: int64_t osd_backfill_scan_max;
public: int64_t osd_op_thread_timeout;
public: int64_t osd_op_thread_suicide_timeout;
public: double osd_recovery_sleep;
public: double osd_recovery_sleep_hdd;
public: double osd_recovery_sleep_ssd;
public: double osd_snap_trim_sleep;
public: bool osd_scrub_invalid_stats;
public: int64_t osd_command_thread_timeout;
public: int64_t osd_command_thread_suicide_timeout;
public: int64_t osd_heartbeat_interval;



public: int64_t osd_heartbeat_grace;
public: int64_t osd_heartbeat_min_peers;
public: bool osd_heartbeat_use_min_delay_socket;
public: int64_t osd_heartbeat_min_size;


public: uint64_t osd_pg_max_concurrent_snap_trims;

public: uint64_t osd_max_trimming_pgs;



public: double osd_heartbeat_min_healthy_ratio;

public: int64_t osd_mon_heartbeat_interval;
public: int64_t osd_mon_report_interval;
public: int64_t osd_mon_report_max_in_flight;
public: int64_t osd_beacon_report_interval;
public: int64_t osd_pg_stat_report_interval_max;
public: double osd_mon_ack_timeout;
public: double osd_stats_ack_timeout_factor;
public: double osd_stats_ack_timeout_decay;
public: int64_t osd_default_data_pool_replay_window;
public: bool osd_auto_mark_unfound_lost;
public: double osd_recovery_delay_start;
public: uint64_t osd_recovery_max_active;
public: uint64_t osd_recovery_max_single_start;
public: uint64_t osd_recovery_max_chunk;
public: uint64_t osd_recovery_max_omap_entries_per_chunk;
public: uint64_t osd_copyfrom_max_chunk;
public: uint64_t osd_push_per_object_cost;
public: uint64_t osd_max_push_cost;
public: uint64_t osd_max_push_objects;
public: int64_t osd_max_scrubs;
public: bool osd_scrub_during_recovery;
public: bool osd_repair_during_recovery;
public: int64_t osd_scrub_begin_hour;
public: int64_t osd_scrub_end_hour;
public: int64_t osd_scrub_begin_week_day;
public: int64_t osd_scrub_end_week_day;
public: double osd_scrub_load_threshold;
public: double osd_scrub_min_interval;
public: double osd_scrub_max_interval;
public: double osd_scrub_interval_randomize_ratio;
public: double osd_scrub_backoff_ratio;
public: int64_t osd_scrub_chunk_min;
public: int64_t osd_scrub_chunk_max;
public: double osd_scrub_sleep;
public: bool osd_scrub_auto_repair;
public: uint64_t osd_scrub_auto_repair_num_errors;
public: double osd_deep_scrub_interval;
public: double osd_deep_scrub_randomize_ratio;
public: int64_t osd_deep_scrub_stride;
public: int64_t osd_deep_scrub_keys;
public: int64_t osd_deep_scrub_update_digest_min_age;
public: bool osd_skip_data_digest;
public: uint64_t osd_deep_scrub_large_omap_object_key_threshold;
public: uint64_t osd_deep_scrub_large_omap_object_value_sum_threshold;
public: std::string osd_class_dir;
public: bool osd_open_classes_on_start;
public: std::string osd_class_load_list;
public: std::string osd_class_default_list;
public: bool osd_check_for_log_corruption;
public: bool osd_use_stale_snap;
public: std::string osd_rollback_to_cluster_snap;
public: uint64_t osd_default_notify_timeout;
public: int64_t osd_kill_backfill_at;


public: uint64_t osd_pg_epoch_persisted_max_stale;

public: uint64_t osd_min_pg_log_entries;
public: uint64_t osd_max_pg_log_entries;
public: uint64_t osd_pg_log_dups_tracked;
public: double osd_force_recovery_pg_log_entries_factor;
public: uint64_t osd_pg_log_trim_min;
public: uint64_t osd_pg_log_trim_max;
public: double osd_op_complaint_time;
public: int64_t osd_command_max_records;
public: uint64_t osd_max_pg_blocked_by;
public: int64_t osd_op_log_threshold;
public: bool osd_verify_sparse_read_holes;
public: bool osd_backoff_on_unfound;
public: bool osd_backoff_on_degraded;
public: bool osd_backoff_on_peering;
public: bool osd_debug_crash_on_ignored_backoff;
public: double osd_debug_inject_dispatch_delay_probability;
public: double osd_debug_inject_dispatch_delay_duration;
public: double osd_debug_drop_ping_probability;
public: int64_t osd_debug_drop_ping_duration;
public: bool osd_debug_op_order;
public: bool osd_debug_verify_missing_on_start;
public: bool osd_debug_verify_snaps;
public: bool osd_debug_verify_stray_on_activate;
public: bool osd_debug_skip_full_check_in_backfill_reservation;
public: double osd_debug_reject_backfill_probability;
public: bool osd_debug_inject_copyfrom_error;
public: bool osd_debug_misdirected_ops;
public: bool osd_debug_skip_full_check_in_recovery;
public: double osd_debug_random_push_read_error;
public: bool osd_debug_verify_cached_snaps;
public: double osd_debug_deep_scrub_sleep;
public: bool osd_debug_no_acting_change;
public: bool osd_debug_pretend_recovery_active;
public: bool osd_enable_op_tracker;
public: uint64_t osd_num_op_tracker_shard;
public: uint64_t osd_op_history_size;
public: uint64_t osd_op_history_duration;
public: uint64_t osd_op_history_slow_op_size;
public: double osd_op_history_slow_op_threshold;
public: int64_t osd_target_transaction_size;
public: double osd_failsafe_full_ratio;
public: bool osd_fast_fail_on_connection_refused;

public: int64_t osd_pg_object_context_cache_count;
public: bool osd_tracing;
public: bool osd_function_tracing;

public: bool osd_fast_info;


public: bool osd_debug_pg_log_writeout;
public: uint64_t osd_loop_before_reset_tphandle;
public: uint64_t osd_max_snap_prune_intervals_per_epoch;


public: int64_t threadpool_default_timeout;

public: int64_t threadpool_empty_queue_max_wait;

public: bool leveldb_log_to_ceph_log;
public: uint64_t leveldb_write_buffer_size;
public: uint64_t leveldb_cache_size;
public: uint64_t leveldb_block_size;
public: int64_t leveldb_bloom_size;
public: int64_t leveldb_max_open_files;
public: bool leveldb_compression;
public: bool leveldb_paranoid;
public: std::string leveldb_log;
public: bool leveldb_compact_on_mount;

public: std::string kinetic_host;
public: int64_t kinetic_port;
public: int64_t kinetic_user_id;
public: std::string kinetic_hmac_key;
public: bool kinetic_use_ssl;


public: bool rocksdb_log_to_ceph_log;
public: uint64_t rocksdb_cache_size;
public: double rocksdb_cache_row_ratio;
public: int64_t rocksdb_cache_shard_bits;
public: std::string rocksdb_cache_type;
public: int64_t rocksdb_block_size;
public: bool rocksdb_perf;
public: bool rocksdb_collect_compaction_stats;
public: bool rocksdb_collect_extended_stats;
public: bool rocksdb_collect_memory_stats;
public: bool rocksdb_enable_rmrange;


public: std::string filestore_rocksdb_options;

public: std::string mon_rocksdb_options;
# 859 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/legacy_config_opts.h"
public: uint64_t osd_client_op_priority;
public: uint64_t osd_recovery_op_priority;
public: uint64_t osd_peering_op_priority;

public: uint64_t osd_snap_trim_priority;
public: uint64_t osd_snap_trim_cost;

public: uint64_t osd_scrub_priority;

public: uint64_t osd_scrub_cost;


public: uint64_t osd_requested_scrub_priority;

public: uint64_t osd_pg_delete_priority;
public: uint64_t osd_pg_delete_cost;

public: uint64_t osd_recovery_priority;

public: uint64_t osd_recovery_cost;





public: uint64_t osd_recovery_op_warn_multiple;


public: double osd_mon_shutdown_timeout;
public: bool osd_shutdown_pgref_assert;

public: uint64_t osd_max_object_size;
public: uint64_t osd_max_object_name_len;
public: uint64_t osd_max_object_namespace_len;
public: uint64_t osd_max_attr_name_len;
public: uint64_t osd_max_attr_size;

public: uint64_t osd_max_omap_entries_per_request;
public: uint64_t osd_max_omap_bytes_per_request;

public: std::string osd_objectstore;
public: bool osd_objectstore_tracing;
public: bool osd_objectstore_fuse;

public: uint64_t osd_bench_small_size_max_iops;
public: uint64_t osd_bench_large_size_max_throughput;
public: uint64_t osd_bench_max_block_size;
public: uint64_t osd_bench_duration;

public: bool osd_blkin_trace_all;
public: bool osdc_blkin_trace_all;

public: bool osd_discard_disconnected_ops;

public: uint64_t memstore_device_bytes;
public: bool memstore_page_set;
public: uint64_t memstore_page_size;

public: bool bdev_debug_inflight_ios;
public: int64_t bdev_inject_crash;
public: int64_t bdev_inject_crash_flush_delay;
public: bool bdev_aio;
public: int64_t bdev_aio_poll_ms;
public: int64_t bdev_aio_max_queue_depth;
public: int64_t bdev_aio_reap_max;
public: int64_t bdev_block_size;
public: bool bdev_debug_aio;
public: double bdev_debug_aio_suicide_timeout;
public: double bdev_debug_aio_log_age;




public: bool bdev_nvme_unbind_from_kernel;
public: int64_t bdev_nvme_retry_count;
public: bool bdev_enable_discard;
public: bool bdev_async_discard;

public: bool objectstore_blackhole;

public: uint64_t bluefs_alloc_size;
public: uint64_t bluefs_shared_alloc_size;
public: uint64_t bluefs_max_prefetch;
public: uint64_t bluefs_min_log_runway;
public: uint64_t bluefs_max_log_runway;
public: double bluefs_log_compact_min_ratio;
public: uint64_t bluefs_log_compact_min_size;
public: uint64_t bluefs_min_flush_size;
public: bool bluefs_compact_log_sync;
public: bool bluefs_buffered_io;
public: bool bluefs_sync_write;
public: std::string bluefs_allocator;
public: bool bluefs_preextend_wal_files;

public: bool bluestore_bluefs;
public: bool bluestore_bluefs_env_mirror;
public: uint64_t bluestore_bluefs_min;
public: double bluestore_bluefs_min_ratio;
public: double bluestore_bluefs_max_ratio;
public: double bluestore_bluefs_gift_ratio;
public: double bluestore_bluefs_reclaim_ratio;
public: double bluestore_bluefs_balance_interval;

public: double bluestore_bluefs_alloc_failure_dump_interval;



public: bool bluestore_bluefs_db_compatibility;







public: std::string bluestore_block_path;
public: uint64_t bluestore_block_size;
public: bool bluestore_block_create;
public: std::string bluestore_block_db_path;
public: uint64_t bluestore_block_db_size;
public: bool bluestore_block_db_create;
public: std::string bluestore_block_wal_path;
public: uint64_t bluestore_block_wal_size;
public: bool bluestore_block_wal_create;
public: bool bluestore_block_preallocate_file;
public: bool bluestore_ignore_data_csum;
public: std::string bluestore_csum_type;
public: uint64_t bluestore_retry_disk_reads;
public: uint64_t bluestore_min_alloc_size;
public: uint64_t bluestore_min_alloc_size_hdd;
public: uint64_t bluestore_min_alloc_size_ssd;
public: uint64_t bluestore_max_alloc_size;
public: uint64_t bluestore_prefer_deferred_size;
public: uint64_t bluestore_prefer_deferred_size_hdd;
public: uint64_t bluestore_prefer_deferred_size_ssd;
public: std::string bluestore_compression_mode;
public: std::string bluestore_compression_algorithm;
public: uint64_t bluestore_compression_min_blob_size;
public: uint64_t bluestore_compression_min_blob_size_hdd;
public: uint64_t bluestore_compression_min_blob_size_ssd;
public: uint64_t bluestore_compression_max_blob_size;
public: uint64_t bluestore_compression_max_blob_size_hdd;
public: uint64_t bluestore_compression_max_blob_size_ssd;





public: int64_t bluestore_gc_enable_blob_threshold;





public: int64_t bluestore_gc_enable_total_threshold;

public: uint64_t bluestore_max_blob_size;
public: uint64_t bluestore_max_blob_size_hdd;
public: uint64_t bluestore_max_blob_size_ssd;





public: double bluestore_compression_required_ratio;
public: uint64_t bluestore_extent_map_shard_max_size;
public: uint64_t bluestore_extent_map_shard_target_size;
public: uint64_t bluestore_extent_map_shard_min_size;
public: double bluestore_extent_map_shard_target_size_slop;
public: uint64_t bluestore_extent_map_inline_shard_prealloc_size;
public: double bluestore_cache_trim_interval;
public: uint64_t bluestore_cache_trim_max_skip_pinned;
public: std::string bluestore_cache_type;
public: double bluestore_2q_cache_kin_ratio;
public: double bluestore_2q_cache_kout_ratio;
public: uint64_t bluestore_cache_size;
public: uint64_t bluestore_cache_size_hdd;
public: uint64_t bluestore_cache_size_ssd;
public: double bluestore_cache_meta_ratio;
public: double bluestore_cache_kv_ratio;
public: std::string bluestore_kvbackend;
public: std::string bluestore_allocator;
public: int64_t bluestore_freelist_blocks_per_key;
public: int64_t bluestore_bitmapallocator_blocks_per_zone;
public: int64_t bluestore_bitmapallocator_span_size;
public: uint64_t bluestore_max_deferred_txc;
public: std::string bluestore_rocksdb_options;
public: bool bluestore_fsck_on_mount;
public: bool bluestore_fsck_on_mount_deep;
public: bool bluestore_fsck_quick_fix_on_mount;
public: bool bluestore_fsck_on_umount;
public: bool bluestore_fsck_on_umount_deep;
public: bool bluestore_fsck_on_mkfs;
public: bool bluestore_fsck_on_mkfs_deep;
public: bool bluestore_sync_submit_transaction;
public: uint64_t bluestore_fsck_read_bytes_cap;
public: int64_t bluestore_fsck_quick_fix_threads;
public: uint64_t bluestore_throttle_bytes;
public: uint64_t bluestore_throttle_deferred_bytes;
public: uint64_t bluestore_throttle_cost_per_io_hdd;
public: uint64_t bluestore_throttle_cost_per_io_ssd;
public: uint64_t bluestore_throttle_cost_per_io;
public: uint64_t bluestore_deferred_batch_ops;
public: uint64_t bluestore_deferred_batch_ops_hdd;
public: uint64_t bluestore_deferred_batch_ops_ssd;
public: int64_t bluestore_nid_prealloc;
public: uint64_t bluestore_blobid_prealloc;
public: bool bluestore_clone_cow;
public: bool bluestore_default_buffered_read;
public: bool bluestore_default_buffered_write;
public: bool bluestore_debug_misc;
public: bool bluestore_debug_no_reuse_blocks;
public: int64_t bluestore_debug_small_allocations;
public: bool bluestore_debug_freelist;
public: double bluestore_debug_prefill;
public: int64_t bluestore_debug_prefragment_max;
public: bool bluestore_debug_inject_read_err;
public: int64_t bluestore_debug_randomize_serial_transaction;
public: bool bluestore_debug_omit_block_device_write;
public: bool bluestore_debug_fsck_abort;
public: bool bluestore_debug_omit_kv_commit;
public: bool bluestore_debug_permit_any_bdev_label;
public: double bluestore_debug_random_read_err;
public: bool bluestore_debug_inject_bug21040;
public: double bluestore_debug_inject_csum_err_probability;
public: bool bluestore_fsck_error_on_no_per_pool_stats;
public: bool bluestore_warn_on_bluefs_spillover;
public: bool bluestore_warn_on_legacy_statfs;
public: double bluestore_log_op_age;
public: double bluestore_log_omap_iterator_age;
public: double bluestore_log_collection_list_age;

public: uint64_t kstore_max_ops;
public: uint64_t kstore_max_bytes;
public: std::string kstore_backend;
public: std::string kstore_rocksdb_options;
public: bool kstore_fsck_on_mount;
public: bool kstore_fsck_on_mount_deep;
public: uint64_t kstore_nid_prealloc;
public: bool kstore_sync_transaction;
public: bool kstore_sync_submit_transaction;
public: uint64_t kstore_onode_map_size;
public: int64_t kstore_default_stripe_size;

public: std::string filestore_omap_backend;
public: std::string filestore_omap_backend_path;


public: bool filestore_wbthrottle_enable;
public: uint64_t filestore_wbthrottle_btrfs_bytes_start_flusher;
public: uint64_t filestore_wbthrottle_btrfs_bytes_hard_limit;
public: uint64_t filestore_wbthrottle_btrfs_ios_start_flusher;
public: uint64_t filestore_wbthrottle_btrfs_ios_hard_limit;
public: uint64_t filestore_wbthrottle_btrfs_inodes_start_flusher;
public: uint64_t filestore_wbthrottle_xfs_bytes_start_flusher;
public: uint64_t filestore_wbthrottle_xfs_bytes_hard_limit;
public: uint64_t filestore_wbthrottle_xfs_ios_start_flusher;
public: uint64_t filestore_wbthrottle_xfs_ios_hard_limit;
public: uint64_t filestore_wbthrottle_xfs_inodes_start_flusher;


public: uint64_t filestore_wbthrottle_btrfs_inodes_hard_limit;
public: uint64_t filestore_wbthrottle_xfs_inodes_hard_limit;


public: bool filestore_odsync_write;


public: double filestore_index_retry_probability;


public: bool filestore_debug_inject_read_err;
public: double filestore_debug_random_read_err;

public: bool filestore_debug_omap_check;
public: int64_t filestore_omap_header_cache_size;



public: uint64_t filestore_max_inline_xattr_size;
public: uint64_t filestore_max_inline_xattr_size_xfs;
public: uint64_t filestore_max_inline_xattr_size_btrfs;
public: uint64_t filestore_max_inline_xattr_size_other;


public: uint64_t filestore_max_inline_xattrs;
public: uint64_t filestore_max_inline_xattrs_xfs;
public: uint64_t filestore_max_inline_xattrs_btrfs;
public: uint64_t filestore_max_inline_xattrs_other;


public: uint64_t filestore_max_xattr_value_size;
public: uint64_t filestore_max_xattr_value_size_xfs;
public: uint64_t filestore_max_xattr_value_size_btrfs;






public: uint64_t filestore_max_xattr_value_size_other;

public: bool filestore_sloppy_crc;
public: int64_t filestore_sloppy_crc_block_size;

public: uint64_t filestore_max_alloc_hint_size;

public: double filestore_max_sync_interval;
public: double filestore_min_sync_interval;
public: bool filestore_btrfs_snap;
public: bool filestore_btrfs_clone_range;
public: bool filestore_zfs_snap;
public: bool filestore_fsync_flushes_journal_data;
public: bool filestore_fiemap;
public: bool filestore_punch_hole;
public: bool filestore_seek_data_hole;
public: bool filestore_splice;
public: bool filestore_fadvise;

public: bool filestore_collect_device_partition_information;
# 1187 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/legacy_config_opts.h"
public: bool filestore_xfs_extsize;

public: bool filestore_journal_parallel;
public: bool filestore_journal_writeahead;
public: bool filestore_journal_trailing;
public: uint64_t filestore_queue_max_ops;
public: uint64_t filestore_queue_max_bytes;

public: int64_t filestore_caller_concurrency;


public: double filestore_expected_throughput_bytes;

public: double filestore_expected_throughput_ops;


public: double filestore_queue_max_delay_multiple;

public: double filestore_queue_high_delay_multiple;


public: double filestore_queue_max_delay_multiple_bytes;

public: double filestore_queue_high_delay_multiple_bytes;


public: double filestore_queue_max_delay_multiple_ops;

public: double filestore_queue_high_delay_multiple_ops;


public: double filestore_queue_low_threshhold;
public: double filestore_queue_high_threshhold;

public: int64_t filestore_op_threads;
public: int64_t filestore_op_thread_timeout;
public: int64_t filestore_op_thread_suicide_timeout;
public: double filestore_commit_timeout;
public: int64_t filestore_fiemap_threshold;
public: int64_t filestore_merge_threshold;
public: int64_t filestore_split_multiple;
public: uint64_t filestore_split_rand_factor;
public: int64_t filestore_update_to;
public: bool filestore_blackhole;
public: int64_t filestore_fd_cache_size;
public: int64_t filestore_fd_cache_shards;
public: int64_t filestore_ondisk_finisher_threads;
public: int64_t filestore_apply_finisher_threads;
public: std::string filestore_dump_file;
public: int64_t filestore_kill_at;
public: int64_t filestore_inject_stall;
public: bool filestore_fail_eio;
public: bool filestore_debug_verify_split;
public: bool journal_dio;
public: bool journal_aio;
public: bool journal_force_aio;
public: int64_t journal_block_size;

public: bool journal_block_align;
public: uint64_t journal_write_header_frequency;
public: int64_t journal_max_write_bytes;
public: int64_t journal_max_write_entries;


public: double journal_throttle_low_threshhold;
public: double journal_throttle_high_threshhold;


public: double journal_throttle_high_multiple;

public: double journal_throttle_max_multiple;

public: int64_t journal_align_min_size;
public: int64_t journal_replay_from;
public: bool journal_zero_on_create;
public: bool journal_ignore_corruption;
public: bool journal_discard;

public: std::string fio_dir;

public: double rados_mon_op_timeout;
public: double rados_osd_op_timeout;
public: bool rados_tracing;

public: std::string nss_db_path;


public: size_t rgw_max_attr_name_len;
public: size_t rgw_max_attr_size;
public: uint64_t rgw_max_attrs_num_in_req;

public: int64_t rgw_max_chunk_size;
public: int64_t rgw_put_obj_min_window_size;
public: int64_t rgw_put_obj_max_window_size;
public: uint64_t rgw_max_put_size;
public: uint64_t rgw_max_put_param_size;
# 1293 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/legacy_config_opts.h"
public: uint64_t rgw_override_bucket_index_max_shards;




public: uint64_t rgw_bucket_index_max_aio;




public: bool rgw_enable_quota_threads;
public: bool rgw_enable_gc_threads;
public: bool rgw_enable_lc_threads;


public: std::string rgw_data;
public: std::string rgw_enable_apis;
public: bool rgw_cache_enabled;
public: int64_t rgw_cache_lru_size;
public: std::string rgw_socket_path;
public: std::string rgw_host;
public: std::string rgw_port;
public: std::string rgw_dns_name;
public: std::string rgw_dns_s3website_name;
public: std::string rgw_service_provider_name;
public: bool rgw_content_length_compat;
public: std::string rgw_lifecycle_work_time;
public: int64_t rgw_lc_lock_max_time;
public: int64_t rgw_lc_max_objs;
public: uint64_t rgw_lc_max_rules;
public: int64_t rgw_lc_debug_interval;
public: std::string rgw_script_uri;
public: std::string rgw_request_uri;
public: bool rgw_ignore_get_invalid_range;
public: std::string rgw_swift_url;
public: std::string rgw_swift_url_prefix;
public: std::string rgw_swift_auth_url;
public: std::string rgw_swift_auth_entry;
public: std::string rgw_swift_tenant_name;
public: bool rgw_swift_account_in_url;
public: bool rgw_swift_enforce_content_length;
public: std::string rgw_keystone_url;
public: std::string rgw_keystone_admin_token;
public: std::string rgw_keystone_admin_token_path;
public: std::string rgw_keystone_admin_user;
public: std::string rgw_keystone_admin_password;
public: std::string rgw_keystone_admin_password_path;
public: std::string rgw_keystone_admin_tenant;
public: std::string rgw_keystone_admin_project;
public: std::string rgw_keystone_admin_domain;
public: std::string rgw_keystone_barbican_user;
public: std::string rgw_keystone_barbican_password;
public: std::string rgw_keystone_barbican_tenant;
public: std::string rgw_keystone_barbican_project;
public: std::string rgw_keystone_barbican_domain;
public: int64_t rgw_keystone_api_version;
public: std::string rgw_keystone_accepted_roles;
public: std::string rgw_keystone_accepted_admin_roles;
public: int64_t rgw_keystone_token_cache_size;
public: int64_t rgw_keystone_revocation_interval;
public: bool rgw_keystone_verify_ssl;
public: bool rgw_keystone_implicit_tenants;
public: std::string rgw_cross_domain_policy;
public: std::string rgw_healthcheck_disabling_path;
public: bool rgw_s3_auth_use_rados;
public: bool rgw_s3_auth_use_keystone;
public: std::string rgw_s3_auth_order;
public: std::string rgw_barbican_url;
public: std::string rgw_opa_url;
public: std::string rgw_opa_token;
public: bool rgw_opa_verify_ssl;
public: bool rgw_use_opa_authz;



public: std::string rgw_ldap_uri;

public: std::string rgw_ldap_binddn;

public: std::string rgw_ldap_searchdn;

public: std::string rgw_ldap_dnattr;

public: std::string rgw_ldap_secret;

public: bool rgw_s3_auth_use_ldap;

public: std::string rgw_ldap_searchfilter;

public: std::string rgw_admin_entry;
public: bool rgw_enforce_swift_acls;
public: int64_t rgw_swift_token_expiration;
public: bool rgw_print_continue;
public: bool rgw_print_prohibited_content_length;
public: std::string rgw_remote_addr_param;
public: int64_t rgw_op_thread_timeout;
public: int64_t rgw_op_thread_suicide_timeout;
public: int64_t rgw_thread_pool_size;
public: int64_t rgw_num_control_oids;
public: bool rgw_verify_ssl;
# 1403 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/legacy_config_opts.h"
public: int64_t rgw_nfs_lru_lanes;
public: int64_t rgw_nfs_lru_lane_hiwat;
public: int64_t rgw_nfs_fhcache_partitions;
public: int64_t rgw_nfs_fhcache_size;
public: int64_t rgw_nfs_namespace_expire_secs;

public: int64_t rgw_nfs_max_gc;
public: int64_t rgw_nfs_write_completion_interval_s;


public: bool rgw_nfs_s3_fast_attrs;




public: std::string rgw_zone;
public: std::string rgw_zone_root_pool;
public: std::string rgw_default_zone_info_oid;
public: std::string rgw_region;
public: std::string rgw_region_root_pool;
public: std::string rgw_default_region_info_oid;
public: std::string rgw_zonegroup;
public: std::string rgw_zonegroup_root_pool;
public: std::string rgw_default_zonegroup_info_oid;
public: std::string rgw_realm;
public: std::string rgw_realm_root_pool;
public: std::string rgw_default_realm_info_oid;
public: std::string rgw_period_root_pool;
public: std::string rgw_period_latest_epoch_info_oid;
public: bool rgw_log_nonexistent_bucket;
public: std::string rgw_log_object_name;
public: bool rgw_log_object_name_utc;
public: int64_t rgw_usage_max_shards;
public: int64_t rgw_usage_max_user_shards;
public: bool rgw_enable_ops_log;
public: bool rgw_enable_usage_log;
public: bool rgw_ops_log_rados;
public: std::string rgw_ops_log_socket_path;
public: int64_t rgw_ops_log_data_backlog;
public: int64_t rgw_fcgi_socket_backlog;
public: int64_t rgw_usage_log_flush_threshold;
public: int64_t rgw_usage_log_tick_interval;
public: int64_t rgw_init_timeout;
public: std::string rgw_mime_types_file;
public: int64_t rgw_gc_max_objs;
public: int64_t rgw_gc_obj_min_wait;
public: int64_t rgw_gc_processor_max_time;
public: int64_t rgw_gc_processor_period;
public: int64_t rgw_gc_max_concurrent_io;
public: int64_t rgw_gc_max_trim_chunk;
public: int64_t rgw_s3_success_create_obj_status;
public: bool rgw_resolve_cname;
public: int64_t rgw_obj_stripe_size;
public: std::string rgw_extended_http_attrs;
public: int64_t rgw_exit_timeout_secs;
public: int64_t rgw_get_obj_window_size;
public: int64_t rgw_get_obj_max_req_size;
public: bool rgw_relaxed_s3_bucket_names;
public: std::string rgw_defer_to_bucket_acls;
public: int64_t rgw_list_buckets_max_chunk;
public: int64_t rgw_md_log_max_shards;
public: int64_t rgw_curl_wait_timeout_ms;
public: int64_t rgw_curl_low_speed_limit;
public: int64_t rgw_curl_low_speed_time;
public: bool rgw_copy_obj_progress;
public: int64_t rgw_copy_obj_progress_every_bytes;
public: int64_t rgw_obj_tombstone_cache_size;


public: int64_t rgw_data_log_window;
public: int64_t rgw_data_log_changes_size;
public: int64_t rgw_data_log_num_shards;
public: std::string rgw_data_log_obj_prefix;

public: int64_t rgw_bucket_quota_ttl;
public: double rgw_bucket_quota_soft_threshold;
public: int64_t rgw_bucket_quota_cache_size;
public: int64_t rgw_bucket_default_quota_max_objects;
public: int64_t rgw_bucket_default_quota_max_size;

public: bool rgw_expose_bucket;

public: std::string rgw_frontends;

public: int64_t rgw_user_quota_bucket_sync_interval;
public: int64_t rgw_user_quota_sync_interval;
public: bool rgw_user_quota_sync_idle_users;
public: int64_t rgw_user_quota_sync_wait_time;
public: int64_t rgw_user_default_quota_max_objects;
public: int64_t rgw_user_default_quota_max_size;

public: int64_t rgw_multipart_min_part_size;
public: int64_t rgw_multipart_part_upload_limit;

public: int64_t rgw_max_slo_entries;

public: int64_t rgw_olh_pending_timeout_sec;
public: int64_t rgw_user_max_buckets;

public: uint64_t rgw_objexp_gc_interval;
public: uint64_t rgw_objexp_hints_num_shards;
public: uint64_t rgw_objexp_chunk_size;

public: bool rgw_enable_static_website;
public: std::string rgw_log_http_headers;

public: int64_t rgw_num_async_rados_threads;
public: int64_t rgw_md_notify_interval_msec;
public: bool rgw_run_sync_thread;
public: int64_t rgw_sync_lease_period;
public: int64_t rgw_sync_log_trim_interval;

public: double rgw_sync_data_inject_err_probability;
public: double rgw_sync_meta_inject_err_probability;
public: int64_t rgw_sync_trace_history_size;
public: int64_t rgw_sync_trace_per_node_log_size;
public: int64_t rgw_sync_trace_servicemap_update_interval;


public: double rgw_period_push_interval;
public: double rgw_period_push_interval_max;

public: int64_t rgw_safe_max_objects_per_shard;
public: double rgw_shard_warning_threshold;


public: bool rgw_swift_versioning_enabled;

public: bool rgw_trust_forwarded_https;
public: bool rgw_crypt_require_ssl;
public: std::string rgw_crypt_default_encryption_key;
public: std::string rgw_crypt_s3_kms_encryption_keys;

public: bool rgw_crypt_suppress_logs;
public: int64_t rgw_list_bucket_min_readahead;

public: bool rgw_rest_getusage_op_compat;

public: bool throttler_perf_counter;


public: bool rgw_torrent_flag;
public: std::string rgw_torrent_tracker;
public: std::string rgw_torrent_createby;
public: std::string rgw_torrent_comment;
public: std::string rgw_torrent_encoding;
public: std::string rgw_torrent_origin;
public: int64_t rgw_torrent_sha_unit;

public: bool event_tracing;

public: bool debug_deliberately_leak_memory;
public: bool debug_asok_assert_abort;

public: std::string rgw_swift_custom_header;

public: bool rgw_swift_need_stats;

public: int64_t rgw_acl_grants_max_num;
public: int64_t rgw_cors_rules_max_num;
public: int64_t rgw_delete_multi_obj_max_num;
public: int64_t rgw_website_routing_rules_max_num;
public: std::string rgw_sts_entry;
public: std::string rgw_sts_key;
public: bool rgw_s3_auth_use_sts;
public: uint64_t rgw_sts_max_session_duration;
public: int64_t fake_statfs_for_testing;
public: std::string rgw_sts_token_introspection_url;
public: std::string rgw_sts_client_id;
public: std::string rgw_sts_client_secret;
public: bool debug_allow_any_pool_priority;
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_values.h" 2
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_values.h"
public:
  enum set_value_result_t {
    SET_NO_CHANGE,
    SET_NO_EFFECT,
    SET_HAVE_EFFECT,
  };



  set_value_result_t set_value(const std::string& key,
                               Option::value_t&& value,
                               int level);
  int rm_val(const std::string& key, int level);
  void set_logging(int which, const char* val);




  std::pair<Option::value_t, bool> get_value(const std::string& name,
                                             int level) const;
  template<typename Func> void for_each(Func&& func) const {
    for (const auto& [name,configs] : values) {
      func(name, configs);
    }
  }
  bool contains(const std::string& key) const;
};
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h" 2

class CephContext;

enum {
  CONF_DEFAULT,
  CONF_MON,
  CONF_FILE,
  CONF_ENV,
  CONF_CMDLINE,
  CONF_OVERRIDE,
  CONF_FINAL
};

extern const char *ceph_conf_level_name(int level);
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config.h"
struct md_config_t {
public:
  typedef boost::variant<int64_t ConfigValues::*,
                         uint64_t ConfigValues::*,
                         std::string ConfigValues::*,
                         double ConfigValues::*,
                         bool ConfigValues::*,
                         entity_addr_t ConfigValues::*,
    entity_addrvec_t ConfigValues::*,
                         uuid_d ConfigValues::*> member_ptr_t;


  typedef std::function<bool(
      const std::string &k, const std::string &v)> config_callback;


  const bool is_daemon;




  std::map<std::string, member_ptr_t> legacy_values;





  std::map<std::string, const Option&> schema;


  std::map<std::string,std::string> ignored_mon_values;


  mutable std::map<std::string, std::string> may_reexpand_meta;


  bufferlist values_bl;


  uint64_t values_bl_version = 0;


  bufferlist defaults_bl;

  typedef enum {
    OPT_INT, OPT_LONGLONG, OPT_STR, OPT_DOUBLE, OPT_FLOAT, OPT_BOOL,
    OPT_ADDR, OPT_ADDRVEC, OPT_U32, OPT_U64, OPT_UUID
  } opt_type_t;


  explicit md_config_t(ConfigValues& values,
         const ConfigTracker& tracker,
         bool is_daemon=false);
  ~md_config_t();


  int parse_config_files(ConfigValues& values, const ConfigTracker& tracker,
    const char *conf_files,
    std::ostream *warnings, int flags);


  void parse_env(unsigned entity_type,
   ConfigValues& values, const ConfigTracker& tracker,
   const char *env_var = "CEPH_ARGS");


  int parse_argv(ConfigValues& values, const ConfigTracker& tracker,
   std::vector<const char*>& args, int level=CONF_CMDLINE);


  void do_argv_commands(const ConfigValues& values) const;

  bool _internal_field(const string& k);

  void set_safe_to_start_threads();
  void _clear_safe_to_start_threads();


  const Option *find_option(const string& name) const;


  void set_val_default(ConfigValues& values,
         const ConfigTracker& tracker,
         const std::string& key, const std::string &val);


  int set_mon_vals(CephContext *cct,
      ConfigValues& values,
      const ConfigTracker& tracker,
      const map<std::string,std::string>& kv,
      config_callback config_cb);


  int injectargs(ConfigValues& values,
   const ConfigTracker& tracker,
   const std::string &s,
   std::ostream *oss);



  void set_val_or_die(ConfigValues& values, const ConfigTracker& tracker,
        const std::string &key, const std::string &val);



  int set_val(ConfigValues& values, const ConfigTracker& tracker,
       const std::string &key, const char *val,
              std::stringstream *err_ss=nullptr);
  int set_val(ConfigValues& values, const ConfigTracker& tracker,
       const std::string &key, const string& s,
              std::stringstream *err_ss=nullptr) {
    return set_val(values, tracker, key, s.c_str(), err_ss);
  }


  int rm_val(ConfigValues& values, const std::string& key);


  void get_config_bl(const ConfigValues& values,
       uint64_t have_version,
       bufferlist *bl,
       uint64_t *got_version);


  void get_defaults_bl(const ConfigValues& values, bufferlist *bl);



  int get_val(const ConfigValues& values, const std::string &key, char **buf, int len) const;
  int get_val(const ConfigValues& values, const std::string &key, std::string *val) const;
  Option::value_t get_val_generic(const ConfigValues& values, const std::string &key) const;
  template<typename T> const T get_val(const ConfigValues& values, const std::string &key) const;
  template<typename T, typename Callback, typename...Args>
  auto with_val(const ConfigValues& values, const string& key,
  Callback&& cb, Args&&... args) const ->
    std::result_of_t<Callback(const T&, Args...)> {
    return std::forward<Callback>(cb)(
      boost::get<T>(this->get_val_generic(values, key)),
      std::forward<Args>(args)...);
  }

  void get_all_keys(std::vector<std::string> *keys) const;


  void get_my_sections(const ConfigValues& values,
         std::vector <std::string> &sections) const;


  int get_all_sections(std::vector <std::string> &sections) const;



  int get_val_from_conf_file(const ConfigValues& values,
     const std::vector <std::string> &sections,
     std::string const &key, std::string &out, bool emeta) const;


  void show_config(const ConfigValues& values, std::ostream& out) const;

  void show_config(const ConfigValues& values, Formatter *f) const;


  void config_options(Formatter *f) const;


  void diff(const ConfigValues& values,
     Formatter *f,
     std::string name=string{}) const;


  void complain_about_parse_errors(CephContext *cct);

private:

  typedef boost::container::small_vector<pair<const Option*,
           const Option::value_t*>,
      4> expand_stack_t;

  void validate_schema();
  void validate_default_settings();

  int _get_val_cstr(const ConfigValues& values,
      const std::string &key, char **buf, int len) const;
  Option::value_t _get_val(const ConfigValues& values,
      const std::string &key,
      expand_stack_t *stack=0,
      std::ostream *err=0) const;
  Option::value_t _get_val(const ConfigValues& values,
      const Option& o,
      expand_stack_t *stack=0,
      std::ostream *err=0) const;
  const Option::value_t& _get_val_default(const Option& o) const;
  Option::value_t _get_val_nometa(const ConfigValues& values,
      const Option& o) const;

  int _rm_val(ConfigValues& values, const std::string& key, int level);

  void _refresh(ConfigValues& values, const Option& opt);

  void _show_config(const ConfigValues& values,
      std::ostream *out, Formatter *f) const;

  void _get_my_sections(const ConfigValues& values,
   std::vector <std::string> &sections) const;

  int _get_val_from_conf_file(const std::vector <std::string> &sections,
         const std::string &key, std::string &out) const;

  int parse_option(ConfigValues& values,
     const ConfigTracker& tracker,
     std::vector<const char*>& args,
     std::vector<const char*>::iterator& i,
     std::ostream *oss,
     int level);
  int parse_injectargs(ConfigValues& values,
         const ConfigTracker& tracker,
         std::vector<const char*>& args,
         std::ostream *oss);



  int _set_val(
    ConfigValues& values,
    const ConfigTracker& tracker,
    const std::string &val,
    const Option &opt,
    int level,
    std::string *error_message);

  template <typename T>
  void assign_member(member_ptr_t ptr, const Option::value_t &val);


  void update_legacy_vals(ConfigValues& values);
  void update_legacy_val(ConfigValues& values,
    const Option &opt,
    member_ptr_t member);

  Option::value_t _expand_meta(
    const ConfigValues& values,
    const Option::value_t& in,
    const Option *o,
    expand_stack_t *stack,
    std::ostream *err) const;

public:
  void early_expand_meta(const ConfigValues& values,
    std::string &val,
    std::ostream *oss) const;


  bool finalize_reexpand_meta(ConfigValues& values,
         const ConfigTracker& tracker);
private:


  void expand_all_meta();


  ConfFile cf;
public:
  std::deque<std::string> parse_errors;
private:



  bool safe_to_start_threads = false;

  bool do_show_config = false;
  string do_show_config_value;

  vector<Option> subsys_options;

public:
  string data_dir_option;

public:
  unsigned get_osd_pool_default_min_size(const ConfigValues& values,
                                         uint8_t size) const {
    uint8_t min_size = get_val<uint64_t>(values, "osd_pool_default_min_size");
    return min_size ? std::min(min_size, size) : (size - size / 2);
  }

  friend class test_md_config_t;
};

template<typename T>
const T md_config_t::get_val(const ConfigValues& values,
        const std::string &key) const {
  return boost::get<T>(this->get_val_generic(values, key));
}

inline std::ostream& operator<<(std::ostream& o, const boost::blank& ) {
      return o << "INVALID_CONFIG_VALUE";
}

int ceph_resolve_file_search(const std::string& filename_list,
        std::string& result);
# 7 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_obs.h" 1
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_obs.h"
namespace ceph {






template<class ConfigProxy>
class md_config_obs_impl {
public:
  virtual ~md_config_obs_impl() {}




  virtual const char** get_tracked_conf_keys() const = 0;

  virtual void handle_conf_change(const ConfigProxy& conf,
      const std::set <std::string> &changed) = 0;

  virtual void handle_subsys_change(const ConfigProxy& conf,
        const std::set<int>& changed) { }
};
}

using md_config_obs_t = ceph::md_config_obs_impl<ConfigProxy>;
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_obs_mgr.h" 1


       







class ConfigValues;



template<class ConfigObs>
class ObserverMgr : public ConfigTracker {

  using obs_map_t = std::multimap<std::string, ConfigObs*>;
  obs_map_t observers;

public:
  typedef std::map<ConfigObs*, std::set<std::string>> rev_obs_map;
  typedef std::function<void(ConfigObs*, const std::string&)> config_gather_cb;
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_obs_mgr.h"
  void add_observer(ConfigObs* observer);






  void remove_observer(ConfigObs* observer);

  void for_each_observer(config_gather_cb callback);

  template<class ConfigProxyT>
  void for_each_change(const std::set<std::string>& changes,
                       ConfigProxyT& proxy,
                       config_gather_cb callback, std::ostream *oss);
  bool is_tracking(const std::string& name) const override;
};
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_obs_mgr.h"
template<class ConfigObs>
void ObserverMgr<ConfigObs>::add_observer(ConfigObs* observer)
{
  const char **keys = observer->get_tracked_conf_keys();
  for (const char ** k = keys; *k; ++k) {
    observers.emplace(*k, observer);
  }
}

template<class ConfigObs>
void ObserverMgr<ConfigObs>::remove_observer(ConfigObs* observer)
{
  [[maybe_unused]] bool found_obs = false;
  for (auto o = observers.begin(); o != observers.end(); ) {
    if (o->second == observer) {
      observers.erase(o++);
      found_obs = true;
    } else {
      ++o;
    }
  }
  do { static const ceph::assert_data assert_data_ctx = {"found_obs", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_obs_mgr.h", 80, __PRETTY_FUNCTION__}; ((found_obs) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
}

template<class ConfigObs>
void ObserverMgr<ConfigObs>::for_each_observer(config_gather_cb callback)
{
  for (const auto& [key, obs] : observers) {
    callback(obs, key);
  }
}

template<class ConfigObs>
template<class ConfigProxyT>
void ObserverMgr<ConfigObs>::for_each_change(const std::set<std::string>& changes,
                                             ConfigProxyT& proxy,
                                             config_gather_cb callback, std::ostream *oss)
{


  string val;
  for (auto& key : changes) {
    auto [first, last] = observers.equal_range(key);
    if ((oss) && !proxy.get_val(key, &val)) {
      (*oss) << key << " = '" << val << "' ";
      if (first == last) {
        (*oss) << "(not observed, change may require restart) ";
      }
    }
    for (auto r = first; r != last; ++r) {
      callback(r->second, key);
    }
  }
}

template<class ConfigObs>
bool ObserverMgr<ConfigObs>::is_tracking(const std::string& name) const
{
  return observers.count(name) > 0;
}
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_mutex.h" 1



       
# 101 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_mutex.h"
namespace ceph {

  typedef std::mutex mutex;
  typedef std::recursive_mutex recursive_mutex;
  typedef std::condition_variable condition_variable;
  typedef std::shared_mutex shared_mutex;


  template <typename ...Args>
  std::mutex make_mutex(Args&& ...args) {
    return {};
  }
  template <typename ...Args>
  std::recursive_mutex make_recursive_mutex(Args&& ...args) {
    return {};
  }
  template <typename ...Args>
  std::shared_mutex make_shared_mutex(Args&& ...args) {
    return {};
  }






}
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h" 2




class ConfigProxy {
  static ConfigValues get_config_values(const ConfigProxy &config_proxy) {
    std::lock_guard locker(config_proxy.lock);
    return config_proxy.values;
  }




  ConfigValues values;
  using md_config_obs_t = ceph::md_config_obs_impl<ConfigProxy>;
  ObserverMgr<md_config_obs_t> obs_mgr;
  md_config_t config;




  mutable ceph::recursive_mutex lock =
    ceph::make_recursive_mutex("ConfigProxy::lock");

  class CallGate {
  private:
    uint32_t call_count = 0;
    ceph::mutex lock;
    ceph::condition_variable cond;
  public:
    CallGate()
      : lock(ceph::make_mutex("call::gate::lock")) {
    }

    void enter() {
      std::lock_guard<ceph::mutex> locker(lock);
      ++call_count;
    }
    void leave() {
      std::lock_guard<ceph::mutex> locker(lock);
      do { static const ceph::assert_data assert_data_ctx = {"call_count > 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h", 50, __PRETTY_FUNCTION__}; ((call_count > 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
      if (--call_count == 0) {
        cond.notify_all();
      }
    }
    void close() {
      std::unique_lock<ceph::mutex> locker(lock);
      while (call_count != 0) {
        cond.wait(locker);
      }
    }
  };

  void call_gate_enter(md_config_obs_t *obs) {
    auto p = obs_call_gate.find(obs);
    do { static const ceph::assert_data assert_data_ctx = {"p != obs_call_gate.end()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h", 65, __PRETTY_FUNCTION__}; ((p != obs_call_gate.end()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    p->second->enter();
  }
  void call_gate_leave(md_config_obs_t *obs) {
    auto p = obs_call_gate.find(obs);
    do { static const ceph::assert_data assert_data_ctx = {"p != obs_call_gate.end()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h", 70, __PRETTY_FUNCTION__}; ((p != obs_call_gate.end()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    p->second->leave();
  }
  void call_gate_close(md_config_obs_t *obs) {
    auto p = obs_call_gate.find(obs);
    do { static const ceph::assert_data assert_data_ctx = {"p != obs_call_gate.end()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h", 75, __PRETTY_FUNCTION__}; ((p != obs_call_gate.end()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    p->second->close();
  }

  using rev_obs_map_t = ObserverMgr<md_config_obs_t>::rev_obs_map;
  typedef std::unique_ptr<CallGate> CallGateRef;

  std::map<md_config_obs_t*, CallGateRef> obs_call_gate;

  void call_observers(std::unique_lock<ceph::recursive_mutex>& locker,
                      rev_obs_map_t& rev_obs) {

    locker.unlock();
    for (auto& [obs, keys] : rev_obs) {
      obs->handle_conf_change(*this, keys);
    }
    locker.lock();

    for (auto& rev_ob : rev_obs) {
      call_gate_leave(rev_ob.first);
    }
  }

  void map_observer_changes(md_config_obs_t *obs, const std::string &key,
                            rev_obs_map_t *rev_obs) {
    do { static const ceph::assert_data assert_data_ctx = {"true", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/config_proxy.h", 100, __PRETTY_FUNCTION__}; ((true) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

    auto [it, new_entry] = rev_obs->emplace(obs, std::set<std::string>{});
    it->second.emplace(key);
    if (new_entry) {



      call_gate_enter(obs);
    }
  }

public:
  explicit ConfigProxy(bool is_daemon)
    : config{values, obs_mgr, is_daemon}
  {}
  explicit ConfigProxy(const ConfigProxy &config_proxy)
    : values(get_config_values(config_proxy)),
      config{values, obs_mgr, config_proxy.config.is_daemon}
  {}
  const ConfigValues* operator->() const noexcept {
    return &values;
  }
  ConfigValues* operator->() noexcept {
    return &values;
  }
  int get_val(const std::string& key, char** buf, int len) const {
    std::lock_guard l{lock};
    return config.get_val(values, key, buf, len);
  }
  int get_val(const std::string &key, std::string *val) const {
    std::lock_guard l{lock};
    return config.get_val(values, key, val);
  }
  template<typename T>
  const T get_val(const std::string& key) const {
    std::lock_guard l{lock};
    return config.template get_val<T>(values, key);
  }
  template<typename T, typename Callback, typename...Args>
  auto with_val(const string& key, Callback&& cb, Args&&... args) const {
    std::lock_guard l{lock};
    return config.template with_val<T>(values, key,
           std::forward<Callback>(cb),
           std::forward<Args>(args)...);
  }
  void config_options(Formatter *f) const {
    config.config_options(f);
  }
  const decltype(md_config_t::schema)& get_schema() const {
    return config.schema;
  }
  const Option* get_schema(const std::string& key) const {
    auto found = config.schema.find(key);
    if (found == config.schema.end()) {
      return nullptr;
    } else {
      return &found->second;
    }
  }
  const Option *find_option(const string& name) const {
    return config.find_option(name);
  }
  void diff(Formatter *f, const std::string& name=string{}) const {
    std::lock_guard l{lock};
    return config.diff(values, f, name);
  }
  void get_my_sections(std::vector <std::string> &sections) const {
    std::lock_guard l{lock};
    config.get_my_sections(values, sections);
  }
  int get_all_sections(std::vector<std::string>& sections) const {
    std::lock_guard l{lock};
    return config.get_all_sections(sections);
  }
  int get_val_from_conf_file(const std::vector<std::string>& sections,
        const std::string& key, std::string& out,
        bool emeta) const {
    std::lock_guard l{lock};
    return config.get_val_from_conf_file(values,
      sections, key, out, emeta);
  }
  unsigned get_osd_pool_default_min_size(uint8_t size) const {
    return config.get_osd_pool_default_min_size(values, size);
  }
  void early_expand_meta(std::string &val,
    std::ostream *oss) const {
    std::lock_guard l{lock};
    return config.early_expand_meta(values, val, oss);
  }

  void finalize_reexpand_meta() {
    std::unique_lock locker(lock);
    rev_obs_map_t rev_obs;
    if (config.finalize_reexpand_meta(values, obs_mgr)) {
      _gather_changes(values.changed, &rev_obs, nullptr);
      values.changed.clear();
    }

    call_observers(locker, rev_obs);
  }
  void add_observer(md_config_obs_t* obs) {
    std::lock_guard l(lock);
    obs_mgr.add_observer(obs);
    obs_call_gate.emplace(obs, std::make_unique<CallGate>());
  }
  void remove_observer(md_config_obs_t* obs) {
    std::lock_guard l(lock);
    call_gate_close(obs);
    obs_call_gate.erase(obs);
    obs_mgr.remove_observer(obs);
  }
  void call_all_observers() {
    std::unique_lock locker(lock);
    rev_obs_map_t rev_obs;
    obs_mgr.for_each_observer(
      [this, &rev_obs](md_config_obs_t *obs, const std::string &key) {
        map_observer_changes(obs, key, &rev_obs);
      });

    call_observers(locker, rev_obs);
  }
  void set_safe_to_start_threads() {
    config.set_safe_to_start_threads();
  }
  void _clear_safe_to_start_threads() {
    config._clear_safe_to_start_threads();
  }
  void show_config(std::ostream& out) {
    std::lock_guard l{lock};
    config.show_config(values, out);
  }
  void show_config(Formatter *f) {
    std::lock_guard l{lock};
    config.show_config(values, f);
  }
  void config_options(Formatter *f) {
    std::lock_guard l{lock};
    config.config_options(f);
  }
  int rm_val(const std::string& key) {
    std::lock_guard l{lock};
    return config.rm_val(values, key);
  }

  void apply_changes(std::ostream* oss) {
    std::unique_lock locker(lock);
    rev_obs_map_t rev_obs;


    if (!values.cluster.empty()) {

      _gather_changes(values.changed, &rev_obs, oss);
      values.changed.clear();
    }

    call_observers(locker, rev_obs);
  }
  void _gather_changes(std::set<std::string> &changes,
                       rev_obs_map_t *rev_obs, std::ostream* oss) {
    obs_mgr.for_each_change(
      changes, *this,
      [this, rev_obs](md_config_obs_t *obs, const std::string &key) {
        map_observer_changes(obs, key, rev_obs);
      }, oss);
  }
  int set_val(const std::string& key, const std::string& s,
              std::stringstream* err_ss=nullptr) {
    std::lock_guard l{lock};
    return config.set_val(values, obs_mgr, key, s, err_ss);
  }
  void set_val_default(const std::string& key, const std::string& val) {
    std::lock_guard l{lock};
    config.set_val_default(values, obs_mgr, key, val);
  }
  void set_val_or_die(const std::string& key, const std::string& val) {
    std::lock_guard l{lock};
    config.set_val_or_die(values, obs_mgr, key, val);
  }
  int set_mon_vals(CephContext *cct,
     const map<std::string,std::string>& kv,
     md_config_t::config_callback config_cb) {
    std::unique_lock locker(lock);
    int ret = config.set_mon_vals(cct, values, obs_mgr, kv, config_cb);

    rev_obs_map_t rev_obs;
    _gather_changes(values.changed, &rev_obs, nullptr);
    values.changed.clear();

    call_observers(locker, rev_obs);
    return ret;
  }
  int injectargs(const std::string &s, std::ostream *oss) {
    std::unique_lock locker(lock);
    int ret = config.injectargs(values, obs_mgr, s, oss);

    rev_obs_map_t rev_obs;
    _gather_changes(values.changed, &rev_obs, oss);
    values.changed.clear();

    call_observers(locker, rev_obs);
    return ret;
  }
  void parse_env(unsigned entity_type,
   const char *env_var = "CEPH_ARGS") {
    std::lock_guard l{lock};
    config.parse_env(entity_type, values, obs_mgr, env_var);
  }
  int parse_argv(std::vector<const char*>& args, int level=CONF_CMDLINE) {
    std::lock_guard l{lock};
    return config.parse_argv(values, obs_mgr, args, level);
  }
  int parse_config_files(const char *conf_files,
    std::ostream *warnings, int flags) {
    std::lock_guard l{lock};
    return config.parse_config_files(values, obs_mgr,
         conf_files, warnings, flags);
  }
  size_t num_parse_errors() const {
    return config.parse_errors.size();
  }
  void complain_about_parse_errors(CephContext *cct) {
    return config.complain_about_parse_errors(cct);
  }
  void do_argv_commands() const {
    std::lock_guard l{lock};
    config.do_argv_commands(values);
  }
  void get_config_bl(uint64_t have_version,
       bufferlist *bl,
       uint64_t *got_version) {
    std::lock_guard l{lock};
    config.get_config_bl(values, have_version, bl, got_version);
  }
  void get_defaults_bl(bufferlist *bl) {
    std::lock_guard l{lock};
    config.get_defaults_bl(values, bl);
  }
};
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/spinlock.h" 1
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/spinlock.h"
namespace ceph {
inline namespace version_1_0 {

class spinlock;

inline void spin_lock(std::atomic_flag& lock);
inline void spin_unlock(std::atomic_flag& lock);
inline void spin_lock(ceph::spinlock& lock);
inline void spin_unlock(ceph::spinlock& lock);


class spinlock final
{
  std::atomic_flag af = 
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/spinlock.h" 3
                       { 0 }
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/spinlock.h"
                                       ;

  public:
  void lock() {
    ceph::spin_lock(af);
  }

  void unlock() noexcept {
    ceph::spin_unlock(af);
  }
};


inline void spin_lock(std::atomic_flag& lock)
{
 while(lock.test_and_set(std::memory_order_acquire))
  ;
}

inline void spin_unlock(std::atomic_flag& lock)
{
 lock.clear(std::memory_order_release);
}

inline void spin_lock(std::atomic_flag *lock)
{
 spin_lock(*lock);
}

inline void spin_unlock(std::atomic_flag *lock)
{
 spin_unlock(*lock);
}

inline void spin_lock(ceph::spinlock& lock)
{
 lock.lock();
}

inline void spin_unlock(ceph::spinlock& lock)
{
 lock.unlock();
}

inline void spin_lock(ceph::spinlock *lock)
{
 spin_lock(*lock);
}

inline void spin_unlock(ceph::spinlock *lock)
{
 spin_unlock(*lock);
}

}
}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters_collection.h" 1
       

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 1
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h" 1
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h"
class PerfHistogramCommon {
public:
  enum scale_type_d : uint8_t {
    SCALE_LINEAR = 1,
    SCALE_LOG2 = 2,
  };

  struct axis_config_d {
    const char *m_name = nullptr;
    scale_type_d m_scale_type = SCALE_LINEAR;
    int64_t m_min = 0;
    int64_t m_quant_size = 0;
    int32_t m_buckets = 0;
    axis_config_d() = default;
    axis_config_d(const char* name,
    scale_type_d scale_type,
    int64_t min,
    int64_t quant_size,
    int32_t buckets)
      : m_name(name),
 m_scale_type(scale_type),
 m_min(min),
 m_quant_size(quant_size),
 m_buckets(buckets)
    {}
  };

protected:

  static void dump_formatted_axis(ceph::Formatter *f, const axis_config_d &ac);


  static int64_t get_bucket_for_axis(int64_t value, const axis_config_d &ac);


  static std::vector<std::pair<int64_t, int64_t>> get_axis_bucket_ranges(
      const axis_config_d &ac);
};
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h"
template <int DIM = 2>
class PerfHistogram : public PerfHistogramCommon {
public:

  PerfHistogram(std::initializer_list<axis_config_d> axes_config) {
    do { static const ceph::assert_data assert_data_ctx = {"axes_config.size() == DIM && \"Invalid number of axis configuration objects\"", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h", 77, __PRETTY_FUNCTION__}; ((axes_config.size() == DIM && "Invalid number of axis configuration objects") ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false)
                                                 ;

    int i = 0;
    for (const auto &ac : axes_config) {
      ((ac.m_buckets > 0) ? static_cast<void> (0) : __ceph_assertf_fail ("ac.m_buckets > 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h", 82, __PRETTY_FUNCTION__, "Must have at least one bucket on axis"));
      ((ac.m_quant_size > 0) ? static_cast<void> (0) : __ceph_assertf_fail ("ac.m_quant_size > 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h", 83, __PRETTY_FUNCTION__, "Quantization unit must be non-zero positive integer value"))
                                                                         ;

      m_axes_config[i++] = ac;
    }

    m_rawData.reset(new std::atomic<uint64_t>[get_raw_size()] {});
  }


  PerfHistogram(const PerfHistogram &other)
      : m_axes_config(other.m_axes_config) {
    int64_t size = get_raw_size();
    m_rawData.reset(new std::atomic<uint64_t>[size] {});
    for (int64_t i = 0; i < size; i++) {
      m_rawData[i] = other.m_rawData[i].load();
    }
  }


  void reset() {
    auto size = get_raw_size();
    for (auto i = size; --i >= 0;) {
      m_rawData[i] = 0;
    }
  }


  template <typename... T>
  void inc(T... axis) {
    auto index = get_raw_index_for_value(axis...);
    m_rawData[index]++;
  }


  template <typename... T>
  void inc_bucket(T... bucket) {
    auto index = get_raw_index_for_bucket(bucket...);
    m_rawData[index]++;
  }


  template <typename... T>
  uint64_t read_bucket(T... bucket) const {
    auto index = get_raw_index_for_bucket(bucket...);
    return m_rawData[index];
  }


  void dump_formatted(ceph::Formatter *f) const {

    f->open_array_section("axes");
    for (auto &ac : m_axes_config) {
      dump_formatted_axis(f, ac);
    }
    f->close_section();


    dump_formatted_values(f);
  }

protected:


  std::unique_ptr<std::atomic<uint64_t>[]> m_rawData;


  std::array<axis_config_d, DIM> m_axes_config;


  void dump_formatted_values(ceph::Formatter *f) const {
    visit_values([f](int) { f->open_array_section("values"); },
                 [f](int64_t value) { f->dump_unsigned("value", value); },
                 [f](int) { f->close_section(); });
  }


  int64_t get_raw_size() {
    int64_t ret = 1;
    for (const auto &ac : m_axes_config) {
      ret *= ac.m_buckets;
    }
    return ret;
  }


  template <typename... T>
  int64_t get_raw_index_for_value(T... axes) const {
    static_assert(sizeof...(T) == DIM, "Incorrect number of arguments");
    return get_raw_index_internal<0>(get_bucket_for_axis, 0, axes...);
  }


  template <typename... T>
  int64_t get_raw_index_for_bucket(T... buckets) const {
    static_assert(sizeof...(T) == DIM, "Incorrect number of arguments");
    return get_raw_index_internal<0>(
        [](int64_t bucket, const axis_config_d &ac) {
          ((bucket >= 0) ? static_cast<void> (0) : __ceph_assertf_fail ("bucket >= 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h", 181, __PRETTY_FUNCTION__, "Bucket index can not be negative"));
          ((bucket < ac.m_buckets) ? static_cast<void> (0) : __ceph_assertf_fail ("bucket < ac.m_buckets", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_histogram.h", 182, __PRETTY_FUNCTION__, "Bucket index too large"));
          return bucket;
        },
        0, buckets...);
  }

  template <int level = 0, typename F, typename... T>
  int64_t get_raw_index_internal(F bucket_evaluator, int64_t startIndex,
                                 int64_t value, T... tail) const {
    static_assert(level + 1 + sizeof...(T) == DIM,
                  "Internal consistency check");
    auto &ac = m_axes_config[level];
    auto bucket = bucket_evaluator(value, ac);
    return get_raw_index_internal<level + 1>(
        bucket_evaluator, ac.m_buckets * startIndex + bucket, tail...);
  }

  template <int level, typename F>
  int64_t get_raw_index_internal(F, int64_t startIndex) const {
    static_assert(level == DIM, "Internal consistency check");
    return startIndex;
  }




  template <typename FDE, typename FV, typename FDL>
  void visit_values(FDE onDimensionEnter, FV onValue, FDL onDimensionLeave,
                    int level = 0, int startIndex = 0) const {
    if (level == DIM) {
      onValue(m_rawData[startIndex]);
      return;
    }

    onDimensionEnter(level);
    auto &ac = m_axes_config[level];
    startIndex *= ac.m_buckets;
    for (int32_t i = 0; i < ac.m_buckets; ++i, ++startIndex) {
      visit_values(onDimensionEnter, onValue, onDimensionLeave, level + 1,
                   startIndex);
    }
    onDimensionLeave(level);
  }
};
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
# 1 "/usr/include/c++/10/math.h" 1 3
# 36 "/usr/include/c++/10/math.h" 3
# 1 "/usr/include/c++/10/cmath" 1 3
# 39 "/usr/include/c++/10/cmath" 3
       
# 40 "/usr/include/c++/10/cmath" 3
# 37 "/usr/include/c++/10/math.h" 2 3


# 38 "/usr/include/c++/10/math.h" 3
using std::abs;
using std::acos;
using std::asin;
using std::atan;
using std::atan2;
using std::cos;
using std::sin;
using std::tan;
using std::cosh;
using std::sinh;
using std::tanh;
using std::exp;
using std::frexp;
using std::ldexp;
using std::log;
using std::log10;
using std::modf;
using std::pow;
using std::sqrt;
using std::ceil;
using std::fabs;
using std::floor;
using std::fmod;


using std::fpclassify;
using std::isfinite;
using std::isinf;
using std::isnan;
using std::isnormal;
using std::signbit;
using std::isgreater;
using std::isgreaterequal;
using std::isless;
using std::islessequal;
using std::islessgreater;
using std::isunordered;



using std::acosh;
using std::asinh;
using std::atanh;
using std::cbrt;
using std::copysign;
using std::erf;
using std::erfc;
using std::exp2;
using std::expm1;
using std::fdim;
using std::fma;
using std::fmax;
using std::fmin;
using std::hypot;
using std::ilogb;
using std::lgamma;
using std::llrint;
using std::llround;
using std::log1p;
using std::log2;
using std::logb;
using std::lrint;
using std::lround;
using std::nearbyint;
using std::nextafter;
using std::nexttoward;
using std::remainder;
using std::remquo;
using std::rint;
using std::round;
using std::scalbln;
using std::scalbn;
using std::tgamma;
using std::trunc;
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 2





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/timegm.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/timegm.h"

# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/timegm.h"
static int32_t is_leap(int32_t year) {
  if(year % 400 == 0)
    return 1;
  if(year % 100 == 0)
    return 0;
  if(year % 4 == 0)
    return 1;
  return 0;
}

static int32_t days_from_0(int32_t year) {
  year--;
  return 365 * year + (year / 400) - (year/100) + (year / 4);
}

int32_t static days_from_1970(int32_t year) {
  static const int days_from_0_to_1970 = days_from_0(1970);
  return days_from_0(year) - days_from_0_to_1970;
}

static int32_t days_from_1jan(int32_t year,int32_t month,int32_t day) {
  static const int32_t days[2][12] =
  {
    { 0,31,59,90,120,151,181,212,243,273,304,334},
    { 0,31,60,91,121,152,182,213,244,274,305,335}
  };

  return days[is_leap(year)][month-1] + day - 1;
}

static time_t internal_timegm(tm const *t) {
  int year = t->tm_year + 1900;
  int month = t->tm_mon;
  if(month > 11)
  {
    year += month/12;
    month %= 12;
  }
  else if(month < 0)
  {
    int years_diff = (-month + 11)/12;
    year -= years_diff;
    month+=12 * years_diff;
  }
  month++;
  int day = t->tm_mday;
  int day_of_year = days_from_1jan(year,month,day);
  int days_since_epoch = days_from_1970(year) + day_of_year ;

  time_t seconds_in_day = 3600 * 24;
  time_t result = seconds_in_day * days_since_epoch + 3600 * t->tm_hour + 60 * t->tm_min + t->tm_sec;

  return result;
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/strtol.h" 1
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/strtol.h"
extern "C" {

}

long long strict_strtoll(const char *str, int base, std::string *err);

int strict_strtol(const char *str, int base, std::string *err);

double strict_strtod(const char *str, std::string *err);

float strict_strtof(const char *str, std::string *err);

uint64_t strict_iecstrtoll(const char *str, std::string *err);

template<typename T>
T strict_iec_cast(const char *str, std::string *err);

uint64_t strict_sistrtoll(const char *str, std::string *err);

template<typename T>
T strict_si_cast(const char *str, std::string *err);






template<typename T, const unsigned base = 10, const unsigned width = 1>
static inline
char* ritoa(T u, char *buf)
{
  static_assert(std::is_unsigned<T>::value, "signed types are not supported");
  static_assert(base <= 16, "extend character map below to support higher bases");
  unsigned digits = 0;
  while (u) {
    *--buf = "0123456789abcdef"[u % base];
    u /= base;
    digits++;
  }
  while (digits++ < width)
    *--buf = '0';
  return buf;
}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/safe_io.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/safe_io.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/compiler_extensions.h" 1
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/safe_io.h" 2



extern "C" {







  ssize_t safe_read(int fd, void *buf, size_t count)
      __attribute__((warn_unused_result));
  ssize_t safe_write(int fd, const void *buf, size_t count)
      __attribute__((warn_unused_result));
  ssize_t safe_pread(int fd, void *buf, size_t count, off_t offset)
      __attribute__((warn_unused_result));
  ssize_t safe_pwrite(int fd, const void *buf, size_t count, off_t offset)
      __attribute__((warn_unused_result));





  ssize_t safe_splice(int fd_in, off_t *off_in, int fd_out, off_t *off_out,
        size_t len, unsigned int flags)
    __attribute__((warn_unused_result));
  ssize_t safe_splice_exact(int fd_in, off_t *off_in, int fd_out,
       off_t *off_out, size_t len, unsigned int flags)
    __attribute__((warn_unused_result));






  ssize_t safe_read_exact(int fd, void *buf, size_t count)
      __attribute__((warn_unused_result));
  ssize_t safe_pread_exact(int fd, void *buf, size_t count, off_t offset)
      __attribute__((warn_unused_result));





  int safe_write_file(const char *base, const char *file,
        const char *val, size_t vallen,
        unsigned mode);
  int safe_read_file(const char *base, const char *file,
       char *val, size_t vallen);


}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h"
# 1 "/usr/include/sys/wait.h" 1 3 4
# 27 "/usr/include/sys/wait.h" 3 4

# 27 "/usr/include/sys/wait.h" 3 4
extern "C" {
# 36 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/signal.h" 1 3 4
# 27 "/usr/include/signal.h" 3 4
extern "C" {


# 1 "/usr/include/bits/signum.h" 1 3 4
# 26 "/usr/include/bits/signum.h" 3 4
# 1 "/usr/include/bits/signum-generic.h" 1 3 4
# 27 "/usr/include/bits/signum.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
# 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

};


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
# 210 "/usr/include/bits/siginfo-consts.h" 2 3 4
# 59 "/usr/include/signal.h" 2 3 4



# 1 "/usr/include/bits/types/sigval_t.h" 1 3 4
# 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/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)
     throw ();

extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
     throw ();






extern __sighandler_t signal (int __sig, __sighandler_t __handler)
     throw ();
# 112 "/usr/include/signal.h" 3 4
extern int kill (__pid_t __pid, int __sig) throw ();






extern int killpg (__pid_t __pgrp, int __sig) throw ();



extern int raise (int __sig) throw ();



extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
     throw ();
extern int gsignal (int __sig) throw ();




extern void psignal (int __sig, const char *__s);


extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
# 151 "/usr/include/signal.h" 3 4
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
# 170 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));


extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));


extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
# 185 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;




typedef __sighandler_t sig_t;





extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));


extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));


extern int sigismember (const sigset_t *__set, int __signo)
     throw () __attribute__ ((__nonnull__ (1)));



extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigandset (sigset_t *__set, const sigset_t *__left,
        const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));


extern int sigorset (sigset_t *__set, const sigset_t *__left,
       const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));




# 1 "/usr/include/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);
  };
# 227 "/usr/include/signal.h" 2 3 4


extern int sigprocmask (int __how, const sigset_t *__restrict __set,
   sigset_t *__restrict __oset) throw ();






extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));


extern int sigaction (int __sig, const struct sigaction *__restrict __act,
        struct sigaction *__restrict __oact) throw ();


extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));







extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
     __attribute__ ((__nonnull__ (1, 2)));







extern int sigwaitinfo (const sigset_t *__restrict __set,
   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));






extern int sigtimedwait (const sigset_t *__restrict __set,
    siginfo_t *__restrict __info,
    const struct timespec *__restrict __timeout)
     __attribute__ ((__nonnull__ (1)));



extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
     throw ();
# 286 "/usr/include/signal.h" 3 4
extern const char *const _sys_siglist[(64 + 1)];
extern const char *const sys_siglist[(64 + 1)];



# 1 "/usr/include/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;
};
# 292 "/usr/include/signal.h" 2 3 4


extern int sigreturn (struct sigcontext *__scp) throw ();






# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 3 4
# 302 "/usr/include/signal.h" 2 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/lib/gcc/x86_64-redhat-linux/10/include/stddef.h" 1 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;
# 304 "/usr/include/signal.h" 2 3 4


# 1 "/usr/include/sys/ucontext.h" 1 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;
# 307 "/usr/include/signal.h" 2 3 4







extern int siginterrupt (int __sig, int __interrupt) throw ();

# 1 "/usr/include/bits/sigstack.h" 1 3 4
# 317 "/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

};
# 318 "/usr/include/signal.h" 2 3 4



extern int sigaltstack (const stack_t *__restrict __ss,
   stack_t *__restrict __oss) throw ();




# 1 "/usr/include/bits/types/struct_sigstack.h" 1 3 4
# 23 "/usr/include/bits/types/struct_sigstack.h" 3 4
struct sigstack
  {
    void *ss_sp;
    int ss_onstack;
  };
# 328 "/usr/include/signal.h" 2 3 4







extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
     throw () __attribute__ ((__deprecated__));






extern int sighold (int __sig) throw ();


extern int sigrelse (int __sig) throw ();


extern int sigignore (int __sig) throw ();


extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();






# 1 "/usr/include/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)throw ();


extern int pthread_kill (pthread_t __threadid, int __signo) throw ();



extern int pthread_sigqueue (pthread_t __threadid, int __signo,
        const union sigval __value) throw ();
# 360 "/usr/include/signal.h" 2 3 4






extern int __libc_current_sigrtmin (void) throw ();

extern int __libc_current_sigrtmax (void) throw ();





# 1 "/usr/include/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);
# 375 "/usr/include/signal.h" 2 3 4

}
# 37 "/usr/include/sys/wait.h" 2 3 4
# 74 "/usr/include/sys/wait.h" 3 4
typedef enum
{
  P_ALL,
  P_PID,
  P_PGID
} idtype_t;
# 88 "/usr/include/sys/wait.h" 3 4
extern __pid_t wait (int *__stat_loc);
# 111 "/usr/include/sys/wait.h" 3 4
extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);
# 132 "/usr/include/sys/wait.h" 3 4
extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop,
     int __options);






struct rusage;






extern __pid_t wait3 (int *__stat_loc, int __options,
        struct rusage * __usage) throw ();




extern __pid_t wait4 (__pid_t __pid, int *__stat_loc, int __options,
        struct rusage *__usage) throw ();



}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h" 2
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h"

# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h"
class SubProcess {
public:
  enum std_fd_op{
    KEEP,
    CLOSE,
    PIPE
  };
public:
  SubProcess(const char *cmd,
             std_fd_op stdin_op = CLOSE,
             std_fd_op stdout_op = CLOSE,
             std_fd_op stderr_op = CLOSE);
  virtual ~SubProcess();

  void add_cmd_args(const char *arg, ...);
  void add_cmd_arg(const char *arg);

  virtual int spawn();
  virtual int join();

  bool is_spawned() const { return pid > 0; }

  int get_stdin() const;
  int get_stdout() const;
  int get_stderr() const;

  void close_stdin();
  void close_stdout();
  void close_stderr();

  void kill(int signo = 
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h" 3 4
                       15
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h"
                              ) const;

  const std::string err() const;

protected:
  bool is_child() const { return pid == 0; }
  virtual void exec();

private:
  void close(int &fd);

protected:
  std::string cmd;
  std::vector<std::string> cmd_args;
  std_fd_op stdin_op;
  std_fd_op stdout_op;
  std_fd_op stderr_op;
  int stdin_pipe_out_fd;
  int stdout_pipe_in_fd;
  int stderr_pipe_in_fd;
  int pid;
  std::ostringstream errstr;
};

class SubProcessTimed : public SubProcess {
public:
  SubProcessTimed(const char *cmd, std_fd_op stdin_op = CLOSE,
    std_fd_op stdout_op = CLOSE, std_fd_op stderr_op = CLOSE,
    int timeout = 0, int sigkill = 
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h" 3 4
                                  9
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/SubProcess.h"
                                         );

protected:
  void exec() override;

private:
  int timeout;
  int sigkill;
};

void timeout_sighandler(int sig);
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/denc.h" 1
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 2





inline __u32 cap_to_u32_max(__u64 t) {
  return std::min(t, (__u64)std::numeric_limits<uint32_t>::max());
}





class utime_t {
public:
  struct {
    __u32 tv_sec, tv_nsec;
  } tv;

 public:
  bool is_zero() const {
    return (tv.tv_sec == 0) && (tv.tv_nsec == 0);
  }

  void normalize() {
    if (tv.tv_nsec > 1000000000ul) {
      tv.tv_sec = cap_to_u32_max(tv.tv_sec + tv.tv_nsec / (1000000000ul));
      tv.tv_nsec %= 1000000000ul;
    }
  }


  utime_t() { tv.tv_sec = 0; tv.tv_nsec = 0; }
  utime_t(time_t s, int n) { tv.tv_sec = s; tv.tv_nsec = n; normalize(); }
  utime_t(const struct ceph_timespec &v) {
    decode_timeval(&v);
  }
  utime_t(const struct timespec v)
  {


    tv.tv_sec = v.tv_sec;
    tv.tv_nsec = v.tv_nsec;
  }

  template <typename Clock, typename std::enable_if_t<
            ceph::converts_to_timespec_v<Clock>>* = nullptr>
  explicit utime_t(const std::chrono::time_point<Clock>& t)
    : utime_t(Clock::to_timespec(t)) {}

  utime_t(const struct timeval &v) {
    set_from_timeval(&v);
  }
  utime_t(const struct timeval *v) {
    set_from_timeval(v);
  }
  void to_timespec(struct timespec *ts) const {
    ts->tv_sec = tv.tv_sec;
    ts->tv_nsec = tv.tv_nsec;
  }
  void set_from_double(double d) {
    tv.tv_sec = (__u32)trunc(d);
    tv.tv_nsec = (__u32)((d - (double)tv.tv_sec) * 1000000000.0);
  }

  real_time to_real_time() const {
    ceph_timespec ts;
    encode_timeval(&ts);
    return ceph::real_clock::from_ceph_timespec(ts);
  }


  time_t sec() const { return tv.tv_sec; }
  long usec() const { return tv.tv_nsec/1000; }
  int nsec() const { return tv.tv_nsec; }


  __u32& sec_ref() { return tv.tv_sec; }
  __u32& nsec_ref() { return tv.tv_nsec; }

  uint64_t to_nsec() const {
    return (uint64_t)tv.tv_nsec + (uint64_t)tv.tv_sec * 1000000000ull;
  }
  uint64_t to_msec() const {
    return (uint64_t)tv.tv_nsec / 1000000ull + (uint64_t)tv.tv_sec * 1000ull;
  }

  void copy_to_timeval(struct timeval *v) const {
    v->tv_sec = tv.tv_sec;
    v->tv_usec = tv.tv_nsec/1000;
  }
  void set_from_timeval(const struct timeval *v) {
    tv.tv_sec = v->tv_sec;
    tv.tv_nsec = v->tv_usec*1000;
  }
  void padding_check() {
    static_assert(
      sizeof(utime_t) ==
        sizeof(tv.tv_sec) +
        sizeof(tv.tv_nsec)
      ,
      "utime_t have padding");
  }
  void encode(bufferlist &bl) const {

    bl.append((char *)(this), sizeof(__u32) + sizeof(__u32));





  }
  void decode(bufferlist::const_iterator &p) {

    p.copy(sizeof(__u32) + sizeof(__u32), (char *)(this));





  }

  static void _denc_start(size_t& p, __u8 *struct_v, __u8 *struct_compat, char **, uint32_t *) { p += 2 + 4; } static void _denc_finish(size_t& p, __u8 *struct_v, __u8 *struct_compat, char **, uint32_t *) { } static void _denc_start(bufferlist::contiguous_appender& p, __u8 *struct_v, __u8 *struct_compat, char **len_pos, uint32_t *start_oob_off) { denc(*struct_v, p); denc(*struct_compat, p); *len_pos = p.get_pos_add(4); *start_oob_off = p.get_out_of_band_offset(); } static void _denc_finish(bufferlist::contiguous_appender& p, __u8 *struct_v, __u8 *struct_compat, char **len_pos, uint32_t *start_oob_off) { *(ceph_le32*)*len_pos = p.get_pos() - *len_pos - sizeof(uint32_t) + p.get_out_of_band_offset() - *start_oob_off; } static void _denc_start(buffer::ptr::const_iterator& p, __u8 *struct_v, __u8 *struct_compat, char **start_pos, uint32_t *struct_len) { denc(*struct_v, p); denc(*struct_compat, p); denc(*struct_len, p); *start_pos = const_cast<char*>(p.get_pos()); } static void _denc_finish(buffer::ptr::const_iterator& p, __u8 *struct_v, __u8 *struct_compat, char **start_pos, uint32_t *struct_len) { const char *pos = p.get_pos(); char *end = *start_pos + *struct_len; do { static const ceph::assert_data assert_data_ctx = {"pos <= end", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h", 152, __PRETTY_FUNCTION__}; ((pos <= end) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false); if (pos < end) { p.advance(end - pos); } } void bound_encode(size_t& p) const { _denc_friend(*this, p); } void encode(bufferlist::contiguous_appender& p) const { ; _denc_friend(*this, p); ; } void decode(buffer::ptr::const_iterator& p) { _denc_friend(*this, p); } template<typename T, typename P> friend std::enable_if_t<std::is_same_v<T, utime_t> || std::is_same_v<T, const utime_t>> _denc_friend(T& v, P& p) {
    denc(v.tv.tv_sec, p);
    denc(v.tv.tv_nsec, p);
  }


  void encode_timeval(struct ceph_timespec *t) const {
    t->tv_sec = tv.tv_sec;
    t->tv_nsec = tv.tv_nsec;
  }
  void decode_timeval(const struct ceph_timespec *t) {
    tv.tv_sec = t->tv_sec;
    tv.tv_nsec = t->tv_nsec;
  }

  utime_t round_to_minute() {
    struct tm bdt;
    time_t tt = sec();
    localtime_r(&tt, &bdt);
    bdt.tm_sec = 0;
    tt = mktime(&bdt);
    return utime_t(tt, 0);
  }

  utime_t round_to_hour() {
    struct tm bdt;
    time_t tt = sec();
    localtime_r(&tt, &bdt);
    bdt.tm_sec = 0;
    bdt.tm_min = 0;
    tt = mktime(&bdt);
    return utime_t(tt, 0);
  }

  utime_t round_to_day() {
    struct tm bdt;
    time_t tt = sec();
    localtime_r(&tt, &bdt);
    bdt.tm_sec = 0;
    bdt.tm_min = 0;
    bdt.tm_hour = 0;
    tt = mktime(&bdt);
    return utime_t(tt, 0);
  }


  operator double() const {
    return (double)sec() + ((double)nsec() / 1000000000.0L);
  }
  operator ceph_timespec() const {
    ceph_timespec ts;
    ts.tv_sec = sec();
    ts.tv_nsec = nsec();
    return ts;
  }

  void sleep() const {
    struct timespec ts;
    to_timespec(&ts);
    nanosleep(&ts, 
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
                  __null
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                      );
  }


  ostream& gmtime(ostream& out) const {
    out.setf(std::ios::right);
    char oldfill = out.fill();
    out.fill('0');
    if (sec() < ((time_t)(60*60*24*365*10))) {

      out << (long)sec() << "." << std::setw(6) << usec();
    } else {


      struct tm bdt;
      time_t tt = sec();
      gmtime_r(&tt, &bdt);
      out << std::setw(4) << (bdt.tm_year+1900)
   << '-' << std::setw(2) << (bdt.tm_mon+1)
   << '-' << std::setw(2) << bdt.tm_mday
   << ' '
   << std::setw(2) << bdt.tm_hour
   << ':' << std::setw(2) << bdt.tm_min
   << ':' << std::setw(2) << bdt.tm_sec;
      out << "." << std::setw(6) << usec();
      out << "Z";
    }
    out.fill(oldfill);
    out.unsetf(std::ios::right);
    return out;
  }


  ostream& gmtime_nsec(ostream& out) const {
    out.setf(std::ios::right);
    char oldfill = out.fill();
    out.fill('0');
    if (sec() < ((time_t)(60*60*24*365*10))) {

      out << (long)sec() << "." << std::setw(6) << usec();
    } else {


      struct tm bdt;
      time_t tt = sec();
      gmtime_r(&tt, &bdt);
      out << std::setw(4) << (bdt.tm_year+1900)
   << '-' << std::setw(2) << (bdt.tm_mon+1)
   << '-' << std::setw(2) << bdt.tm_mday
   << ' '
   << std::setw(2) << bdt.tm_hour
   << ':' << std::setw(2) << bdt.tm_min
   << ':' << std::setw(2) << bdt.tm_sec;
      out << "." << std::setw(9) << nsec();
      out << "Z";
    }
    out.fill(oldfill);
    out.unsetf(std::ios::right);
    return out;
  }


  ostream& asctime(ostream& out) const {
    out.setf(std::ios::right);
    char oldfill = out.fill();
    out.fill('0');
    if (sec() < ((time_t)(60*60*24*365*10))) {

      out << (long)sec() << "." << std::setw(6) << usec();
    } else {


      struct tm bdt;
      time_t tt = sec();
      gmtime_r(&tt, &bdt);

      char buf[128];
      asctime_r(&bdt, buf);
      int len = strlen(buf);
      if (buf[len - 1] == '\n')
        buf[len - 1] = '\0';
      out << buf;
    }
    out.fill(oldfill);
    out.unsetf(std::ios::right);
    return out;
  }

  ostream& localtime(ostream& out) const {
    out.setf(std::ios::right);
    char oldfill = out.fill();
    out.fill('0');
    if (sec() < ((time_t)(60*60*24*365*10))) {

      out << (long)sec() << "." << std::setw(6) << usec();
    } else {


      struct tm bdt;
      time_t tt = sec();
      localtime_r(&tt, &bdt);
      out << std::setw(4) << (bdt.tm_year+1900)
   << '-' << std::setw(2) << (bdt.tm_mon+1)
   << '-' << std::setw(2) << bdt.tm_mday
   << ' '
   << std::setw(2) << bdt.tm_hour
   << ':' << std::setw(2) << bdt.tm_min
   << ':' << std::setw(2) << bdt.tm_sec;
      out << "." << std::setw(6) << usec();

    }
    out.fill(oldfill);
    out.unsetf(std::ios::right);
    return out;
  }

  int sprintf(char *out, int outlen) const {
    struct tm bdt;
    time_t tt = sec();
    localtime_r(&tt, &bdt);

    return ::snprintf(out, outlen,
      "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
      bdt.tm_year + 1900, bdt.tm_mon + 1, bdt.tm_mday,
      bdt.tm_hour, bdt.tm_min, bdt.tm_sec, usec());
  }

  static int snprintf(char *out, int outlen, time_t tt) {
    struct tm bdt;
    localtime_r(&tt, &bdt);

    return ::snprintf(out, outlen,
        "%04d-%02d-%02d %02d:%02d:%02d",
        bdt.tm_year + 1900, bdt.tm_mon + 1, bdt.tm_mday,
        bdt.tm_hour, bdt.tm_min, bdt.tm_sec);
  }

  static int invoke_date(const std::string& date_str, utime_t *result) {
     char buf[256];

     SubProcess bin_date("/bin/date", SubProcess::CLOSE, SubProcess::PIPE,
    SubProcess::KEEP);
     bin_date.add_cmd_args("-d", date_str.c_str(), "+%s %N", 
# 353 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
                                                            __null
# 353 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                                                                );

     int r = bin_date.spawn();
     if (r < 0) return r;

     ssize_t n = safe_read(bin_date.get_stdout(), buf, sizeof(buf));

     r = bin_date.join();
     if (r || n <= 0) return -
# 361 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
                             22
# 361 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                                   ;

     uint64_t epoch, nsec;
     std::istringstream iss(buf);

     iss >> epoch;
     iss >> nsec;

     *result = utime_t(epoch, nsec);

     return 0;
  }


  static int parse_date(const string& date, uint64_t *epoch, uint64_t *nsec,
                        string *out_date=
# 376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
                                        __null
# 376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                                            , string *out_time=
# 376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
                                                               __null
# 376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                                                                   ) {
    struct tm tm;
    memset(&tm, 0, sizeof(tm));

    if (nsec)
      *nsec = 0;

    const char *p = strptime(date.c_str(), "%Y-%m-%d", &tm);
    if (p) {
      if (*p == ' ' || *p == 'T') {
 p++;



 char fmt[32] = {0};
 strncpy(fmt, p, sizeof(fmt) - 1);
 fmt[0] = '%';
 fmt[1] = 'H';
 fmt[2] = ':';
 fmt[3] = '%';
 fmt[4] = 'M';
 fmt[6] = '%';
 fmt[7] = 'S';
 const char *subsec = 0;
 char *q = fmt + 8;
 if (*q == '.') {
   ++q;
   subsec = p + 9;
   q = fmt + 9;
   while (*q && isdigit(*q)) {
     ++q;
   }
 }

 if (*q == '-' || *q == '+') {
   *q = '%';
   *(q+1) = 'z';
   *(q+2) = 0;
 }
 p = strptime(p, fmt, &tm);
 if (!p) {
   return -
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
          22
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                ;
 }
        if (nsec && subsec) {
          unsigned i;
          char buf[10];
          for (i = 0; (i < sizeof(buf) - 1) && isdigit(*subsec); ++i, ++subsec) {
            buf[i] = *subsec;
          }
          for (; i < sizeof(buf) - 1; ++i) {
            buf[i] = '0';
          }
          buf[i] = '\0';
          string err;
          *nsec = (uint64_t)strict_strtol(buf, 10, &err);
          if (!err.empty()) {
            return -
# 432 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
                   22
# 432 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                         ;
          }
        }
      }
    } else {
      int sec, usec;
      int r = sscanf(date.c_str(), "%d.%d", &sec, &usec);
      if (r != 2) {
        return -
# 440 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h" 3 4
               22
# 440 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/utime.h"
                     ;
      }

      time_t tt = sec;
      gmtime_r(&tt, &tm);

      if (nsec) {
        *nsec = (uint64_t)usec * 1000;
      }
    }




    auto gmtoff = tm.tm_gmtoff;
    tm.tm_gmtoff = 0;

    time_t t = internal_timegm(&tm);
    if (epoch)
      *epoch = (uint64_t)t;

    *epoch -= gmtoff;

    if (out_date) {
      char buf[32];
      strftime(buf, sizeof(buf), "%F", &tm);
      *out_date = buf;
    }
    if (out_time) {
      char buf[32];
      strftime(buf, sizeof(buf), "%T", &tm);
      *out_time = buf;
    }

    return 0;
  }

  bool parse(const string& s) {
    uint64_t epoch, nsec;
    int r = parse_date(s, &epoch, &nsec);
    if (r < 0) {
      return false;
    }
    *this = utime_t(epoch, nsec);
    return true;
  }
};
inline void encode(const utime_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(utime_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
template<> struct denc_traits<utime_t> { static constexpr bool supported = true; static constexpr bool featured = false; static constexpr bool bounded = false; static constexpr bool need_contiguous = !_denc::has_legacy_denc<utime_t>::value; static void bound_encode(const utime_t& v, size_t& p, uint64_t f=0) { v.bound_encode(p); } static void encode(const utime_t& v, buffer::list::contiguous_appender& p, uint64_t f=0) { v.encode(p); } static void decode(utime_t& v, buffer::ptr::const_iterator& p, uint64_t f=0) { v.decode(p); } };


inline utime_t operator+(const utime_t& l, const utime_t& r) {
  __u64 sec = (__u64)l.sec() + r.sec();
  return utime_t(cap_to_u32_max(sec), l.nsec() + r.nsec());
}
inline utime_t& operator+=(utime_t& l, const utime_t& r) {
  l.sec_ref() = cap_to_u32_max((__u64)l.sec() + r.sec());
  l.nsec_ref() += r.nsec();
  l.normalize();
  return l;
}
inline utime_t& operator+=(utime_t& l, double f) {
  double fs = trunc(f);
  double ns = (f - fs) * 1000000000.0;
  l.sec_ref() = cap_to_u32_max(l.sec() + (__u64)fs);
  l.nsec_ref() += (long)ns;
  l.normalize();
  return l;
}

inline utime_t operator-(const utime_t& l, const utime_t& r) {
  return utime_t( l.sec() - r.sec() - (l.nsec()<r.nsec() ? 1:0),
                  l.nsec() - r.nsec() + (l.nsec()<r.nsec() ? 1000000000:0) );
}
inline utime_t& operator-=(utime_t& l, const utime_t& r) {
  l.sec_ref() -= r.sec();
  if (l.nsec() >= r.nsec())
    l.nsec_ref() -= r.nsec();
  else {
    l.nsec_ref() += 1000000000L - r.nsec();
    l.sec_ref()--;
  }
  return l;
}
inline utime_t& operator-=(utime_t& l, double f) {
  double fs = trunc(f);
  double ns = (f - fs) * 1000000000.0;
  l.sec_ref() -= (long)fs;
  long nsl = (long)ns;
  if (nsl) {
    l.sec_ref()--;
    l.nsec_ref() = 1000000000L + l.nsec_ref() - nsl;
  }
  l.normalize();
  return l;
}



inline bool operator>(const utime_t& a, const utime_t& b)
{
  return (a.sec() > b.sec()) || (a.sec() == b.sec() && a.nsec() > b.nsec());
}
inline bool operator<=(const utime_t& a, const utime_t& b)
{
  return !(operator>(a, b));
}
inline bool operator<(const utime_t& a, const utime_t& b)
{
  return (a.sec() < b.sec()) || (a.sec() == b.sec() && a.nsec() < b.nsec());
}
inline bool operator>=(const utime_t& a, const utime_t& b)
{
  return !(operator<(a, b));
}

inline bool operator==(const utime_t& a, const utime_t& b)
{
  return a.sec() == b.sec() && a.nsec() == b.nsec();
}
inline bool operator!=(const utime_t& a, const utime_t& b)
{
  return a.sec() != b.sec() || a.nsec() != b.nsec();
}





inline std::ostream& operator<<(std::ostream& out, const utime_t& t)
{
  return t.localtime(out);
}

inline std::string utimespan_str(const utime_t& age) {
  auto age_ts = ceph::timespan(age.nsec()) + std::chrono::seconds(age.sec());
  return timespan_str(age_ts);
}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 2



class CephContext;
class PerfCountersBuilder;
class PerfCounters;

enum perfcounter_type_d : uint8_t
{
  PERFCOUNTER_NONE = 0,
  PERFCOUNTER_TIME = 0x1,
  PERFCOUNTER_U64 = 0x2,
  PERFCOUNTER_LONGRUNAVG = 0x4,
  PERFCOUNTER_COUNTER = 0x8,
  PERFCOUNTER_HISTOGRAM = 0x10,
};

enum unit_t : uint8_t
{
  UNIT_BYTES,
  UNIT_NONE
};
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
class PerfCountersBuilder
{
public:
  PerfCountersBuilder(CephContext *cct, const std::string &name,
      int first, int last);
  ~PerfCountersBuilder();





  enum {
    PRIO_CRITICAL = 10,

    PRIO_INTERESTING = 8,


    PRIO_USEFUL = 5,
    PRIO_UNINTERESTING = 2,
    PRIO_DEBUGONLY = 0,
  };
  void add_u64(int key, const char *name,
        const char *description=
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                               __null
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                                   , const char *nick = 
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                                                        __null
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                                                            ,
        int prio=0, int unit=UNIT_NONE);
  void add_u64_counter(int key, const char *name,
         const char *description=
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                                __null
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                                    ,
         const char *nick = 
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                           __null
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                               ,
         int prio=0, int unit=UNIT_NONE);
  void add_u64_avg(int key, const char *name,
     const char *description=
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                            __null
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                                ,
     const char *nick = 
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                       __null
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                           ,
     int prio=0, int unit=UNIT_NONE);
  void add_time(int key, const char *name,
  const char *description=
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                         __null
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                             ,
  const char *nick = 
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                    __null
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                        ,
  int prio=0);
  void add_time_avg(int key, const char *name,
      const char *description=
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                             __null
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                                 ,
      const char *nick = 
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                        __null
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                            ,
      int prio=0);
  void add_u64_counter_histogram(
    int key, const char* name,
    PerfHistogramCommon::axis_config_d x_axis_config,
    PerfHistogramCommon::axis_config_d y_axis_config,
    const char *description=
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                           __null
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                               ,
    const char* nick = 
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                      __null
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                          ,
    int prio=0, int unit=UNIT_NONE);

  void set_prio_default(int prio_)
  {
    prio_default = prio_;
  }

  PerfCounters* create_perf_counters();
private:
  PerfCountersBuilder(const PerfCountersBuilder &rhs);
  PerfCountersBuilder& operator=(const PerfCountersBuilder &rhs);
  void add_impl(int idx, const char *name,
                const char *description, const char *nick, int prio, int ty, int unit=UNIT_NONE,
                unique_ptr<PerfHistogram<>> histogram = nullptr);

  PerfCounters *m_perf_counters;

  int prio_default = 0;
};
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
class PerfCounters
{
public:

  struct perf_counter_data_any_d {
    perf_counter_data_any_d()
      : name(
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
            __null
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                ),
        description(
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
                   __null
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                       ),
        nick(
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h" 3 4
            __null
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters.h"
                ),
  type(PERFCOUNTER_NONE),
  unit(UNIT_NONE)
    {}
    perf_counter_data_any_d(const perf_counter_data_any_d& other)
      : name(other.name),
        description(other.description),
        nick(other.nick),
  type(other.type),
  unit(other.unit),
  u64(other.u64.load()) {
      pair<uint64_t,uint64_t> a = other.read_avg();
      u64 = a.first;
      avgcount = a.second;
      avgcount2 = a.second;
      if (other.histogram) {
        histogram.reset(new PerfHistogram<>(*other.histogram));
      }
    }

    const char *name;
    const char *description;
    const char *nick;
    uint8_t prio = 0;
    enum perfcounter_type_d type;
    enum unit_t unit;
    std::atomic<uint64_t> u64 = { 0 };
    std::atomic<uint64_t> avgcount = { 0 };
    std::atomic<uint64_t> avgcount2 = { 0 };
    std::unique_ptr<PerfHistogram<>> histogram;

    void reset()
    {
      if (type != PERFCOUNTER_U64) {
     u64 = 0;
     avgcount = 0;
     avgcount2 = 0;
      }
      if (histogram) {
        histogram->reset();
      }
    }




    pair<uint64_t,uint64_t> read_avg() const {
      uint64_t sum, count;
      do {
 count = avgcount2;
 sum = u64;
      } while (avgcount != count);
      return make_pair(sum, count);
    }
  };

  template <typename T>
  struct avg_tracker {
    pair<uint64_t, T> last;
    pair<uint64_t, T> cur;
    avg_tracker() : last(0, 0), cur(0, 0) {}
    T current_avg() const {
      if (cur.first == last.first)
        return 0;
      return (cur.second - last.second) / (cur.first - last.first);
    }
    void consume_next(const pair<uint64_t, T> &next) {
      last = cur;
      cur = next;
    }
  };

  ~PerfCounters();

  void inc(int idx, uint64_t v = 1);
  void dec(int idx, uint64_t v = 1);
  void set(int idx, uint64_t v);
  uint64_t get(int idx) const;

  void tset(int idx, utime_t v);
  void tinc(int idx, utime_t v);
  void tinc(int idx, ceph::timespan v);
  utime_t tget(int idx) const;

  void hinc(int idx, int64_t x, int64_t y);

  void reset();
  void dump_formatted(ceph::Formatter *f, bool schema,
                      const std::string &counter = "") const {
    dump_formatted_generic(f, schema, false, counter);
  }
  void dump_formatted_histograms(ceph::Formatter *f, bool schema,
                                 const std::string &counter = "") const {
    dump_formatted_generic(f, schema, true, counter);
  }
  pair<uint64_t, uint64_t> get_tavg_ns(int idx) const;

  const std::string& get_name() const;
  void set_name(std::string s) {
    m_name = s;
  }


  void set_prio_adjust(int p) {
    prio_adjust = p;
  }

  int get_adjusted_priority(int p) const {
    return std::max(std::min(p + prio_adjust,
                             (int)PerfCountersBuilder::PRIO_CRITICAL),
                    0);
  }

private:
  PerfCounters(CephContext *cct, const std::string &name,
      int lower_bound, int upper_bound);
  PerfCounters(const PerfCounters &rhs);
  PerfCounters& operator=(const PerfCounters &rhs);
  void dump_formatted_generic(ceph::Formatter *f, bool schema, bool histograms,
                              const std::string &counter = "") const;

  typedef std::vector<perf_counter_data_any_d> perf_counter_data_vec_t;

  CephContext *m_cct;
  int m_lower_bound;
  int m_upper_bound;
  std::string m_name;

  int prio_adjust = 0;


  const std::string m_lock_name;

  ceph::mutex m_lock;


  perf_counter_data_vec_t m_data;

  friend class PerfCountersBuilder;
  friend class PerfCountersCollectionImpl;
};

class SortPerfCountersByName {
public:
  bool operator()(const PerfCounters* lhs, const PerfCounters* rhs) const {
    return (lhs->get_name() < rhs->get_name());
  }
};

typedef std::set <PerfCounters*, SortPerfCountersByName> perf_counters_set_t;




class PerfCountersCollectionImpl
{
public:
  PerfCountersCollectionImpl();
  ~PerfCountersCollectionImpl();
  void add(PerfCounters *l);
  void remove(PerfCounters *l);
  void clear();
  bool reset(const std::string &name);

  void dump_formatted(ceph::Formatter *f, bool schema,
                      const std::string &logger = "",
                      const std::string &counter = "") const {
    dump_formatted_generic(f, schema, false, logger, counter);
  }

  void dump_formatted_histograms(ceph::Formatter *f, bool schema,
                                 const std::string &logger = "",
                                 const std::string &counter = "") const {
    dump_formatted_generic(f, schema, true, logger, counter);
  }




  class PerfCounterRef
  {
    public:
    PerfCounters::perf_counter_data_any_d *data;
    PerfCounters *perf_counters;
  };
  typedef std::map<std::string,
          PerfCounterRef> CounterMap;

  void with_counters(std::function<void(const CounterMap &)>) const;

private:
  void dump_formatted_generic(ceph::Formatter *f, bool schema, bool histograms,
                              const std::string &logger = "",
                              const std::string &counter = "") const;

  perf_counters_set_t m_loggers;

  CounterMap by_path;
};


class PerfGuard {
  const ceph::real_clock::time_point start;
  PerfCounters* const counters;
  const int event;

public:
  PerfGuard(PerfCounters* const counters,
            const int event)
  : start(ceph::real_clock::now()),
    counters(counters),
    event(event) {
  }

  ~PerfGuard() {
    counters->tinc(event, ceph::real_clock::now() - start);
  }
};
# 4 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/perf_counters_collection.h" 2


class CephContext;

class PerfCountersCollection
{
  CephContext *m_cct;


  mutable ceph::mutex m_lock;
  PerfCountersCollectionImpl perf_impl;
public:
  PerfCountersCollection(CephContext *cct);
  ~PerfCountersCollection();
  void add(PerfCounters *l);
  void remove(PerfCounters *l);
  void clear();
  bool reset(const std::string &name);

  void dump_formatted(ceph::Formatter *f, bool schema,
                      const std::string &logger = "",
                      const std::string &counter = "");
  void dump_formatted_histograms(ceph::Formatter *f, bool schema,
                                 const std::string &logger = "",
                                 const std::string &counter = "");

  void with_counters(std::function<void(const PerfCountersCollectionImpl::CounterMap &)>) const;

  friend class PerfCountersCollectionTest;
};

class PerfCountersDeleter {
  CephContext* cct;

public:
  PerfCountersDeleter() noexcept : cct(nullptr) {}
  PerfCountersDeleter(CephContext* cct) noexcept : cct(cct) {}
  void operator()(PerfCounters* p) noexcept;
};

using PerfCountersRef = std::unique_ptr<PerfCounters, PerfCountersDeleter>;
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 2



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/crush/CrushLocation.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/crush/CrushLocation.h"
class CephContext;

class CrushLocation {
  CephContext *cct;
  std::multimap<std::string,std::string> loc;
  std::mutex lock;

  int _parse(const std::string& s);

public:
  explicit CrushLocation(CephContext *c) : cct(c) {
    init_on_startup();
  }

  int update_from_conf();
  int update_from_hook();
  int init_on_startup();

  std::multimap<std::string,std::string> get_location() {
    std::lock_guard<std::mutex> l(lock);
    return loc;
  }
};
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h" 2

class AdminSocket;
class CephContextServiceThread;
class CephContextHook;
class CephContextObs;
class CryptoHandler;
class CryptoRandom;

namespace ceph {
  class PluginRegistry;
  class HeartbeatMap;
  namespace logging {
    class Log;
  }
}
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h"
class CephContext {
public:
  CephContext(uint32_t module_type_,
              enum code_environment_t code_env=CODE_ENVIRONMENT_UTILITY,
              int init_flags_ = 0);

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

  bool _finished = false;


private:
  ~CephContext();
  std::atomic<unsigned> nref;
public:
  CephContext *get() {
    ++nref;
    return this;
  }
  void put();

  ConfigProxy _conf;
  ceph::logging::Log *_log;


  void init_crypto();


  void shutdown_crypto();


  void start_service_thread();


  void reopen_logs();


  uint32_t get_module_type() const;


  void _set_module_type(uint32_t t) {
    _module_type = t;
  }

  void set_init_flags(int flags);
  int get_init_flags() const;


  PerfCountersCollection *get_perfcounters_collection();

  ceph::HeartbeatMap *get_heartbeat_map() {
    return _heartbeat_map;
  }
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/ceph_context.h"
  AdminSocket *get_admin_socket();




  void do_command(std::string_view command, const cmdmap_t& cmdmap,
    std::string_view format, ceph::bufferlist *out);

  static constexpr std::size_t largest_singleton = 8 * 72;

  template<typename T, typename... Args>
  T& lookup_or_create_singleton_object(std::string_view name,
           bool drop_on_fork,
           Args&&... args) {
    static_assert(sizeof(T) <= largest_singleton,
    "Please increase largest singleton.");
    std::lock_guard lg(associated_objs_lock);
    std::type_index type = typeid(T);

    auto i = associated_objs.find(std::make_pair(name, type));
    if (i == associated_objs.cend()) {
      if (drop_on_fork) {
 associated_objs_drop_on_fork.insert(std::string(name));
      }
      i = associated_objs.emplace_hint(
 i,
 std::piecewise_construct,
 std::forward_as_tuple(name, type),
 std::forward_as_tuple(std::in_place_type<T>,
         std::forward<Args>(args)...));
    }
    return ceph::any_cast<T&>(i->second);
  }




  CryptoHandler *get_crypto_handler(int type);

  CryptoRandom* random() const { return _crypto_random.get(); }


  bool check_experimental_feature_enabled(const std::string& feature);
  bool check_experimental_feature_enabled(const std::string& feature,
       std::ostream *message);

  PluginRegistry *get_plugin_registry() {
    return _plugin_registry;
  }

  void set_uid_gid(uid_t u, gid_t g) {
    _set_uid = u;
    _set_gid = g;
  }
  uid_t get_set_uid() const {
    return _set_uid;
  }
  gid_t get_set_gid() const {
    return _set_gid;
  }

  void set_uid_gid_strings(const std::string &u, const std::string &g) {
    _set_uid_string = u;
    _set_gid_string = g;
  }
  std::string get_set_uid_string() const {
    return _set_uid_string;
  }
  std::string get_set_gid_string() const {
    return _set_gid_string;
  }

  class ForkWatcher {
   public:
    virtual ~ForkWatcher() {}
    virtual void handle_pre_fork() = 0;
    virtual void handle_post_fork() = 0;
  };

  void register_fork_watcher(ForkWatcher *w) {
    std::lock_guard lg(_fork_watchers_lock);
    _fork_watchers.push_back(w);
  }

  void notify_pre_fork();
  void notify_post_fork();

private:



  void join_service_thread();

  uint32_t _module_type;

  int _init_flags;

  uid_t _set_uid;
  gid_t _set_gid;
  std::string _set_uid_string;
  std::string _set_gid_string;

  int _crypto_inited;



  friend class CephContextServiceThread;
  CephContextServiceThread *_service_thread;

  using md_config_obs_t = ceph::md_config_obs_impl<ConfigProxy>;

  md_config_obs_t *_log_obs;


  AdminSocket *_admin_socket;


  ceph::spinlock _service_thread_lock;


  PerfCountersCollection *_perf_counters_collection;

  md_config_obs_t *_perf_counters_conf_obs;

  CephContextHook *_admin_hook;

  ceph::HeartbeatMap *_heartbeat_map;

  ceph::spinlock associated_objs_lock;

  struct associated_objs_cmp {
    using is_transparent = std::true_type;
    template<typename T, typename U>
    bool operator ()(const std::pair<T, std::type_index>& l,
       const std::pair<U, std::type_index>& r) const noexcept {
      return ((l.first < r.first) ||
       (l.first == r.first && l.second < r.second));
    }
  };

  std::map<std::pair<std::string, std::type_index>,
    ceph::immobile_any<largest_singleton>,
    associated_objs_cmp> associated_objs;
  std::set<std::string> associated_objs_drop_on_fork;

  ceph::spinlock _fork_watchers_lock;
  std::vector<ForkWatcher*> _fork_watchers;


  CryptoHandler *_crypto_none;
  CryptoHandler *_crypto_aes;
  std::unique_ptr<CryptoRandom> _crypto_random;


  CephContextObs *_cct_obs;
  ceph::spinlock _feature_lock;
  std::set<std::string> _experimental_features;

  PluginRegistry *_plugin_registry;

  md_config_obs_t *_lockdep_obs;

public:
  CrushLocation crush_location;
private:

  enum {
    l_cct_first,
    l_cct_total_workers,
    l_cct_unhealthy_workers,
    l_cct_last
  };
  enum {
    l_mempool_first = 873222,
    l_mempool_bytes,
    l_mempool_items,
    l_mempool_last
  };
  PerfCounters *_cct_perf = nullptr;
  PerfCounters* _mempool_perf = nullptr;
  std::vector<std::string> _mempool_perf_names, _mempool_perf_descriptions;




  void _enable_perf_counter();




  void _disable_perf_counter();




  void _refresh_perf_values();

  friend class CephContextObs;
};
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/dout.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Clock.h" 1
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Clock.h"
static inline utime_t ceph_clock_now()
{

  struct timespec tp;
  clock_gettime(
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Clock.h" 3 4
               0
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Clock.h"
                             , &tp);
  utime_t n(tp);





  return n;
}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/dout.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Log.h" 1






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer_fwd.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer_fwd.hpp" 3 4

# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer_fwd.hpp" 3 4
namespace boost {







template <class T, class Alloc = std::allocator<T> >
class circular_buffer;

template <class T, class Alloc = std::allocator<T> >
class circular_buffer_space_optimized;



}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/debug.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/debug.hpp" 3 4
namespace boost {

namespace cb_details {
# 244 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/debug.hpp" 3 4
}

}
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/details.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/details.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/pointer_traits.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/pointer_traits.hpp" 3 4
namespace boost {


template<class T>
struct pointer_traits
    : std::pointer_traits<T> {
    template<class U>
    struct rebind_to {
        typedef typename std::pointer_traits<T>::template rebind<U> type;
    };
};

template<class T>
struct pointer_traits<T*>
    : std::pointer_traits<T*> {
    template<class U>
    struct rebind_to {
        typedef U* type;
    };
};
# 182 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/pointer_traits.hpp" 3 4
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);
}
# 231 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/pointer_traits.hpp" 3 4
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/details.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/details.hpp" 3 4
namespace boost {

namespace cb_details {

template <class Traits> struct nonconst_traits;

template<class ForwardIterator, class Diff, class T, class Alloc>
void uninitialized_fill_n_with_alloc(
    ForwardIterator first, Diff n, const T& item, Alloc& alloc);

template<class InputIterator, class ForwardIterator, class Alloc>
ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a);

template<class InputIterator, class ForwardIterator, class Alloc>
ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a);





template <class Traits>
struct const_traits {

    typedef typename Traits::value_type value_type;
    typedef typename Traits::const_pointer pointer;
    typedef typename Traits::const_reference reference;
    typedef typename Traits::size_type size_type;
    typedef typename Traits::difference_type difference_type;


    typedef nonconst_traits<Traits> nonconst_self;
};





template <class Traits>
struct nonconst_traits {

    typedef typename Traits::value_type value_type;
    typedef typename Traits::pointer pointer;
    typedef typename Traits::reference reference;
    typedef typename Traits::size_type size_type;
    typedef typename Traits::difference_type difference_type;


    typedef nonconst_traits<Traits> nonconst_self;
};





template <class Iterator>
struct iterator_wrapper {
    mutable Iterator m_it;
    explicit iterator_wrapper(Iterator it) : m_it(it) {}
    Iterator operator () () const { return m_it++; }
private:
    iterator_wrapper<Iterator>& operator = (const iterator_wrapper<Iterator>&);
};





template <class Pointer, class Value>
struct item_wrapper {
    Value m_item;
    explicit item_wrapper(Value item) : m_item(item) {}
    Pointer operator () () const { return &m_item; }
private:
    item_wrapper<Pointer, Value>& operator = (const item_wrapper<Pointer, Value>&);
};





template <class Value, class Alloc>
struct assign_n {
    typedef typename boost::container::allocator_traits<Alloc>::size_type size_type;
    size_type m_n;
    Value m_item;
    Alloc& m_alloc;
    assign_n(size_type n, Value item, Alloc& alloc) : m_n(n), m_item(item), m_alloc(alloc) {}
    template <class Pointer>
    void operator () (Pointer p) const {
        uninitialized_fill_n_with_alloc(p, m_n, m_item, m_alloc);
    }
private:
    assign_n<Value, Alloc>& operator = (const assign_n<Value, Alloc>&);
};





template <class Iterator, class Alloc>
struct assign_range {
    Iterator m_first;
    Iterator m_last;
    Alloc& m_alloc;

    assign_range(const Iterator& first, const Iterator& last, Alloc& alloc)
        : m_first(first), m_last(last), m_alloc(alloc) {}

    template <class Pointer>
    void operator () (Pointer p) const {
        boost::cb_details::uninitialized_copy(m_first, m_last, p, m_alloc);
    }
};

template <class Iterator, class Alloc>
inline assign_range<Iterator, Alloc> make_assign_range(const Iterator& first, const Iterator& last, Alloc& a) {
    return assign_range<Iterator, Alloc>(first, last, a);
}





template <class Size>
class capacity_control {


    Size m_capacity;


    Size m_min_capacity;

public:


    capacity_control(Size buffer_capacity, Size min_buffer_capacity = 0)
    : m_capacity(buffer_capacity), m_min_capacity(min_buffer_capacity)
    {
        ((void)0);
    }






    Size capacity() const { return m_capacity; }


    Size min_capacity() const { return m_min_capacity; }


    operator Size() const { return m_capacity; }
};
# 197 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/details.hpp" 3 4
template <class Buff, class Traits>
struct iterator :
    public std::iterator<
    std::random_access_iterator_tag,
    typename Traits::value_type,
    typename Traits::difference_type,
    typename Traits::pointer,
    typename Traits::reference>



{



    typedef std::iterator<
        std::random_access_iterator_tag,
        typename Traits::value_type,
        typename Traits::difference_type,
        typename Traits::pointer,
        typename Traits::reference> base_iterator;


    typedef iterator<Buff, typename Traits::nonconst_self> nonconst_self;




    typedef typename base_iterator::value_type value_type;


    typedef typename base_iterator::pointer pointer;


    typedef typename base_iterator::reference reference;


    typedef typename Traits::size_type size_type;


    typedef typename base_iterator::difference_type difference_type;




    const Buff* m_buff;


    pointer m_it;






    iterator() : m_buff(0), m_it(0) {}
# 267 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/details.hpp" 3 4
    iterator(const nonconst_self& it) : m_buff(it.m_buff), m_it(it.m_it) {}

    iterator(const Buff* cb, const pointer p) : m_buff(cb), m_it(p) {}




    iterator& operator = (const iterator& it) {
        if (this == &it)
            return *this;



        m_buff = it.m_buff;
        m_it = it.m_it;
        return *this;
    }




    reference operator * () const {
        ((void)0);
        ((void)0);
        return *m_it;
    }


    pointer operator -> () const { return &(operator*()); }


    template <class Traits0>
    difference_type operator - (const iterator<Buff, Traits0>& it) const {
        ((void)0);
        ((void)0);
        return linearize_pointer(*this) - linearize_pointer(it);
    }


    iterator& operator ++ () {
        ((void)0);
        ((void)0);
        m_buff->increment(m_it);
        if (m_it == m_buff->m_last)
            m_it = 0;
        return *this;
    }


    iterator operator ++ (int) {
        iterator<Buff, Traits> tmp = *this;
        ++*this;
        return tmp;
    }


    iterator& operator -- () {
        ((void)0);
        ((void)0);
        if (m_it == 0)
            m_it = m_buff->m_last;
        m_buff->decrement(m_it);
        return *this;
    }


    iterator operator -- (int) {
        iterator<Buff, Traits> tmp = *this;
        --*this;
        return tmp;
    }


    iterator& operator += (difference_type n) {
        ((void)0);
        if (n > 0) {
            ((void)0);
            m_it = m_buff->add(m_it, n);
            if (m_it == m_buff->m_last)
                m_it = 0;
        } else if (n < 0) {
            *this -= -n;
        }
        return *this;
    }


    iterator operator + (difference_type n) const { return iterator<Buff, Traits>(*this) += n; }


    iterator& operator -= (difference_type n) {
        ((void)0);
        if (n > 0) {
            ((void)0);
            m_it = m_buff->sub(m_it == 0 ? m_buff->m_last : m_it, n);
        } else if (n < 0) {
            *this += -n;
        }
        return *this;
    }


    iterator operator - (difference_type n) const { return iterator<Buff, Traits>(*this) -= n; }


    reference operator [] (difference_type n) const { return *(*this + n); }




    template <class Traits0>
    bool operator == (const iterator<Buff, Traits0>& it) const {
        ((void)0);
        ((void)0);
        return m_it == it.m_it;
    }


    template <class Traits0>
    bool operator != (const iterator<Buff, Traits0>& it) const {
        ((void)0);
        ((void)0);
        return m_it != it.m_it;
    }


    template <class Traits0>
    bool operator < (const iterator<Buff, Traits0>& it) const {
        ((void)0);
        ((void)0);
        return linearize_pointer(*this) < linearize_pointer(it);
    }


    template <class Traits0>
    bool operator > (const iterator<Buff, Traits0>& it) const { return it < *this; }


    template <class Traits0>
    bool operator <= (const iterator<Buff, Traits0>& it) const { return !(it < *this); }


    template <class Traits0>
    bool operator >= (const iterator<Buff, Traits0>& it) const { return !(*this < it); }




    template <class Traits0>
    typename Traits0::pointer linearize_pointer(const iterator<Buff, Traits0>& it) const {
        return it.m_it == 0 ? m_buff->m_buff + m_buff->size() :
            (it.m_it < m_buff->m_first ? it.m_it + (m_buff->m_end - m_buff->m_first)
                : m_buff->m_buff + (it.m_it - m_buff->m_first));
    }
};


template <class Buff, class Traits>
inline iterator<Buff, Traits>
operator + (typename Traits::difference_type n, const iterator<Buff, Traits>& it) {
    return it + n;
}





template<class InputIterator, class ForwardIterator, class Alloc>
inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) {
    ForwardIterator next = dest;
    { try {
        for (; first != last; ++first, ++dest)
            boost::container::allocator_traits<Alloc>::construct(a, boost::to_address(dest), *first);
    } catch(...) {
        for (; next != dest; ++next)
            boost::container::allocator_traits<Alloc>::destroy(a, boost::to_address(next));
        throw;
    }
    }
    return dest;
}

template<class InputIterator, class ForwardIterator, class Alloc>
ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
    true_type) {
    for (; first != last; ++first, ++dest)
        boost::container::allocator_traits<Alloc>::construct(a, boost::to_address(dest), boost::move(*first));
    return dest;
}

template<class InputIterator, class ForwardIterator, class Alloc>
ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
    false_type) {
    return uninitialized_copy(first, last, dest, a);
}





template<class InputIterator, class ForwardIterator, class Alloc>
ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) {
    typedef typename boost::is_nothrow_move_constructible<typename boost::container::allocator_traits<Alloc>::value_type>::type tag_t;
    return uninitialized_move_if_noexcept_impl(first, last, dest, a, tag_t());
}





template<class ForwardIterator, class Diff, class T, class Alloc>
inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const T& item, Alloc& alloc) {
    ForwardIterator next = first;
    { try {
        for (; n > 0; ++first, --n)
            boost::container::allocator_traits<Alloc>::construct(alloc, boost::to_address(first), item);
    } catch(...) {
        for (; next != first; ++next)
            boost::container::allocator_traits<Alloc>::destroy(alloc, boost::to_address(next));
        throw;
    }
    }
}

}

}
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 1 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
namespace boost {
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
class circular_buffer





{
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
public:



    typedef circular_buffer<T, Alloc> this_type;


    typedef typename boost::container::allocator_traits<Alloc>::value_type value_type;


    typedef typename boost::container::allocator_traits<Alloc>::pointer pointer;


    typedef typename boost::container::allocator_traits<Alloc>::const_pointer const_pointer;


    typedef typename boost::container::allocator_traits<Alloc>::reference reference;


    typedef typename boost::container::allocator_traits<Alloc>::const_reference const_reference;





    typedef typename boost::container::allocator_traits<Alloc>::difference_type difference_type;





    typedef typename boost::container::allocator_traits<Alloc>::size_type size_type;


    typedef Alloc allocator_type;




    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::const_traits<boost::container::allocator_traits<Alloc> > > const_iterator;


    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::nonconst_traits<boost::container::allocator_traits<Alloc> > > iterator;


    typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;


    typedef boost::reverse_iterator<iterator> reverse_iterator;
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    typedef std::pair<pointer, size_type> array_range;







    typedef std::pair<const_pointer, size_type> const_array_range;
# 167 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    typedef size_type capacity_type;




    typedef const value_type& param_value_type;



    typedef value_type && rvalue_type;

private:



    pointer m_buff;


    pointer m_end;


    pointer m_first;


    pointer m_last;


    size_type m_size;


    allocator_type m_alloc;






    template <class Buff, class Traits> friend struct cb_details::iterator;


public:
# 222 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    allocator_type get_allocator() const noexcept { return m_alloc; }
# 238 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    allocator_type& get_allocator() noexcept { return m_alloc; }
# 256 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator begin() noexcept { return iterator(this, empty() ? 0 : m_first); }
# 272 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator end() noexcept { return iterator(this, 0); }
# 288 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_iterator begin() const noexcept { return const_iterator(this, empty() ? 0 : m_first); }
# 304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_iterator end() const noexcept { return const_iterator(this, 0); }
# 320 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
# 336 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
# 352 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
# 368 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    reference operator [] (size_type index) {
        ((void)0);
        return *add(m_first, index);
    }
# 403 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_reference operator [] (size_type index) const {
        ((void)0);
        return *add(m_first, index);
    }
# 422 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    reference at(size_type index) {
        check_position(index);
        return (*this)[index];
    }
# 441 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_reference at(size_type index) const {
        check_position(index);
        return (*this)[index];
    }
# 459 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    reference front() {
        ((void)0);
        return *m_first;
    }
# 477 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    reference back() {
        ((void)0);
        return *((m_last == m_buff ? m_end : m_last) - 1);
    }
# 495 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_reference front() const {
        ((void)0);
        return *m_first;
    }
# 513 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_reference back() const {
        ((void)0);
        return *((m_last == m_buff ? m_end : m_last) - 1);
    }
# 564 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    array_range array_one() {
        return array_range(m_first, (m_last <= m_first && !empty() ? m_end : m_last) - m_first);
    }
# 584 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    array_range array_two() {
        return array_range(m_buff, m_last <= m_first && !empty() ? m_last - m_buff : 0);
    }
# 604 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_array_range array_one() const {
        return const_array_range(m_first, (m_last <= m_first && !empty() ? m_end : m_last) - m_first);
    }
# 624 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    const_array_range array_two() const {
        return const_array_range(m_buff, m_last <= m_first && !empty() ? m_last - m_buff : 0);
    }
# 648 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    pointer linearize() {
        if (empty())
            return 0;
        if (m_first < m_last || m_last == m_buff)
            return m_first;
        pointer src = m_first;
        pointer dest = m_buff;
        size_type moved = 0;
        size_type constructed = 0;
        { try {
            for (pointer first = m_first; dest < src; src = first) {
                for (size_type ii = 0; src < m_end; ++src, ++dest, ++moved, ++ii) {
                    if (moved == size()) {
                        first = dest;
                        break;
                    }
                    if (dest == first) {
                        first += ii;
                        break;
                    }
                    if (is_uninitialized(dest)) {
                        boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(dest), boost::move_if_noexcept(*src));
                        ++constructed;
                    } else {
                        value_type tmp = boost::move_if_noexcept(*src);
                        replace(src, boost::move_if_noexcept(*dest));
                        replace(dest, boost::move(tmp));
                    }
                }
            }
        } catch(...) {
            m_last += constructed;
            m_size += constructed;
            throw;
        }
        }
        for (src = m_end - constructed; src < m_end; ++src)
            destroy_item(src);
        m_first = m_buff;
        m_last = add(m_buff, size());



        return m_buff;
    }
# 709 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    bool is_linearized() const noexcept { return m_first < m_last || m_last == m_buff; }
# 738 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void rotate(const_iterator new_begin) {
        ((void)0);
        ((void)0);
        if (full()) {
            m_first = m_last = const_cast<pointer>(new_begin.m_it);
        } else {
            difference_type m = end() - new_begin;
            difference_type n = new_begin - begin();
            if (m < n) {
                for (; m > 0; --m) {
                    push_front(boost::move_if_noexcept(back()));
                    pop_back();
                }
            } else {
                for (; n > 0; --n) {
                    push_back(boost::move_if_noexcept(front()));
                    pop_front();
                }
            }
        }
    }
# 775 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    size_type size() const noexcept { return m_size; }
# 789 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    size_type max_size() const noexcept {
        return (std::min<size_type>)(boost::container::allocator_traits<Alloc>::max_size(m_alloc), (std::numeric_limits<difference_type>::max)());
    }
# 806 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    bool empty() const noexcept { return size() == 0; }
# 821 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    bool full() const noexcept { return capacity() == size(); }
# 835 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    size_type reserve() const noexcept { return capacity() - size(); }
# 850 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    capacity_type capacity() const noexcept { return m_end - m_buff; }
# 874 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void set_capacity(capacity_type new_capacity) {
        if (new_capacity == capacity())
            return;
        pointer buff = allocate(new_capacity);
        iterator b = begin();
        { try {
            reset(buff,
                cb_details::uninitialized_move_if_noexcept(b, b + (std::min)(new_capacity, size()), buff, m_alloc),
                new_capacity);
        } catch(...) {
            deallocate(buff, new_capacity);
            throw;
        }
        }
    }
# 917 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void resize(size_type new_size, param_value_type item = value_type()) {
        if (new_size > size()) {
            if (new_size > capacity())
                set_capacity(new_size);
            insert(end(), new_size - size(), item);
        } else {
            iterator e = end();
            erase(e - (size() - new_size), e);
        }
    }
# 950 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void rset_capacity(capacity_type new_capacity) {
        if (new_capacity == capacity())
            return;
        pointer buff = allocate(new_capacity);
        iterator e = end();
        { try {
            reset(buff, cb_details::uninitialized_move_if_noexcept(e - (std::min)(new_capacity, size()),
                e, buff, m_alloc), new_capacity);
        } catch(...) {
            deallocate(buff, new_capacity);
            throw;
        }
        }
    }
# 992 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void rresize(size_type new_size, param_value_type item = value_type()) {
        if (new_size > size()) {
            if (new_size > capacity())
                set_capacity(new_size);
            rinsert(begin(), new_size - size(), item);
        } else {
            rerase(begin(), end() - new_size);
        }
    }
# 1022 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    explicit circular_buffer(const allocator_type& alloc = allocator_type()) noexcept
    : m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0), m_alloc(alloc) {}
# 1035 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    explicit circular_buffer(capacity_type buffer_capacity, const allocator_type& alloc = allocator_type())
    : m_size(0), m_alloc(alloc) {
        initialize_buffer(buffer_capacity);
        m_first = m_last = m_buff;
    }
# 1054 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    circular_buffer(size_type n, param_value_type item, const allocator_type& alloc = allocator_type())
    : m_size(n), m_alloc(alloc) {
        initialize_buffer(n, item);
        m_first = m_last = m_buff;
    }
# 1075 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    circular_buffer(capacity_type buffer_capacity, size_type n, param_value_type item,
        const allocator_type& alloc = allocator_type())
    : m_size(n), m_alloc(alloc) {
        ((void)0);
        initialize_buffer(buffer_capacity, item);
        m_first = m_buff;
        m_last = buffer_capacity == n ? m_buff : m_buff + n;
    }
# 1095 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    circular_buffer(const circular_buffer<T, Alloc>& cb)
    :



    m_size(cb.size()), m_alloc(cb.get_allocator()) {
        initialize_buffer(cb.capacity());
        m_first = m_buff;
        { try {
            m_last = cb_details::uninitialized_copy(cb.begin(), cb.end(), m_buff, m_alloc);
        } catch(...) {
            deallocate(m_buff, cb.capacity());
            throw;
        }
        }
        if (m_last == m_end)
            m_last = m_buff;
    }
# 1123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    circular_buffer(circular_buffer<T, Alloc>&& cb) noexcept
    : m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0), m_alloc(cb.get_allocator()) {
        cb.swap(*this);
    }
# 1145 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    template <class InputIterator>
    circular_buffer(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type())
    : m_alloc(alloc) {
        initialize(first, last, is_integral<InputIterator>());
    }
# 1174 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    template <class InputIterator>
    circular_buffer(capacity_type buffer_capacity, InputIterator first, InputIterator last,
        const allocator_type& alloc = allocator_type())
    : m_alloc(alloc) {
        initialize(buffer_capacity, first, last, is_integral<InputIterator>());
    }
# 1192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    ~circular_buffer() noexcept {
        destroy();



    }

public:
# 1223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    circular_buffer<T, Alloc>& operator = (const circular_buffer<T, Alloc>& cb) {
        if (this == &cb)
            return *this;
        pointer buff = allocate(cb.capacity());
        { try {
            reset(buff, cb_details::uninitialized_copy(cb.begin(), cb.end(), buff, m_alloc), cb.capacity());
        } catch(...) {
            deallocate(buff, cb.capacity());
            throw;
        }
        }
        return *this;
    }
# 1246 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    circular_buffer<T, Alloc>& operator = (circular_buffer<T, Alloc>&& cb) noexcept {
        cb.swap(*this);
        circular_buffer<T, Alloc>(get_allocator())
            .swap(cb);
        return *this;
    }
# 1278 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void assign(size_type n, param_value_type item) {
        assign_n(n, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
    }
# 1307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void assign(capacity_type buffer_capacity, size_type n, param_value_type item) {
        ((void)0);
        assign_n(buffer_capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
    }
# 1340 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    template <class InputIterator>
    void assign(InputIterator first, InputIterator last) {
        assign(first, last, is_integral<InputIterator>());
    }
# 1379 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    template <class InputIterator>
    void assign(capacity_type buffer_capacity, InputIterator first, InputIterator last) {
        assign(buffer_capacity, first, last, is_integral<InputIterator>());
    }
# 1401 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void swap(circular_buffer<T, Alloc>& cb) noexcept {
        swap_allocator(cb, is_stateless<allocator_type>());
        adl_move_swap(m_buff, cb.m_buff);
        adl_move_swap(m_end, cb.m_end);
        adl_move_swap(m_first, cb.m_first);
        adl_move_swap(m_last, cb.m_last);
        adl_move_swap(m_size, cb.m_size);




    }


private:
    template <class ValT>
    void push_back_impl(ValT item) {
        if (full()) {
            if (empty())
                return;
            replace(m_last, static_cast<ValT>(item));
            increment(m_last);
            m_first = m_last;
        } else {
            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(m_last), static_cast<ValT>(item));
            increment(m_last);
            ++m_size;
        }
    }

    template <class ValT>
    void push_front_impl(ValT item) {
        { try {
            if (full()) {
                if (empty())
                    return;
                decrement(m_first);
                replace(m_first, static_cast<ValT>(item));
                m_last = m_first;
            } else {
                decrement(m_first);
                boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(m_first), static_cast<ValT>(item));
                ++m_size;
            }
        } catch(...) {
            increment(m_first);
            throw;
        }
        }
    }

public:
# 1470 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void push_back(param_value_type item) {
        push_back_impl<param_value_type>(item);
    }
# 1491 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void push_back(rvalue_type item) {
        push_back_impl<rvalue_type>(boost::move(item));
    }
# 1512 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void push_back() {
        value_type temp;
        push_back(boost::move(temp));
    }
# 1534 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void push_front(param_value_type item) {
        push_front_impl<param_value_type>(item);
    }
# 1555 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void push_front(rvalue_type item) {
        push_front_impl<rvalue_type>(boost::move(item));
    }
# 1576 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void push_front() {
        value_type temp;
        push_front(boost::move(temp));
    }
# 1595 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void pop_back() {
        ((void)0);
        decrement(m_last);
        destroy_item(m_last);
        --m_size;
    }
# 1616 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void pop_front() {
        ((void)0);
        destroy_item(m_first);
        increment(m_first);
        --m_size;
    }
private:
    template <class ValT>
    iterator insert_impl(iterator pos, ValT item) {
        ((void)0);
        iterator b = begin();
        if (full() && pos == b)
            return b;
        return insert_item<ValT>(pos, static_cast<ValT>(item));
    }

public:
# 1666 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator insert(iterator pos, param_value_type item) {
        return insert_impl<param_value_type>(pos, item);
    }
# 1700 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator insert(iterator pos, rvalue_type item) {
        return insert_impl<rvalue_type>(pos, boost::move(item));
    }
# 1734 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator insert(iterator pos) {
        value_type temp;
        return insert(pos, boost::move(temp));
    }
# 1777 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void insert(iterator pos, size_type n, param_value_type item) {
        ((void)0);
        if (n == 0)
            return;
        size_type copy = capacity() - (end() - pos);
        if (copy == 0)
            return;
        if (n > copy)
            n = copy;
        insert_n(pos, n, cb_details::item_wrapper<const_pointer, param_value_type>(item));
    }
# 1835 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    template <class InputIterator>
    void insert(iterator pos, InputIterator first, InputIterator last) {
        ((void)0);
        insert(pos, first, last, is_integral<InputIterator>());
    }

private:
    template <class ValT>
    iterator rinsert_impl(iterator pos, ValT item) {
        ((void)0);
        if (full() && pos.m_it == 0)
            return end();
        if (pos == begin()) {
            { try {
                decrement(m_first);
                construct_or_replace(!full(), m_first, static_cast<ValT>(item));
            } catch(...) {
                increment(m_first);
                throw;
            }
            }
            pos.m_it = m_first;
        } else {
            pointer src = m_first;
            pointer dest = m_first;
            decrement(dest);
            pos.m_it = map_pointer(pos.m_it);
            bool construct = !full();
            { try {
                while (src != pos.m_it) {
                    construct_or_replace(construct, dest, boost::move_if_noexcept(*src));
                    increment(src);
                    increment(dest);
                    construct = false;
                }
                decrement(pos.m_it);
                replace(pos.m_it, static_cast<ValT>(item));
            } catch(...) {
                if (!construct && !full()) {
                    decrement(m_first);
                    ++m_size;
                }
                throw;
            }
            }
            decrement(m_first);
        }
        if (full())
            m_last = m_first;
        else
            ++m_size;
        return iterator(this, pos.m_it);
    }

public:
# 1920 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator rinsert(iterator pos, param_value_type item) {
        return rinsert_impl<param_value_type>(pos, item);
    }
# 1953 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator rinsert(iterator pos, rvalue_type item) {
        return rinsert_impl<rvalue_type>(pos, boost::move(item));
    }
# 1986 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator rinsert(iterator pos) {
        value_type temp;
        return rinsert(pos, boost::move(temp));
    }
# 2028 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void rinsert(iterator pos, size_type n, param_value_type item) {
        ((void)0);
        rinsert_n(pos, n, cb_details::item_wrapper<const_pointer, param_value_type>(item));
    }
# 2078 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    template <class InputIterator>
    void rinsert(iterator pos, InputIterator first, InputIterator last) {
        ((void)0);
        rinsert(pos, first, last, is_integral<InputIterator>());
    }
# 2106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator erase(iterator pos) {
        ((void)0);
        ((void)0);
        pointer next = pos.m_it;
        increment(next);
        for (pointer p = pos.m_it; next != m_last; p = next, increment(next))
            replace(p, boost::move_if_noexcept(*next));
        decrement(m_last);
        destroy_item(m_last);
        --m_size;



        return m_last == pos.m_it ? end() : pos;

    }
# 2143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator erase(iterator first, iterator last) {
        ((void)0);
        ((void)0);
        ((void)0);
        if (first == last)
            return first;
        pointer p = first.m_it;
        while (last.m_it != 0)
            replace((first++).m_it, boost::move_if_noexcept(*last++));
        do {
            decrement(m_last);
            destroy_item(m_last);
            --m_size;
        } while(m_last != first.m_it);
        return m_last == p ? end() : iterator(this, p);
    }
# 2183 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator rerase(iterator pos) {
        ((void)0);
        ((void)0);
        pointer prev = pos.m_it;
        pointer p = prev;
        for (decrement(prev); p != m_first; p = prev, decrement(prev))
            replace(p, boost::move_if_noexcept(*prev));
        destroy_item(m_first);
        increment(m_first);
        --m_size;



        return p == pos.m_it ? begin() : pos;

    }
# 2223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    iterator rerase(iterator first, iterator last) {
        ((void)0);
        ((void)0);
        ((void)0);
        if (first == last)
            return first;
        pointer p = map_pointer(last.m_it);
        last.m_it = p;
        while (first.m_it != m_first) {
            decrement(first.m_it);
            decrement(p);
            replace(p, boost::move_if_noexcept(*first.m_it));
        }
        do {
            destroy_item(m_first);
            increment(m_first);
            --m_size;
        } while(m_first != p);
        if (m_first == last.m_it)
            return begin();
        decrement(last.m_it);
        return iterator(this, last.m_it);
    }
# 2270 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void erase_begin(size_type n) {
        ((void)0);



        erase_begin(n, is_scalar<value_type>());

    }
# 2302 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void erase_end(size_type n) {
        ((void)0);



        erase_end(n, is_scalar<value_type>());

    }
# 2326 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
    void clear() noexcept {
        destroy_content();
        m_size = 0;
    }

private:



    void check_position(size_type index) const {
        if (index >= size())
            throw_exception(std::out_of_range("circular_buffer"));
    }


    template <class Pointer>
    void increment(Pointer& p) const {
        if (++p == m_end)
            p = m_buff;
    }


    template <class Pointer>
    void decrement(Pointer& p) const {
        if (p == m_buff)
            p = m_end;
        --p;
    }


    template <class Pointer>
    Pointer add(Pointer p, difference_type n) const {
        return p + (n < (m_end - p) ? n : n - capacity());
    }


    template <class Pointer>
    Pointer sub(Pointer p, difference_type n) const {
        return p - (n > (p - m_buff) ? n - capacity() : n);
    }


    pointer map_pointer(pointer p) const { return p == 0 ? m_last : p; }


    pointer allocate(size_type n) {
        if (n > max_size())
            throw_exception(std::length_error("circular_buffer"));





        return (n == 0) ? 0 : m_alloc.allocate(n);

    }


    void deallocate(pointer p, size_type n) {
        if (p != 0)
            m_alloc.deallocate(p, n);
    }


    bool is_uninitialized(const_pointer p) const noexcept {
        return p >= m_last && (m_first < m_last || p < m_first);
    }


    void replace(pointer pos, param_value_type item) {
        *pos = item;



    }


    void replace(pointer pos, rvalue_type item) {
        *pos = boost::move(item);



    }






    void construct_or_replace(bool construct, pointer pos, param_value_type item) {
        if (construct)
            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(pos), item);
        else
            replace(pos, item);
    }






    void construct_or_replace(bool construct, pointer pos, rvalue_type item) {
        if (construct)
            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(pos), boost::move(item));
        else
            replace(pos, boost::move(item));
    }


    void destroy_item(pointer p) {
        boost::container::allocator_traits<Alloc>::destroy(m_alloc, boost::to_address(p));




    }


    void destroy_if_constructed(pointer pos) {
        if (is_uninitialized(pos))
            destroy_item(pos);
    }


    void destroy_content() {



        destroy_content(is_scalar<value_type>());

    }


    void destroy_content(const true_type&) {
        m_first = add(m_first, size());
    }


    void destroy_content(const false_type&) {
        for (size_type ii = 0; ii < size(); ++ii, increment(m_first))
            destroy_item(m_first);
    }


    void destroy() noexcept {
        destroy_content();
        deallocate(m_buff, capacity());






    }


    void initialize_buffer(capacity_type buffer_capacity) {
        m_buff = allocate(buffer_capacity);
        m_end = m_buff + buffer_capacity;
    }


    void initialize_buffer(capacity_type buffer_capacity, param_value_type item) {
        initialize_buffer(buffer_capacity);
        { try {
            cb_details::uninitialized_fill_n_with_alloc(m_buff, size(), item, m_alloc);
        } catch(...) {
            deallocate(m_buff, size());
            throw;
        }
        }
    }


    template <class IntegralType>
    void initialize(IntegralType n, IntegralType item, const true_type&) {
        m_size = static_cast<size_type>(n);
        initialize_buffer(size(), item);
        m_first = m_last = m_buff;
    }


    template <class Iterator>
    void initialize(Iterator first, Iterator last, const false_type&) {
        static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");



        initialize(first, last, typename iterator_category<Iterator>::type());

    }


    template <class InputIterator>
    void initialize(InputIterator first, InputIterator last, const std::input_iterator_tag&) {
        ((void)0);

        std::deque<value_type, allocator_type> tmp(first, last, m_alloc);
        size_type distance = tmp.size();
        initialize(distance, boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), distance);
    }


    template <class ForwardIterator>
    void initialize(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
        ((void)0);
        size_type distance = std::distance(first, last);
        initialize(distance, first, last, distance);
    }


    template <class IntegralType>
    void initialize(capacity_type buffer_capacity, IntegralType n, IntegralType item, const true_type&) {
        ((void)0);
        m_size = static_cast<size_type>(n);
        initialize_buffer(buffer_capacity, item);
        m_first = m_buff;
        m_last = buffer_capacity == size() ? m_buff : m_buff + size();
    }


    template <class Iterator>
    void initialize(capacity_type buffer_capacity, Iterator first, Iterator last, const false_type&) {
        static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");



        initialize(buffer_capacity, first, last, typename iterator_category<Iterator>::type());

    }


    template <class InputIterator>
    void initialize(capacity_type buffer_capacity,
        InputIterator first,
        InputIterator last,
        const std::input_iterator_tag&) {
        initialize_buffer(buffer_capacity);
        m_first = m_last = m_buff;
        m_size = 0;
        if (buffer_capacity == 0)
            return;
        while (first != last && !full()) {
            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(m_last), *first++);
            increment(m_last);
            ++m_size;
        }
        while (first != last) {
            replace(m_last, *first++);
            increment(m_last);
            m_first = m_last;
        }
    }


    template <class ForwardIterator>
    void initialize(capacity_type buffer_capacity,
        ForwardIterator first,
        ForwardIterator last,
        const std::forward_iterator_tag&) {
        ((void)0);
        initialize(buffer_capacity, first, last, std::distance(first, last));
    }


    template <class ForwardIterator>
    void initialize(capacity_type buffer_capacity,
        ForwardIterator first,
        ForwardIterator last,
        size_type distance) {
        initialize_buffer(buffer_capacity);
        m_first = m_buff;
        if (distance > buffer_capacity) {
            std::advance(first, distance - buffer_capacity);
            m_size = buffer_capacity;
        } else {
            m_size = distance;
        }
        { try {
            m_last = cb_details::uninitialized_copy(first, last, m_buff, m_alloc);
        } catch(...) {
            deallocate(m_buff, buffer_capacity);
            throw;
        }
        }
        if (m_last == m_end)
            m_last = m_buff;
    }


    void reset(pointer buff, pointer last, capacity_type new_capacity) {
        destroy();
        m_size = last - buff;
        m_first = m_buff = buff;
        m_end = m_buff + new_capacity;
        m_last = last == m_end ? m_buff : last;
    }


    void swap_allocator(circular_buffer<T, Alloc>&, const true_type&) {

    }


    void swap_allocator(circular_buffer<T, Alloc>& cb, const false_type&) {
        adl_move_swap(m_alloc, cb.m_alloc);
    }


    template <class IntegralType>
    void assign(IntegralType n, IntegralType item, const true_type&) {
        assign(static_cast<size_type>(n), static_cast<value_type>(item));
    }


    template <class Iterator>
    void assign(Iterator first, Iterator last, const false_type&) {
        static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");



        assign(first, last, typename iterator_category<Iterator>::type());

    }


    template <class InputIterator>
    void assign(InputIterator first, InputIterator last, const std::input_iterator_tag&) {
        ((void)0);

        std::deque<value_type, allocator_type> tmp(first, last, m_alloc);
        size_type distance = tmp.size();
        assign_n(distance, distance,
            cb_details::make_assign_range
                (boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), m_alloc));
    }


    template <class ForwardIterator>
    void assign(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
        ((void)0);
        size_type distance = std::distance(first, last);
        assign_n(distance, distance, cb_details::make_assign_range(first, last, m_alloc));
    }


    template <class IntegralType>
    void assign(capacity_type new_capacity, IntegralType n, IntegralType item, const true_type&) {
        assign(new_capacity, static_cast<size_type>(n), static_cast<value_type>(item));
    }


    template <class Iterator>
    void assign(capacity_type new_capacity, Iterator first, Iterator last, const false_type&) {
        static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");



        assign(new_capacity, first, last, typename iterator_category<Iterator>::type());

    }


    template <class InputIterator>
    void assign(capacity_type new_capacity, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
        if (new_capacity == capacity()) {
            clear();
            insert(begin(), first, last);
        } else {
            circular_buffer<value_type, allocator_type> tmp(new_capacity, first, last, m_alloc);
            tmp.swap(*this);
        }
    }


    template <class ForwardIterator>
    void assign(capacity_type new_capacity, ForwardIterator first, ForwardIterator last,
        const std::forward_iterator_tag&) {
        ((void)0);
        size_type distance = std::distance(first, last);
        if (distance > new_capacity) {
            std::advance(first, distance - new_capacity);
            distance = new_capacity;
        }
        assign_n(new_capacity, distance,
            cb_details::make_assign_range(first, last, m_alloc));
    }


    template <class Functor>
    void assign_n(capacity_type new_capacity, size_type n, const Functor& fnc) {
        if (new_capacity == capacity()) {
            destroy_content();
            { try {
                fnc(m_buff);
            } catch(...) {
                m_size = 0;
                throw;
            }
            }
        } else {
            pointer buff = allocate(new_capacity);
            { try {
                fnc(buff);
            } catch(...) {
                deallocate(buff, new_capacity);
                throw;
            }
            }
            destroy();
            m_buff = buff;
            m_end = m_buff + new_capacity;
        }
        m_size = n;
        m_first = m_buff;
        m_last = add(m_buff, size());
    }


    template <class ValT>
    iterator insert_item(const iterator& pos, ValT item) {
        pointer p = pos.m_it;
        if (p == 0) {
            construct_or_replace(!full(), m_last, static_cast<ValT>(item));
            p = m_last;
        } else {
            pointer src = m_last;
            pointer dest = m_last;
            bool construct = !full();
            { try {
                while (src != p) {
                    decrement(src);
                    construct_or_replace(construct, dest, boost::move_if_noexcept(*src));
                    decrement(dest);
                    construct = false;
                }
                replace(p, static_cast<ValT>(item));
            } catch(...) {
                if (!construct && !full()) {
                    increment(m_last);
                    ++m_size;
                }
                throw;
            }
            }
        }
        increment(m_last);
        if (full())
            m_first = m_last;
        else
            ++m_size;
        return iterator(this, p);
    }


    template <class IntegralType>
    void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
        insert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
    }


    template <class Iterator>
    void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
        static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");



        insert(pos, first, last, typename iterator_category<Iterator>::type());

    }


    template <class InputIterator>
    void insert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
        if (!full() || pos != begin()) {
            for (;first != last; ++pos)
                pos = insert(pos, *first++);
        }
    }


    template <class ForwardIterator>
    void insert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
        ((void)0);
        size_type n = std::distance(first, last);
        if (n == 0)
            return;
        size_type copy = capacity() - (end() - pos);
        if (copy == 0)
            return;
        if (n > copy) {
            std::advance(first, n - copy);
            n = copy;
        }
        insert_n(pos, n, cb_details::iterator_wrapper<ForwardIterator>(first));
    }


    template <class Wrapper>
    void insert_n(const iterator& pos, size_type n, const Wrapper& wrapper) {
        size_type construct = reserve();
        if (construct > n)
            construct = n;
        if (pos.m_it == 0) {
            size_type ii = 0;
            pointer p = m_last;
            { try {
                for (; ii < construct; ++ii, increment(p))
                    boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(p), *wrapper());
                for (;ii < n; ++ii, increment(p))
                    replace(p, *wrapper());
            } catch(...) {
                size_type constructed = (std::min)(ii, construct);
                m_last = add(m_last, constructed);
                m_size += constructed;
                throw;
            }
            }
        } else {
            pointer src = m_last;
            pointer dest = add(m_last, n - 1);
            pointer p = pos.m_it;
            size_type ii = 0;
            { try {
                while (src != pos.m_it) {
                    decrement(src);
                    construct_or_replace(is_uninitialized(dest), dest, *src);
                    decrement(dest);
                }
                for (; ii < n; ++ii, increment(p))
                    construct_or_replace(is_uninitialized(p), p, *wrapper());
            } catch(...) {
                for (p = add(m_last, n - 1); p != dest; decrement(p))
                    destroy_if_constructed(p);
                for (n = 0, p = pos.m_it; n < ii; ++n, increment(p))
                    destroy_if_constructed(p);
                throw;
            }
            }
        }
        m_last = add(m_last, n);
        m_first = add(m_first, n - construct);
        m_size += construct;
    }


    template <class IntegralType>
    void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
        rinsert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
    }


    template <class Iterator>
    void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
        static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");



        rinsert(pos, first, last, typename iterator_category<Iterator>::type());

    }


    template <class InputIterator>
    void rinsert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
        if (!full() || pos.m_it != 0) {
            for (;first != last; ++pos) {
                pos = rinsert(pos, *first++);
                if (pos.m_it == 0)
                    break;
            }
        }
    }


    template <class ForwardIterator>
    void rinsert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
        ((void)0);
        rinsert_n(pos, std::distance(first, last), cb_details::iterator_wrapper<ForwardIterator>(first));
    }


    template <class Wrapper>
    void rinsert_n(const iterator& pos, size_type n, const Wrapper& wrapper) {
        if (n == 0)
            return;
        iterator b = begin();
        size_type copy = capacity() - (pos - b);
        if (copy == 0)
            return;
        if (n > copy)
            n = copy;
        size_type construct = reserve();
        if (construct > n)
            construct = n;
        if (pos == b) {
            pointer p = sub(m_first, n);
            size_type ii = n;
            { try {
                for (;ii > construct; --ii, increment(p))
                    replace(p, *wrapper());
                for (; ii > 0; --ii, increment(p))
                    boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(p), *wrapper());
            } catch(...) {
                size_type constructed = ii < construct ? construct - ii : 0;
                m_last = add(m_last, constructed);
                m_size += constructed;
                throw;
            }
            }
        } else {
            pointer src = m_first;
            pointer dest = sub(m_first, n);
            pointer p = map_pointer(pos.m_it);
            { try {
                while (src != p) {
                    construct_or_replace(is_uninitialized(dest), dest, *src);
                    increment(src);
                    increment(dest);
                }
                for (size_type ii = 0; ii < n; ++ii, increment(dest))
                    construct_or_replace(is_uninitialized(dest), dest, *wrapper());
            } catch(...) {
                for (src = sub(m_first, n); src != dest; increment(src))
                    destroy_if_constructed(src);
                throw;
            }
            }
        }
        m_first = sub(m_first, n);
        m_last = sub(m_last, n - construct);
        m_size += construct;
    }


    void erase_begin(size_type n, const true_type&) {
        m_first = add(m_first, n);
        m_size -= n;
    }


    void erase_begin(size_type n, const false_type&) {
        iterator b = begin();
        rerase(b, b + n);
    }


    void erase_end(size_type n, const true_type&) {
        m_last = sub(m_last, n);
        m_size -= n;
    }


    void erase_end(size_type n, const false_type&) {
        iterator e = end();
        erase(e - n, e);
    }
};
# 3001 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
inline bool operator == (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
    return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
}
# 3021 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
inline bool operator < (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
# 3040 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
inline bool operator != (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
    return !(lhs == rhs);
}
# 3058 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
inline bool operator > (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
    return rhs < lhs;
}
# 3076 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
inline bool operator <= (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
    return !(rhs < lhs);
}
# 3094 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
inline bool operator >= (const circular_buffer<T, Alloc>& lhs, const circular_buffer<T, Alloc>& rhs) {
    return !(lhs < rhs);
}
# 3114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/base.hpp" 3 4
template <class T, class Alloc>
inline void swap(circular_buffer<T, Alloc>& lhs, circular_buffer<T, Alloc>& rhs) noexcept {
    lhs.swap(rhs);
}



}
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
namespace boost {







template <class T, class Alloc>
class circular_buffer_space_optimized :





circular_buffer<T, Alloc> {
public:


    typedef typename circular_buffer<T, Alloc>::value_type value_type;
    typedef typename circular_buffer<T, Alloc>::pointer pointer;
    typedef typename circular_buffer<T, Alloc>::const_pointer const_pointer;
    typedef typename circular_buffer<T, Alloc>::reference reference;
    typedef typename circular_buffer<T, Alloc>::const_reference const_reference;
    typedef typename circular_buffer<T, Alloc>::size_type size_type;
    typedef typename circular_buffer<T, Alloc>::difference_type difference_type;
    typedef typename circular_buffer<T, Alloc>::allocator_type allocator_type;
    typedef typename circular_buffer<T, Alloc>::const_iterator const_iterator;
    typedef typename circular_buffer<T, Alloc>::iterator iterator;
    typedef typename circular_buffer<T, Alloc>::const_reverse_iterator const_reverse_iterator;
    typedef typename circular_buffer<T, Alloc>::reverse_iterator reverse_iterator;
    typedef typename circular_buffer<T, Alloc>::array_range array_range;
    typedef typename circular_buffer<T, Alloc>::const_array_range const_array_range;
    typedef typename circular_buffer<T, Alloc>::param_value_type param_value_type;
    typedef typename circular_buffer<T, Alloc>::rvalue_type rvalue_type;
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    typedef cb_details::capacity_control<size_type> capacity_type;



    using circular_buffer<T, Alloc>::get_allocator;
    using circular_buffer<T, Alloc>::begin;
    using circular_buffer<T, Alloc>::end;
    using circular_buffer<T, Alloc>::rbegin;
    using circular_buffer<T, Alloc>::rend;
    using circular_buffer<T, Alloc>::at;
    using circular_buffer<T, Alloc>::front;
    using circular_buffer<T, Alloc>::back;
    using circular_buffer<T, Alloc>::array_one;
    using circular_buffer<T, Alloc>::array_two;
    using circular_buffer<T, Alloc>::linearize;
    using circular_buffer<T, Alloc>::is_linearized;
    using circular_buffer<T, Alloc>::rotate;
    using circular_buffer<T, Alloc>::size;
    using circular_buffer<T, Alloc>::max_size;
    using circular_buffer<T, Alloc>::empty;





    using circular_buffer<T, Alloc>::operator[];


private:



    capacity_type m_capacity_ctrl;

public:
# 153 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    bool full() const noexcept { return m_capacity_ctrl == size(); }
# 167 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    size_type reserve() const noexcept { return m_capacity_ctrl - size(); }
# 183 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    const capacity_type& capacity() const noexcept { return m_capacity_ctrl; }
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void set_capacity(const capacity_type& capacity_ctrl) {
        m_capacity_ctrl = capacity_ctrl;
        if (capacity_ctrl < size()) {
            iterator e = end();
            circular_buffer<T, Alloc>::erase(e - (size() - capacity_ctrl), e);
        }
        adjust_min_capacity();
    }
# 261 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void resize(size_type new_size, param_value_type item = value_type()) {
        if (new_size > size()) {
            if (new_size > m_capacity_ctrl)
                m_capacity_ctrl = capacity_type(new_size, m_capacity_ctrl.min_capacity());
            insert(end(), new_size - size(), item);
        } else {
            iterator e = end();
            erase(e - (size() - new_size), e);
        }
    }
# 296 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void rset_capacity(const capacity_type& capacity_ctrl) {
        m_capacity_ctrl = capacity_ctrl;
        if (capacity_ctrl < size()) {
            iterator b = begin();
            circular_buffer<T, Alloc>::rerase(b, b + (size() - capacity_ctrl));
        }
        adjust_min_capacity();
    }
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void rresize(size_type new_size, param_value_type item = value_type()) {
        if (new_size > size()) {
            if (new_size > m_capacity_ctrl)
                m_capacity_ctrl = capacity_type(new_size, m_capacity_ctrl.min_capacity());
            rinsert(begin(), new_size - size(), item);
        } else {
            rerase(begin(), end() - new_size);
        }
    }
# 352 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    explicit circular_buffer_space_optimized(const allocator_type& alloc = allocator_type()) noexcept
    : circular_buffer<T, Alloc>(0, alloc)
    , m_capacity_ctrl(0) {}
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    explicit circular_buffer_space_optimized(capacity_type capacity_ctrl,
        const allocator_type& alloc = allocator_type())
    : circular_buffer<T, Alloc>(capacity_ctrl.min_capacity(), alloc)
    , m_capacity_ctrl(capacity_ctrl) {}
# 390 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    circular_buffer_space_optimized(capacity_type capacity_ctrl, param_value_type item,
        const allocator_type& alloc = allocator_type())
    : circular_buffer<T, Alloc>(capacity_ctrl.capacity(), item, alloc)
    , m_capacity_ctrl(capacity_ctrl) {}
# 414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    circular_buffer_space_optimized(capacity_type capacity_ctrl, size_type n, param_value_type item,
        const allocator_type& alloc = allocator_type())
    : circular_buffer<T, Alloc>(init_capacity(capacity_ctrl, n), n, item, alloc)
    , m_capacity_ctrl(capacity_ctrl) {}
# 431 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    circular_buffer_space_optimized(const circular_buffer_space_optimized<T, Alloc>& cb)
    : circular_buffer<T, Alloc>(cb.begin(), cb.end(), cb.get_allocator())
    , m_capacity_ctrl(cb.m_capacity_ctrl) {}
# 445 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    circular_buffer_space_optimized(circular_buffer_space_optimized<T, Alloc>&& cb) noexcept
    : circular_buffer<T, Alloc>()
    , m_capacity_ctrl(0) {
        cb.swap(*this);
    }
# 471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    template <class InputIterator>
    circular_buffer_space_optimized(InputIterator first, InputIterator last,
        const allocator_type& alloc = allocator_type())
    : circular_buffer<T, Alloc>(first, last, alloc)
    , m_capacity_ctrl(circular_buffer<T, Alloc>::capacity()) {}
# 504 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    template <class InputIterator>
    circular_buffer_space_optimized(capacity_type capacity_ctrl, InputIterator first, InputIterator last,
        const allocator_type& alloc = allocator_type())
    : circular_buffer<T, Alloc>(
        init_capacity(capacity_ctrl, first, last, is_integral<InputIterator>()),
        first, last, alloc)
    , m_capacity_ctrl(capacity_ctrl) {
        reduce_capacity(
            is_same< typename iterator_category<InputIterator>::type, std::input_iterator_tag >());
    }
# 563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    circular_buffer_space_optimized<T, Alloc>& operator = (const circular_buffer_space_optimized<T, Alloc>& cb) {
        if (this == &cb)
            return *this;
        circular_buffer<T, Alloc>::assign(cb.begin(), cb.end());
        m_capacity_ctrl = cb.m_capacity_ctrl;
        return *this;
    }
# 580 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    circular_buffer_space_optimized<T, Alloc>& operator = (circular_buffer_space_optimized<T, Alloc>&& cb) noexcept {
        cb.swap(*this);
        circular_buffer<T, Alloc>(get_allocator())
            .swap(cb);
        return *this;
    }
# 614 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void assign(size_type n, param_value_type item) {
        circular_buffer<T, Alloc>::assign(n, item);
        m_capacity_ctrl = capacity_type(n);
    }
# 646 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void assign(capacity_type capacity_ctrl, size_type n, param_value_type item) {
       ((void)0);
       circular_buffer<T, Alloc>::assign((std::max)(capacity_ctrl.min_capacity(), n), n, item);
       m_capacity_ctrl = capacity_ctrl;
    }
# 682 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    template <class InputIterator>
    void assign(InputIterator first, InputIterator last) {
        circular_buffer<T, Alloc>::assign(first, last);
        m_capacity_ctrl = capacity_type(circular_buffer<T, Alloc>::capacity());
    }
# 725 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    template <class InputIterator>
    void assign(capacity_type capacity_ctrl, InputIterator first, InputIterator last) {
       m_capacity_ctrl = capacity_ctrl;
       circular_buffer<T, Alloc>::assign(capacity_ctrl, first, last);
    }
# 754 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void swap(circular_buffer_space_optimized<T, Alloc>& cb) noexcept {
        std::swap(m_capacity_ctrl, cb.m_capacity_ctrl);
        circular_buffer<T, Alloc>::swap(cb);
    }
# 779 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void push_back(param_value_type item) {
        check_low_capacity();
        circular_buffer<T, Alloc>::push_back(item);
    }
# 803 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void push_back(rvalue_type item) {
        check_low_capacity();
        circular_buffer<T, Alloc>::push_back(boost::move(item));
    }
# 828 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void push_back() {
        check_low_capacity();
        circular_buffer<T, Alloc>::push_back();
    }
# 853 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void push_front(param_value_type item) {
        check_low_capacity();
        circular_buffer<T, Alloc>::push_front(item);
    }
# 878 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void push_front(rvalue_type item) {
        check_low_capacity();
        circular_buffer<T, Alloc>::push_front(boost::move(item));
    }
# 903 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void push_front() {
        check_low_capacity();
        circular_buffer<T, Alloc>::push_front();
    }
# 925 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void pop_back() {
        circular_buffer<T, Alloc>::pop_back();
        check_high_capacity();
    }
# 947 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void pop_front() {
        circular_buffer<T, Alloc>::pop_front();
        check_high_capacity();
    }
# 985 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator insert(iterator pos, param_value_type item) {
        size_type index = pos - begin();
        check_low_capacity();
        return circular_buffer<T, Alloc>::insert(begin() + index, item);
    }
# 1023 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator insert(iterator pos, rvalue_type item) {
        size_type index = pos - begin();
        check_low_capacity();
        return circular_buffer<T, Alloc>::insert(begin() + index, boost::move(item));
    }
# 1061 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator insert(iterator pos) {
        size_type index = pos - begin();
        check_low_capacity();
        return circular_buffer<T, Alloc>::insert(begin() + index);
    }
# 1107 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void insert(iterator pos, size_type n, param_value_type item) {
        size_type index = pos - begin();
        check_low_capacity(n);
        circular_buffer<T, Alloc>::insert(begin() + index, n, item);
    }
# 1158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    template <class InputIterator>
    void insert(iterator pos, InputIterator first, InputIterator last) {
        insert(pos, first, last, is_integral<InputIterator>());
    }
# 1196 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator rinsert(iterator pos, param_value_type item) {
        size_type index = pos - begin();
        check_low_capacity();
        return circular_buffer<T, Alloc>::rinsert(begin() + index, item);
    }
# 1234 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator rinsert(iterator pos, rvalue_type item) {
        size_type index = pos - begin();
        check_low_capacity();
        return circular_buffer<T, Alloc>::rinsert(begin() + index, boost::move(item));
    }
# 1272 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator rinsert(iterator pos) {
        size_type index = pos - begin();
        check_low_capacity();
        return circular_buffer<T, Alloc>::rinsert(begin() + index);
    }
# 1318 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void rinsert(iterator pos, size_type n, param_value_type item) {
        size_type index = pos - begin();
        check_low_capacity(n);
        circular_buffer<T, Alloc>::rinsert(begin() + index, n, item);
    }
# 1371 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    template <class InputIterator>
    void rinsert(iterator pos, InputIterator first, InputIterator last) {
        rinsert(pos, first, last, is_integral<InputIterator>());
    }
# 1399 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator erase(iterator pos) {
        iterator it = circular_buffer<T, Alloc>::erase(pos);
        size_type index = it - begin();
        check_high_capacity();
        return begin() + index;
    }
# 1430 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator erase(iterator first, iterator last) {
        iterator it = circular_buffer<T, Alloc>::erase(first, last);
        size_type index = it - begin();
        check_high_capacity();
        return begin() + index;
    }
# 1462 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator rerase(iterator pos) {
        iterator it = circular_buffer<T, Alloc>::rerase(pos);
        size_type index = it - begin();
        check_high_capacity();
        return begin() + index;
    }
# 1496 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    iterator rerase(iterator first, iterator last) {
        iterator it = circular_buffer<T, Alloc>::rerase(first, last);
        size_type index = it - begin();
        check_high_capacity();
        return begin() + index;
    }
# 1520 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer/space_optimized.hpp" 3 4
    void clear() { erase(begin(), end()); }

private:



    void adjust_min_capacity() {
        if (m_capacity_ctrl.min_capacity() > circular_buffer<T, Alloc>::capacity())
            circular_buffer<T, Alloc>::set_capacity(m_capacity_ctrl.min_capacity());
        else
            check_high_capacity();
    }


    size_type ensure_reserve(size_type new_capacity, size_type buffer_size) const {
        if (buffer_size + new_capacity / 5 >= new_capacity)
            new_capacity *= 2;
        if (new_capacity > m_capacity_ctrl)
            return m_capacity_ctrl;
        return new_capacity;
    }





    void check_low_capacity(size_type n = 1) {
        size_type new_size = size() + n;
        size_type new_capacity = circular_buffer<T, Alloc>::capacity();
        if (new_size > new_capacity) {
            if (new_capacity == 0)
                new_capacity = 1;
            for (; new_size > new_capacity; new_capacity *= 2) {}
            circular_buffer<T, Alloc>::set_capacity(
                ensure_reserve(new_capacity, new_size));
        }



    }





    void check_high_capacity() {
        size_type new_capacity = circular_buffer<T, Alloc>::capacity();
        while (new_capacity / 3 >= size()) {
            new_capacity /= 2;
            if (new_capacity <= m_capacity_ctrl.min_capacity()) {
                new_capacity = m_capacity_ctrl.min_capacity();
                break;
            }
        }
        circular_buffer<T, Alloc>::set_capacity(
            ensure_reserve(new_capacity, size()));



    }


    void reduce_capacity(const true_type&) {
        circular_buffer<T, Alloc>::set_capacity((std::max)(m_capacity_ctrl.min_capacity(), size()));
    }


    void reduce_capacity(const false_type&) {}


    static size_type init_capacity(const capacity_type& capacity_ctrl, size_type n) {
        ((void)0);
        return (std::max)(capacity_ctrl.min_capacity(), n);
    }


    template <class IntegralType>
    static size_type init_capacity(const capacity_type& capacity_ctrl, IntegralType n, IntegralType,
        const true_type&) {
        return init_capacity(capacity_ctrl, static_cast<size_type>(n));
    }


    template <class Iterator>
    static size_type init_capacity(const capacity_type& capacity_ctrl, Iterator first, Iterator last,
        const false_type&) {
        static_assert((is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value), "(is_convertible<typename detail::iterator_traits<Iterator>::value_type, value_type>::value)");



        return init_capacity(
            capacity_ctrl, first, last, typename iterator_category<Iterator>::type());

    }


    template <class InputIterator>
    static size_type init_capacity(const capacity_type& capacity_ctrl, InputIterator, InputIterator,
        const std::input_iterator_tag&) {
        return capacity_ctrl.capacity();
    }


    template <class ForwardIterator>
    static size_type init_capacity(const capacity_type& capacity_ctrl, ForwardIterator first, ForwardIterator last,
        const std::forward_iterator_tag&) {
        ((void)0);
        return (std::max)(capacity_ctrl.min_capacity(),
            (std::min)(capacity_ctrl.capacity(), static_cast<size_type>(std::distance(first, last))));
    }


    template <class IntegralType>
    void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
        insert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
    }


    template <class Iterator>
    void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
        size_type index = pos - begin();
        check_low_capacity(std::distance(first, last));
        circular_buffer<T, Alloc>::insert(begin() + index, first, last);
    }


    template <class IntegralType>
    void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
        rinsert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
    }


    template <class Iterator>
    void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
        size_type index = pos - begin();
        check_low_capacity(std::distance(first, last));
        circular_buffer<T, Alloc>::rinsert(begin() + index, first, last);
    }
};




template <class T, class Alloc>
inline bool operator == (const circular_buffer_space_optimized<T, Alloc>& lhs,
    const circular_buffer_space_optimized<T, Alloc>& rhs) {
    return lhs.size() == rhs.size() &&
        std::equal(lhs.begin(), lhs.end(), rhs.begin());
}


template <class T, class Alloc>
inline bool operator < (const circular_buffer_space_optimized<T, Alloc>& lhs,
    const circular_buffer_space_optimized<T, Alloc>& rhs) {
    return std::lexicographical_compare(
        lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}




template <class T, class Alloc>
inline bool operator != (const circular_buffer_space_optimized<T, Alloc>& lhs,
    const circular_buffer_space_optimized<T, Alloc>& rhs) {
    return !(lhs == rhs);
}


template <class T, class Alloc>
inline bool operator > (const circular_buffer_space_optimized<T, Alloc>& lhs,
    const circular_buffer_space_optimized<T, Alloc>& rhs) {
    return rhs < lhs;
}


template <class T, class Alloc>
inline bool operator <= (const circular_buffer_space_optimized<T, Alloc>& lhs,
    const circular_buffer_space_optimized<T, Alloc>& rhs) {
    return !(rhs < lhs);
}


template <class T, class Alloc>
inline bool operator >= (const circular_buffer_space_optimized<T, Alloc>& lhs,
    const circular_buffer_space_optimized<T, Alloc>& rhs) {
    return !(lhs < rhs);
}


template <class T, class Alloc>
inline void swap(circular_buffer_space_optimized<T, Alloc>& lhs,
    circular_buffer_space_optimized<T, Alloc>& rhs) noexcept {
    lhs.swap(rhs);
}



}
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/circular_buffer.hpp" 2 3 4
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Log.h" 2




# 1 "/usr/include/c++/10/queue" 1 3
# 58 "/usr/include/c++/10/queue" 3
       
# 59 "/usr/include/c++/10/queue" 3





# 1 "/usr/include/c++/10/bits/stl_queue.h" 1 3
# 65 "/usr/include/c++/10/bits/stl_queue.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 95 "/usr/include/c++/10/bits/stl_queue.h" 3
  template<typename _Tp, typename _Sequence = deque<_Tp> >
    class queue
    {
# 109 "/usr/include/c++/10/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 _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:
# 147 "/usr/include/c++/10/bits/stl_queue.h" 3
      _Sequence c;

    public:
# 158 "/usr/include/c++/10/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) { }





      [[__nodiscard__]] bool
      empty() const
      { return c.empty(); }


      size_type
      size() const
      { return c.size(); }





      reference
      front()
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_queue.h", 212, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return c.front();
      }





      const_reference
      front() const
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_queue.h", 223, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return c.front();
      }





      reference
      back()
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_queue.h", 234, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return c.back();
      }





      const_reference
      back() const
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_queue.h", 245, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return c.back();
      }
# 258 "/usr/include/c++/10/bits/stl_queue.h" 3
      void
      push(const value_type& __x)
      { c.push_back(__x); }


      void
      push(value_type&& __x)
      { c.push_back(std::move(__x)); }


      template<typename... _Args>
 decltype(auto)
 emplace(_Args&&... __args)
 { return c.emplace_back(std::forward<_Args>(__args)...); }
# 291 "/usr/include/c++/10/bits/stl_queue.h" 3
      void
      pop()
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_queue.h", 294, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 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>,
    typename = _RequireAllocator<_Allocator>>
    queue(_Container, _Allocator)
    -> queue<typename _Container::value_type, _Container>;
# 336 "/usr/include/c++/10/bits/stl_queue.h" 3
  template<typename _Tp, typename _Seq>
    inline bool
    operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __x.c == __y.c; }
# 354 "/usr/include/c++/10/bits/stl_queue.h" 3
  template<typename _Tp, typename _Seq>
    inline bool
    operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __x.c < __y.c; }


  template<typename _Tp, typename _Seq>
    inline bool
    operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Seq>
    inline bool
    operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Seq>
    inline bool
    operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Seq>
    inline bool
    operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__x < __y); }


  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 { };
# 441 "/usr/include/c++/10/bits/stl_queue.h" 3
  template<typename _Tp, typename _Sequence = vector<_Tp>,
    typename _Compare = less<typename _Sequence::value_type> >
    class priority_queue
    {
# 459 "/usr/include/c++/10/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:
# 498 "/usr/include/c++/10/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)) { }
# 572 "/usr/include/c++/10/bits/stl_queue.h" 3
      template<typename _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>
 priority_queue(_InputIterator __first, _InputIterator __last,
         const _Compare& __x = _Compare(),
         _Sequence&& __s = _Sequence())
 : c(std::move(__s)), comp(__x)
 {
   ;
   c.insert(c.end(), __first, __last);
   std::make_heap(c.begin(), c.end(), comp);
 }





      [[__nodiscard__]] bool
      empty() const
      { return c.empty(); }


      size_type
      size() const
      { return c.size(); }





      const_reference
      top() const
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_queue.h", 614, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 return c.front();
      }
# 626 "/usr/include/c++/10/bits/stl_queue.h" 3
      void
      push(const value_type& __x)
      {
 c.push_back(__x);
 std::push_heap(c.begin(), c.end(), comp);
      }


      void
      push(value_type&& __x)
      {
 c.push_back(std::move(__x));
 std::push_heap(c.begin(), c.end(), comp);
      }

      template<typename... _Args>
 void
 emplace(_Args&&... __args)
 {
   c.emplace_back(std::forward<_Args>(__args)...);
   std::push_heap(c.begin(), c.end(), comp);
 }
# 661 "/usr/include/c++/10/bits/stl_queue.h" 3
      void
      pop()
      {
 do { if (! (__builtin_expect(!this->empty(), true))) std::__replacement_assert("/usr/include/c++/10/bits/stl_queue.h", 664, __PRETTY_FUNCTION__, "__builtin_expect(!this->empty(), true)"); } while (false);
 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>,
    typename = _RequireAllocator<_Allocator>>
    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 { };



}
# 65 "/usr/include/c++/10/queue" 2 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Log.h" 2



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Thread.h" 1
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Thread.h"
# 1 "/usr/include/c++/10/thread" 1 3
# 32 "/usr/include/c++/10/thread" 3
       
# 33 "/usr/include/c++/10/thread" 3
# 52 "/usr/include/c++/10/thread" 3
# 1 "/usr/include/c++/10/cerrno" 1 3
# 39 "/usr/include/c++/10/cerrno" 3
       
# 40 "/usr/include/c++/10/cerrno" 3
# 53 "/usr/include/c++/10/thread" 2 3






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

# 72 "/usr/include/c++/10/thread" 3
  class thread
  {
  public:


    struct _State
    {
      virtual ~_State();
      virtual void _M_run() = 0;
    };
    using _State_ptr = unique_ptr<_State>;

    typedef __gthread_t native_handle_type;


    class id
    {
      native_handle_type _M_thread;

    public:
      id() noexcept : _M_thread() { }

      explicit
      id(native_handle_type __id) : _M_thread(__id) { }

    private:
      friend class thread;
      friend class hash<thread::id>;

      friend bool
      operator==(thread::id __x, thread::id __y) noexcept;

      friend bool
      operator<(thread::id __x, thread::id __y) noexcept;

      template<class _CharT, class _Traits>
 friend basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
    };

  private:
    id _M_id;




    template<typename _Tp>
      using __not_same = __not_<is_same<__remove_cvref_t<_Tp>, thread>>;

  public:
    thread() noexcept = default;

    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"
   );



 auto __depend = reinterpret_cast<void(*)()>(&pthread_create);




 using _Invoker_type = _Invoker<__decayed_tuple<_Callable, _Args...>>;

 _M_start_thread(_S_make_state<_Invoker_type>(
       std::forward<_Callable>(__f), std::forward<_Args>(__args)...),
     __depend);
      }

    ~thread()
    {
      if (joinable())
 std::terminate();
    }

    thread(const thread&) = delete;

    thread(thread&& __t) noexcept
    { swap(__t); }

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

    thread& operator=(thread&& __t) noexcept
    {
      if (joinable())
 std::terminate();
      swap(__t);
      return *this;
    }

    void
    swap(thread& __t) noexcept
    { std::swap(_M_id, __t._M_id); }

    bool
    joinable() const noexcept
    { return !(_M_id == id()); }

    void
    join();

    void
    detach();

    thread::id
    get_id() const noexcept
    { return _M_id; }



    native_handle_type
    native_handle()
    { return _M_id._M_thread; }


    static unsigned int
    hardware_concurrency() noexcept;

  private:
    template<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 (*)());

    template<typename _Callable, typename... _Args>
      static _State_ptr
      _S_make_state(_Args&&... __args)
      {
 using _Impl = _State_impl<_Callable>;
 return _State_ptr{new _Impl{std::forward<_Args>(__args)...}};
      }
# 241 "/usr/include/c++/10/thread" 3
  private:

    template<typename _Tuple>
      struct _Invoker
      {
 _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());
 }
      };

    template<typename... _Tp>
      using __decayed_tuple = tuple<typename decay<_Tp>::type...>;

  public:


    template<typename _Callable, typename... _Args>
      static _Invoker<__decayed_tuple<_Callable, _Args...>>
      __make_invoker(_Callable&& __callable, _Args&&... __args)
      {
 return { __decayed_tuple<_Callable, _Args...>{
     std::forward<_Callable>(__callable), std::forward<_Args>(__args)...
 } };
      }
  };

  inline void
  swap(thread& __x, thread& __y) noexcept
  { __x.swap(__y); }

  inline bool
  operator==(thread::id __x, thread::id __y) noexcept
  {




    return __x._M_thread == __y._M_thread;
  }

  inline bool
  operator!=(thread::id __x, thread::id __y) noexcept
  { return !(__x == __y); }

  inline bool
  operator<(thread::id __x, thread::id __y) noexcept
  {


    return __x._M_thread < __y._M_thread;
  }

  inline bool
  operator<=(thread::id __x, thread::id __y) noexcept
  { return !(__y < __x); }

  inline bool
  operator>(thread::id __x, thread::id __y) noexcept
  { return __y < __x; }

  inline bool
  operator>=(thread::id __x, thread::id __y) noexcept
  { return !(__x < __y); }



  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); }
    };

  template<class _CharT, class _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
    {
      if (__id == thread::id())
 return __out << "thread::id of a non-executing thread";
      else
 return __out << __id._M_thread;
    }






  namespace this_thread
  {

    inline thread::id
    get_id() noexcept
    {





      if (!__gthread_active_p())
 return thread::id(1);

      return thread::id(__gthread_self());
    }


    inline void
    yield() noexcept
    {

      __gthread_yield();

    }

    void
    __sleep_for(chrono::seconds, chrono::nanoseconds);


    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);

 __gthread_time_t __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)
      {
 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();
   }
      }
  }
# 550 "/usr/include/c++/10/thread" 3

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Thread.h" 2




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/compat.h" 1
# 194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/compat.h"

# 194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/compat.h"
int ceph_posix_fallocate(int fd, off_t offset, off_t len);

int pipe_cloexec(int pipefd[2]);
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Thread.h" 2

extern pid_t ceph_gettid();

class Thread {
 private:
  pthread_t thread_id;
  pid_t pid;
  int cpuid;
  const char *thread_name;

  void *entry_wrapper();

 public:
  Thread(const Thread&) = delete;
  Thread& operator=(const Thread&) = delete;

  Thread();
  virtual ~Thread();

 protected:
  virtual void *entry() = 0;

 private:
  static void *_entry_func(void *arg);

 public:
  const pthread_t &get_thread_id() const;
  pid_t get_pid() const { return pid; }
  bool is_started() const;
  bool am_self() const;
  int kill(int signal);
  int try_create(size_t stacksize);
  void create(const char *name, size_t stacksize = 0);
  int join(void **prval = 0);
  int detach();
  int set_affinity(int cpuid);
};



void set_thread_name(std::thread& t, const std::string& s);
std::string get_thread_name(const std::thread& t);
void kill(std::thread& t, int signal);

template<typename Fun, typename... Args>
std::thread make_named_thread(std::string_view n,
         Fun&& fun,
         Args&& ...args) {

  return std::thread([n = std::string(n)](auto&& fun, auto&& ...args) {
         pthread_setname_np(pthread_self(), n.data());
         std::invoke(std::forward<Fun>(fun),
       std::forward<Args>(args)...);
       }, std::forward<Fun>(fun), std::forward<Args>(args)...);
}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Log.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Entry.h" 1






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/LogClock.h" 1






# 1 "/usr/include/c++/10/cstdio" 1 3
# 39 "/usr/include/c++/10/cstdio" 3
       
# 40 "/usr/include/c++/10/cstdio" 3
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/LogClock.h" 2

# 1 "/usr/include/c++/10/ctime" 1 3
# 39 "/usr/include/c++/10/ctime" 3
       
# 40 "/usr/include/c++/10/ctime" 3
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/LogClock.h" 2





namespace ceph {
namespace logging {
namespace _logclock {
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/LogClock.h"
struct taggedrep {
  uint64_t count;
  bool coarse;

  explicit taggedrep(uint64_t count) : count(count), coarse(true) {}
  taggedrep(uint64_t count, bool coarse) : count(count), coarse(coarse) {}

  explicit operator uint64_t() {
    return count;
  }
};




inline taggedrep operator +(const taggedrep& l, const taggedrep& r) {
  return { l.count + r.count, l.coarse || r.coarse };
}
inline taggedrep operator -(const taggedrep& l, const taggedrep& r) {
  return { l.count - r.count, l.coarse || r.coarse };
}
inline taggedrep operator *(const taggedrep& l, const taggedrep& r) {
  return { l.count * r.count, l.coarse || r.coarse };
}
inline taggedrep operator /(const taggedrep& l, const taggedrep& r) {
  return { l.count / r.count, l.coarse || r.coarse };
}
inline taggedrep operator %(const taggedrep& l, const taggedrep& r) {
  return { l.count % r.count, l.coarse || r.coarse };
}




inline bool operator ==(const taggedrep& l, const taggedrep& r) {
  return l.count == r.count;
}
inline bool operator !=(const taggedrep& l, const taggedrep& r) {
  return l.count != r.count;
}
inline bool operator <(const taggedrep& l, const taggedrep& r) {
  return l.count < r.count;
}
inline bool operator <=(const taggedrep& l, const taggedrep& r) {
  return l.count <= r.count;
}
inline bool operator >=(const taggedrep& l, const taggedrep& r) {
  return l.count >= r.count;
}
inline bool operator >(const taggedrep& l, const taggedrep& r) {
  return l.count > r.count;
}
}
class log_clock {
public:
  using rep = _logclock::taggedrep;
  using period = std::nano;
  using duration = std::chrono::duration<rep, period>;


  using time_point = std::chrono::time_point<log_clock>;
  static constexpr const bool is_steady = false;

  time_point now() noexcept {
    return appropriate_now();
  }

  void coarsen() {
    appropriate_now = coarse_now;
  }

  void refine() {
    appropriate_now = fine_now;
  }



  static timeval to_timeval(time_point t) {
    auto rep = t.time_since_epoch().count();
    timespan ts(rep.count);
    return { static_cast<time_t>(std::chrono::duration_cast<std::chrono::seconds>(ts).count()),
             static_cast<suseconds_t>(std::chrono::duration_cast<std::chrono::microseconds>(
               ts % std::chrono::seconds(1)).count()) };
  }
private:
  static time_point coarse_now() {
    return time_point(
      duration(_logclock::taggedrep(coarse_real_clock::now()
        .time_since_epoch().count(), true)));
  }
  static time_point fine_now() {
    return time_point(
      duration(_logclock::taggedrep(real_clock::now()
        .time_since_epoch().count(), false)));
  }
  time_point(*appropriate_now)() = coarse_now;
};
using log_time = log_clock::time_point;
inline int append_time(const log_time& t, char *out, int outlen) {
  bool coarse = t.time_since_epoch().count().coarse;
  auto tv = log_clock::to_timeval(t);
  std::tm bdt;
  localtime_r(&tv.tv_sec, &bdt);

  int r;
  if (coarse) {
    r = std::snprintf(out, outlen, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
        bdt.tm_year + 1900, bdt.tm_mon + 1, bdt.tm_mday,
        bdt.tm_hour, bdt.tm_min, bdt.tm_sec,
        static_cast<long>(tv.tv_usec / 1000));
  } else {
    r = std::snprintf(out, outlen, "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
        bdt.tm_year + 1900, bdt.tm_mon + 1, bdt.tm_mday,
        bdt.tm_hour, bdt.tm_min, bdt.tm_sec,
        static_cast<long>(tv.tv_usec));
  }


  do { static const ceph::assert_data assert_data_ctx = {"r >= 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/LogClock.h", 149, __PRETTY_FUNCTION__}; ((r >= 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
  return r;
}
}
}
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Entry.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/StackStringStream.h" 1
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/StackStringStream.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/inline_memory.h" 1
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/StackStringStream.h" 2

template<std::size_t SIZE>
class StackStringBuf : public std::basic_streambuf<char>
{
public:
  StackStringBuf()
    : vec{SIZE, boost::container::default_init_t{}}
  {
    setp(vec.data(), vec.data() + vec.size());
  }
  StackStringBuf(const StackStringBuf&) = delete;
  StackStringBuf& operator=(const StackStringBuf&) = delete;
  StackStringBuf(StackStringBuf&& o) = delete;
  StackStringBuf& operator=(StackStringBuf&& o) = delete;
  ~StackStringBuf() override = default;

  void clear()
  {
    vec.resize(SIZE);
    setp(vec.data(), vec.data() + SIZE);
  }

  std::string_view strv() const
  {
    return std::string_view(pbase(), pptr() - pbase());
  }

protected:
  std::streamsize xsputn(const char *s, std::streamsize n)
  {
    std::streamsize capacity = epptr() - pptr();
    std::streamsize left = n;
    if (capacity >= left) {
      maybe_inline_memcpy(pptr(), s, left, 32);
      pbump(left);
    } else {
      maybe_inline_memcpy(pptr(), s, capacity, 64);
      s += capacity;
      left -= capacity;
      vec.insert(vec.end(), s, s + left);
      setp(vec.data(), vec.data() + vec.size());
      pbump(vec.size());
    }
    return n;
  }

  int overflow(int c)
  {
    if (traits_type::not_eof(c)) {
      char str = traits_type::to_char_type(c);
      vec.push_back(str);
      return c;
    } else {
      return traits_type::eof();
    }
  }

private:

  boost::container::small_vector<char, SIZE> vec;
};

template<std::size_t SIZE>
class StackStringStream : public std::basic_ostream<char>
{
public:
  StackStringStream() : basic_ostream<char>(&ssb), default_fmtflags(flags()) {}
  StackStringStream(const StackStringStream& o) = delete;
  StackStringStream& operator=(const StackStringStream& o) = delete;
  StackStringStream(StackStringStream&& o) = delete;
  StackStringStream& operator=(StackStringStream&& o) = delete;
  ~StackStringStream() override = default;

  void reset() {
    clear();
    flags(default_fmtflags);
    ssb.clear();
  }

  std::string_view strv() const {
    return ssb.strv();
  }

private:
  StackStringBuf<SIZE> ssb;
  fmtflags const default_fmtflags;
};







class CachedStackStringStream {
public:
  using sss = StackStringStream<4096>;
  using osptr = std::unique_ptr<sss>;

  CachedStackStringStream() {
    if (cache.destructed || cache.c.empty()) {
      osp = std::make_unique<sss>();
    } else {
      osp = std::move(cache.c.back());
      cache.c.pop_back();
      osp->reset();
    }
  }
  CachedStackStringStream(const CachedStackStringStream&) = delete;
  CachedStackStringStream& operator=(const CachedStackStringStream&) = delete;
  CachedStackStringStream(CachedStackStringStream&&) = delete;
  CachedStackStringStream& operator=(CachedStackStringStream&&) = delete;
  ~CachedStackStringStream() {
    if (!cache.destructed && cache.c.size() < max_elems) {
      cache.c.emplace_back(std::move(osp));
    }
  }

  sss& operator*() {
    return *osp;
  }
  sss const& operator*() const {
    return *osp;
  }
  sss* operator->() {
    return osp.get();
  }
  sss const* operator->() const {
    return osp.get();
  }

  sss const* get() const {
    return osp.get();
  }
  sss* get() {
    return osp.get();
  }

private:
  static constexpr std::size_t max_elems = 8;






  struct Cache {
    using container = std::vector<osptr>;

    Cache() {}
    ~Cache() { destructed = true; }

    container c;
    bool destructed = false;
  };

  inline static thread_local Cache cache;
  osptr osp;
};
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Entry.h" 2







namespace ceph {
namespace logging {

class Entry {
public:
  using time = log_time;

  Entry() = delete;
  Entry(short pr, short sub) :
    m_stamp(clock().now()),
    m_thread(pthread_self()),
    m_prio(pr),
    m_subsys(sub)
  {}
  Entry(const Entry &) = default;
  Entry& operator=(const Entry &) = default;
  Entry(Entry &&e) = default;
  Entry& operator=(Entry &&e) = default;
  virtual ~Entry() = default;

  virtual std::string_view strv() const = 0;
  virtual std::size_t size() const = 0;

  time m_stamp;
  pthread_t m_thread;
  short m_prio, m_subsys;

private:
  static log_clock& clock() {
    static log_clock clock;
    return clock;
  }
};




class MutableEntry : public Entry {
public:
  MutableEntry() = delete;
  MutableEntry(short pr, short sub) : Entry(pr, sub) {}
  MutableEntry(const MutableEntry&) = delete;
  MutableEntry& operator=(const MutableEntry&) = delete;
  MutableEntry(MutableEntry&&) = delete;
  MutableEntry& operator=(MutableEntry&&) = delete;
  ~MutableEntry() override = default;

  std::ostream& get_ostream() {
    return *cos;
  }

  std::string_view strv() const override {
    return cos->strv();
  }
  std::size_t size() const override {
    return cos->strv().size();
  }

private:
  CachedStackStringStream cos;
};

class ConcreteEntry : public Entry {
public:
  ConcreteEntry() = delete;
  ConcreteEntry(const Entry& e) : Entry(e) {
    auto strv = e.strv();
    str.reserve(strv.size());
    str.insert(str.end(), strv.begin(), strv.end());
  }
  ConcreteEntry& operator=(const Entry& e) {
    Entry::operator=(e);
    auto strv = e.strv();
    str.reserve(strv.size());
    str.assign(strv.begin(), strv.end());
    return *this;
  }
  ConcreteEntry(ConcreteEntry&& e) : Entry(e), str(std::move(e.str)) {}
  ConcreteEntry& operator=(ConcreteEntry&& e) {
    Entry::operator=(e);
    str = std::move(e.str);
    return *this;
  }
  ~ConcreteEntry() override = default;

  std::string_view strv() const override {
    return std::string_view(str.data(), str.size());
  }
  std::size_t size() const override {
    return str.size();
  }

private:
  boost::container::small_vector<char, 1024> str;
};

}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/log/Log.h" 2

namespace ceph {
namespace logging {

class Graylog;
class SubsystemMap;

class Log : private Thread
{
  using EntryRing = boost::circular_buffer<ConcreteEntry>;
  using EntryVector = std::vector<ConcreteEntry>;

  static const std::size_t DEFAULT_MAX_NEW = 100;
  static const std::size_t DEFAULT_MAX_RECENT = 10000;

  Log **m_indirect_this;
  log_clock clock;

  const SubsystemMap *m_subs;

  std::mutex m_queue_mutex;
  std::mutex m_flush_mutex;
  std::condition_variable m_cond_loggers;
  std::condition_variable m_cond_flusher;

  pthread_t m_queue_mutex_holder;
  pthread_t m_flush_mutex_holder;

  EntryVector m_new;
  EntryRing m_recent;
  EntryVector m_flush;

  std::string m_log_file;
  int m_fd = -1;
  uid_t m_uid = 0;
  gid_t m_gid = 0;

  int m_fd_last_error = 0;

  int m_syslog_log = -2, m_syslog_crash = -2;
  int m_stderr_log = -1, m_stderr_crash = -1;
  int m_graylog_log = -3, m_graylog_crash = -3;

  std::string m_log_stderr_prefix;

  std::shared_ptr<Graylog> m_graylog;

  std::vector<char> m_log_buf;

  bool m_stop = false;

  std::size_t m_max_new = DEFAULT_MAX_NEW;
  std::size_t m_max_recent = DEFAULT_MAX_RECENT;

  bool m_inject_segv = false;

  void *entry() override;

  void _log_safe_write(std::string_view sv);
  void _flush_logbuf();
  void _flush(EntryVector& q, bool requeue, bool crash);

  void _log_message(const char *s, bool crash);

public:
  using Thread::is_started;

  Log(const SubsystemMap *s);
  ~Log() override;

  void set_flush_on_exit();

  void set_coarse_timestamps(bool coarse);
  void set_max_new(std::size_t n);
  void set_max_recent(std::size_t n);
  void set_log_file(std::string_view fn);
  void reopen_log_file();
  void chown_log_file(uid_t uid, gid_t gid);
  void set_log_stderr_prefix(std::string_view p);

  void flush();

  void dump_recent();

  void set_syslog_level(int log, int crash);
  void set_stderr_level(int log, int crash);
  void set_graylog_level(int log, int crash);

  void start_graylog();
  void stop_graylog();

  std::shared_ptr<Graylog> graylog() { return m_graylog; }

  void submit_entry(Entry&& e);

  void start();
  void stop();


  bool is_inside_log_lock();


  void inject_segv();
  void reset_segv();
};

}
}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/dout.h" 2


extern void dout_emergency(const char * const str);
extern void dout_emergency(const std::string &str);


class _bad_endl_use_dendl_t { public: _bad_endl_use_dendl_t(int) {} };
static const _bad_endl_use_dendl_t endl = 0;
inline std::ostream& operator<<(std::ostream& out, _bad_endl_use_dendl_t) {
  __ceph_abort( "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/dout.h", 42, __PRETTY_FUNCTION__, "you are using the wrong endl.. use std::endl or dendl");
  return out;
}

class DoutPrefixProvider {
public:
  virtual std::ostream& gen_prefix(std::ostream& out) const = 0;
  virtual CephContext *get_cct() const = 0;
  virtual unsigned get_subsys() const = 0;
  virtual ~DoutPrefixProvider() {}
};


class NoDoutPrefix : public DoutPrefixProvider {
  CephContext *const cct;
  const unsigned subsys;
 public:
  NoDoutPrefix(CephContext *cct, unsigned subsys) : cct(cct), subsys(subsys) {}

  std::ostream& gen_prefix(std::ostream& out) const override { return out; }
  CephContext *get_cct() const override { return cct; }
  unsigned get_subsys() const override { return subsys; }
};


class DoutPrefix : public NoDoutPrefix {
  const char *const prefix;
 public:
  DoutPrefix(CephContext *cct, unsigned subsys, const char *prefix)
    : NoDoutPrefix(cct, subsys), prefix(prefix) {}

  std::ostream& gen_prefix(std::ostream& out) const override {
    return out << prefix;
  }
};


class DoutPrefixPipe : public DoutPrefixProvider {
  const DoutPrefixProvider& dpp;
 public:
  DoutPrefixPipe(const DoutPrefixProvider& dpp) : dpp(dpp) {}

  std::ostream& gen_prefix(std::ostream& out) const override final {
    dpp.gen_prefix(out);
    add_prefix(out);
    return out;
  }
  CephContext *get_cct() const override { return dpp.get_cct(); }
  unsigned get_subsys() const override { return dpp.get_subsys(); }

  virtual void add_prefix(std::ostream& out) const = 0;
};


namespace ceph::dout {

template<typename T>
struct dynamic_marker_t {
  T value;
  operator T() const { return value; }
};

template<typename T>
dynamic_marker_t<T> need_dynamic(T&& t) {
  return dynamic_marker_t<T>{ std::forward<T>(t) };
}

template<typename T>
struct is_dynamic : public std::false_type {};

template<typename T>
struct is_dynamic<dynamic_marker_t<T>> : public std::true_type {};

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/debug.h" 2
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_basic_types.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_basic_types.h"
struct rgw_user {
  std::string tenant;
  std::string id;

  rgw_user() {}

  rgw_user(const std::string& s) {
    from_str(s);
  }
  rgw_user(const std::string& tenant, const std::string& id)
    : tenant(tenant),
      id(id) {
  }
  rgw_user(std::string&& tenant, std::string&& id)
    : tenant(std::move(tenant)),
      id(std::move(id)) {
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(tenant, bl);
    encode(id, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(tenant, bl);
    decode(id, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void to_str(std::string& str) const {
    if (!tenant.empty()) {
      str = tenant + '$' + id;
    } else {
      str = id;
    }
  }

  void clear() {
    tenant.clear();
    id.clear();
  }

  bool empty() const {
    return id.empty();
  }

  string to_str() const {
    string s;
    to_str(s);
    return s;
  }

  void from_str(const std::string& str) {
    size_t pos = str.find('$');
    if (pos != std::string::npos) {
      tenant = str.substr(0, pos);
      id = str.substr(pos + 1);
    } else {
      tenant.clear();
      id = str;
    }
  }

  rgw_user& operator=(const string& str) {
    from_str(str);
    return *this;
  }

  int compare(const rgw_user& u) const {
    int r = tenant.compare(u.tenant);
    if (r != 0)
      return r;

    return id.compare(u.id);
  }
  int compare(const string& str) const {
    rgw_user u(str);
    return compare(u);
  }

  bool operator!=(const rgw_user& rhs) const {
    return (compare(rhs) != 0);
  }
  bool operator==(const rgw_user& rhs) const {
    return (compare(rhs) == 0);
  }
  bool operator<(const rgw_user& rhs) const {
    if (tenant < rhs.tenant) {
      return true;
    } else if (tenant > rhs.tenant) {
      return false;
    }
    return (id < rhs.id);
  }
};
inline void encode(const rgw_user &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_user &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }







namespace rgw {
namespace auth {
class Principal {
  enum types { User, Role, Tenant, Wildcard, OidcProvider };
  types t;
  rgw_user u;
  string idp_url;

  explicit Principal(types t)
    : t(t) {}

  Principal(types t, std::string&& n, std::string i)
    : t(t), u(std::move(n), std::move(i)) {}

  Principal(string&& idp_url)
    : t(OidcProvider), idp_url(std::move(idp_url)) {}

public:

  static Principal wildcard() {
    return Principal(Wildcard);
  }

  static Principal user(std::string&& t, std::string&& u) {
    return Principal(User, std::move(t), std::move(u));
  }

  static Principal role(std::string&& t, std::string&& u) {
    return Principal(Role, std::move(t), std::move(u));
  }

  static Principal tenant(std::string&& t) {
    return Principal(Tenant, std::move(t), {});
  }

  static Principal oidc_provider(string&& idp_url) {
    return Principal(std::move(idp_url));
  }

  bool is_wildcard() const {
    return t == Wildcard;
  }

  bool is_user() const {
    return t == User;
  }

  bool is_role() const {
    return t == Role;
  }

  bool is_tenant() const {
    return t == Tenant;
  }

  bool is_oidc_provider() const {
    return t == OidcProvider;
  }

  const std::string& get_tenant() const {
    return u.tenant;
  }

  const std::string& get_id() const {
    return u.id;
  }

  const string& get_idp_url() const {
    return idp_url;
  }

  bool operator ==(const Principal& o) const {
    return (t == o.t) && (u == o.u);
  }

  bool operator <(const Principal& o) const {
    return (t < o.t) || ((t == o.t) && (u < o.u));
  }
};

std::ostream& operator <<(std::ostream& m, const Principal& p);
}
}

class JSONObj;

void decode_json_obj(rgw_user& val, JSONObj *obj);
void encode_json(const char *name, const rgw_user& val, Formatter *f);
void encode_xml(const char *name, const rgw_user& val, Formatter *f);

inline ostream& operator<<(ostream& out, const rgw_user &u) {
  string s;
  u.to_str(s);
  return out << s;
}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h" 2
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h"
static constexpr char RGW_REFERER_WILDCARD[] = "*";

enum ACLGranteeTypeEnum {

  ACL_TYPE_CANON_USER = 0,
  ACL_TYPE_EMAIL_USER = 1,
  ACL_TYPE_GROUP = 2,
  ACL_TYPE_UNKNOWN = 3,
  ACL_TYPE_REFERER = 4,
};

enum ACLGroupTypeEnum {

  ACL_GROUP_NONE = 0,
  ACL_GROUP_ALL_USERS = 1,
  ACL_GROUP_AUTHENTICATED_USERS = 2,
};

class ACLPermission
{
protected:
  int flags;
public:
  ACLPermission() : flags(0) {}
  ~ACLPermission() {}
  uint32_t get_permissions() const { return flags; }
  void set_permissions(uint32_t perm) { flags = perm; }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(flags, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(flags, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<ACLPermission*>& o);
};
inline void encode(const ACLPermission &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(ACLPermission &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class ACLGranteeType
{
protected:
  __u32 type;
public:
  ACLGranteeType() : type(ACL_TYPE_UNKNOWN) {}
  virtual ~ACLGranteeType() {}

  ACLGranteeTypeEnum get_type() const { return (ACLGranteeTypeEnum)type; }
  void set(ACLGranteeTypeEnum t) { type = t; }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(type, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(type, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<ACLGranteeType*>& o);
};
inline void encode(const ACLGranteeType &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(ACLGranteeType &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class ACLGrantee
{
public:
  ACLGrantee() {}
  ~ACLGrantee() {}
};


class ACLGrant
{
protected:
  ACLGranteeType type;
  rgw_user id;
  string email;
  ACLPermission permission;
  string name;
  ACLGroupTypeEnum group;
  string url_spec;

public:
  ACLGrant() : group(ACL_GROUP_NONE) {}
  virtual ~ACLGrant() {}



  bool get_id(rgw_user& _id) const {
    switch(type.get_type()) {
    case ACL_TYPE_EMAIL_USER:
      _id = email;
      return true;
    case ACL_TYPE_GROUP:
    case ACL_TYPE_REFERER:
      return false;
    default:
      _id = id;
      return true;
    }
  }
  ACLGranteeType& get_type() { return type; }
  const ACLGranteeType& get_type() const { return type; }
  ACLPermission& get_permission() { return permission; }
  const ACLPermission& get_permission() const { return permission; }
  ACLGroupTypeEnum get_group() const { return group; }
  const string& get_referer() const { return url_spec; }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 5; __u8 struct_compat = 3; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(type, bl);
    string s;
    id.to_str(s);
    encode(s, bl);
    string uri;
    encode(uri, bl);
    encode(email, bl);
    encode(permission, bl);
    encode(name, bl);
    __u32 g = (__u32)group;
    encode(g, bl);
    encode(url_spec, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (5 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "5" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(type, bl);
    string s;
    decode(s, bl);
    id.from_str(s);
    string uri;
    decode(uri, bl);
    decode(email, bl);
    decode(permission, bl);
    decode(name, bl);
    if (struct_v > 1) {
      __u32 g;
      decode(g, bl);
      group = (ACLGroupTypeEnum)g;
    } else {
      group = uri_to_group(uri);
    }
    if (struct_v >= 5) {
      decode(url_spec, bl);
    } else {
      url_spec.clear();
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<ACLGrant*>& o);

  ACLGroupTypeEnum uri_to_group(string& uri);

  void set_canon(const rgw_user& _id, const string& _name, const uint32_t perm) {
    type.set(ACL_TYPE_CANON_USER);
    id = _id;
    name = _name;
    permission.set_permissions(perm);
  }
  void set_group(ACLGroupTypeEnum _group, const uint32_t perm) {
    type.set(ACL_TYPE_GROUP);
    group = _group;
    permission.set_permissions(perm);
  }
  void set_referer(const std::string& _url_spec, const uint32_t perm) {
    type.set(ACL_TYPE_REFERER);
    url_spec = _url_spec;
    permission.set_permissions(perm);
  }
};
inline void encode(const ACLGrant &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(ACLGrant &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct ACLReferer {
  std::string url_spec;
  uint32_t perm;

  ACLReferer() : perm(0) {}
  ACLReferer(const std::string& url_spec,
             const uint32_t perm)
    : url_spec(url_spec),
      perm(perm) {
  }

  bool is_match(boost::string_ref http_referer) const {
    const auto http_host = get_http_host(http_referer);
    if (!http_host || http_host->length() < url_spec.length()) {
      return false;
    }

    if ("*" == url_spec) {
      return true;
    }

    if (http_host->compare(url_spec) == 0) {
      return true;
    }

    if ('.' == url_spec[0]) {


      return http_host->ends_with(url_spec);
    }

    return false;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(url_spec, bl);
    encode(perm, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(url_spec, bl);
    decode(perm, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;

private:
  boost::optional<boost::string_ref> get_http_host(const boost::string_ref url) const {
    size_t pos = url.find("://");
    if (pos == boost::string_ref::npos || url.starts_with("://") ||
        url.ends_with("://") || url.ends_with('@')) {
      return boost::none;
    }
    boost::string_ref url_sub = url.substr(pos + strlen("://"));
    pos = url_sub.find('@');
    if (pos != boost::string_ref::npos) {
      url_sub = url_sub.substr(pos + 1);
    }
    pos = url_sub.find_first_of("/:");
    if (pos == boost::string_ref::npos) {

      return url_sub;
    }
    return url_sub.substr(0, pos);
  }
};
inline void encode(const ACLReferer &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(ACLReferer &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

namespace rgw {
namespace auth {
  class Identity;
}
}

class RGWAccessControlList
{
protected:
  CephContext *cct;


  map<string, int> acl_user_map;
  map<uint32_t, int> acl_group_map;
  list<ACLReferer> referer_list;
  multimap<string, ACLGrant> grant_map;
  void _add_grant(ACLGrant *grant);
public:
  explicit RGWAccessControlList(CephContext *_cct) : cct(_cct) {}
  RGWAccessControlList() : cct(
# 298 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h" 3 4
                              __null
# 298 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h"
                                  ) {}

  void set_ctx(CephContext *ctx) {
    cct = ctx;
  }

  virtual ~RGWAccessControlList() {}

  uint32_t get_perm(const DoutPrefixProvider* dpp,
                    const rgw::auth::Identity& auth_identity,
                    uint32_t perm_mask);
  uint32_t get_group_perm(ACLGroupTypeEnum group, uint32_t perm_mask);
  uint32_t get_referer_perm(uint32_t current_perm,
                            std::string http_referer,
                            uint32_t perm_mask);
  void encode(bufferlist& bl) const {
    __u8 struct_v = 4; __u8 struct_compat = 3; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    bool maps_initialized = true;
    encode(maps_initialized, bl);
    encode(acl_user_map, bl);
    encode(grant_map, bl);
    encode(acl_group_map, bl);
    encode(referer_list, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (4 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "4" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    bool maps_initialized;
    decode(maps_initialized, bl);
    decode(acl_user_map, bl);
    decode(grant_map, bl);
    if (struct_v >= 2) {
      decode(acl_group_map, bl);
    } else if (!maps_initialized) {
      multimap<string, ACLGrant>::iterator iter;
      for (iter = grant_map.begin(); iter != grant_map.end(); ++iter) {
        ACLGrant& grant = iter->second;
        _add_grant(&grant);
      }
    }
    if (struct_v >= 4) {
      decode(referer_list, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWAccessControlList*>& o);

  void add_grant(ACLGrant *grant);

  multimap<string, ACLGrant>& get_grant_map() { return grant_map; }
  const multimap<string, ACLGrant>& get_grant_map() const { return grant_map; }

  void create_default(const rgw_user& id, string name) {
    acl_user_map.clear();
    acl_group_map.clear();
    referer_list.clear();

    ACLGrant grant;
    grant.set_canon(id, name, ( 0x01 | 0x02 | 0x04 | 0x08 ));
    add_grant(&grant);
  }
};
inline void encode(const RGWAccessControlList &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWAccessControlList &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class ACLOwner
{
protected:
  rgw_user id;
  string display_name;
public:
  ACLOwner() {}
  ~ACLOwner() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    string s;
    id.to_str(s);
    encode(s, bl);
    encode(display_name, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (3 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "3" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    string s;
    decode(s, bl);
    id.from_str(s);
    decode(display_name, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<ACLOwner*>& o);
  void set_id(const rgw_user& _id) { id = _id; }
  void set_name(const string& name) { display_name = name; }

  rgw_user& get_id() { return id; }
  const rgw_user& get_id() const { return id; }
  string& get_display_name() { return display_name; }
};
inline void encode(const ACLOwner &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(ACLOwner &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWAccessControlPolicy
{
protected:
  CephContext *cct;
  RGWAccessControlList acl;
  ACLOwner owner;

public:
  explicit RGWAccessControlPolicy(CephContext *_cct) : cct(_cct), acl(_cct) {}
  RGWAccessControlPolicy() : cct(
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h" 3 4
                                __null
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h"
                                    ), acl(
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h" 3 4
                                           __null
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl.h"
                                               ) {}
  virtual ~RGWAccessControlPolicy() {}

  void set_ctx(CephContext *ctx) {
    cct = ctx;
    acl.set_ctx(ctx);
  }

  uint32_t get_perm(const DoutPrefixProvider* dpp,
                    const rgw::auth::Identity& auth_identity,
                    uint32_t perm_mask,
                    const char * http_referer);
  uint32_t get_group_perm(ACLGroupTypeEnum group, uint32_t perm_mask);
  bool verify_permission(const DoutPrefixProvider* dpp,
                         const rgw::auth::Identity& auth_identity,
                         uint32_t user_perm_mask,
                         uint32_t perm,
                         const char * http_referer = nullptr);

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(owner, bl);
    encode(acl, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(owner, bl);
    decode(acl, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWAccessControlPolicy*>& o);
  void decode_owner(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(owner, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void set_owner(ACLOwner& o) { owner = o; }
  ACLOwner& get_owner() {
    return owner;
  }

  void create_default(const rgw_user& id, string& name) {
    acl.create_default(id, name);
    owner.set_id(id);
    owner.set_name(name);
  }
  RGWAccessControlList& get_acl() {
    return acl;
  }
  const RGWAccessControlList& get_acl() const {
    return acl;
  }

  virtual bool compare_group_name(string& id, ACLGroupTypeEnum group) { return false; }
};
inline void encode(const RGWAccessControlPolicy &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWAccessControlPolicy &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_cors.h" 1
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_cors.h"
class RGWCORSRule
{
protected:
  uint32_t max_age;
  uint8_t allowed_methods;
  std::string id;
  std::set<string> allowed_hdrs;
  std::set<string> lowercase_allowed_hdrs;
  std::set<string> allowed_origins;
  std::list<string> exposable_hdrs;

public:
  RGWCORSRule() : max_age(((uint32_t)-1)),allowed_methods(0) {}
  RGWCORSRule(std::set<string>& o, std::set<string>& h,
              std::list<string>& e, uint8_t f, uint32_t a)
      :max_age(a),
       allowed_methods(f),
       allowed_hdrs(h),
       allowed_origins(o),
       exposable_hdrs(e) {}
  virtual ~RGWCORSRule() {}

  std::string& get_id() { return id; }
  uint32_t get_max_age() { return max_age; }
  uint8_t get_allowed_methods() { return allowed_methods; }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(max_age, bl);
    encode(allowed_methods, bl);
    encode(id, bl);
    encode(allowed_hdrs, bl);
    encode(allowed_origins, bl);
    encode(exposable_hdrs, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(max_age, bl);
    decode(allowed_methods, bl);
    decode(id, bl);
    decode(allowed_hdrs, bl);
    decode(allowed_origins, bl);
    decode(exposable_hdrs, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  bool has_wildcard_origin();
  bool is_origin_present(const char *o);
  void format_exp_headers(std::string& s);
  void erase_origin_if_present(std::string& origin, bool *rule_empty);
  void dump_origins();
  void dump(Formatter *f) const;
  bool is_header_allowed(const char *hdr, size_t len);
};
inline void encode(const RGWCORSRule &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWCORSRule &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWCORSConfiguration
{
  protected:
    std::list<RGWCORSRule> rules;
  public:
    RGWCORSConfiguration() {}
    ~RGWCORSConfiguration() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(rules, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(rules, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  std::list<RGWCORSRule>& get_rules() {
    return rules;
  }
  bool is_empty() {
    return rules.empty();
  }
  void get_origins_list(const char *origin, std::list<string>& origins);
  RGWCORSRule * host_name_rule(const char *origin);
  void erase_host_name_rule(std::string& origin);
  void dump();
  void stack_rule(RGWCORSRule& r) {
    rules.push_front(r);
  }
};
inline void encode(const RGWCORSConfiguration &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWCORSConfiguration &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

static inline int validate_name_string(string& o) {
  if (o.length() == 0)
    return -1;
  if (o.find_first_of("*") != o.find_last_of("*"))
    return -1;
  return 0;
}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/shared_mutex.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/shared_mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/config.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/requires_threads.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform.hpp" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/config.hpp" 2 3 4
# 516 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/auto_link.hpp" 1 3 4
# 517 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/config.hpp" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/shared_mutex.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/shared_mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/is_placeholder.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/is_placeholder.hpp" 3 4

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/is_placeholder.hpp" 3 4
namespace boost
{

template< class T > struct is_placeholder
{
    enum _vt { value = 0 };
};

}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/arg.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/arg.hpp" 3 4
namespace boost
{

template<bool Eq> struct _arg_eq
{
};

template<> struct _arg_eq<true>
{
    typedef void type;
};

template< int I > struct arg
{
    constexpr arg()
    {
    }

    template< class T > constexpr arg( T const & , typename _arg_eq< I == is_placeholder<T>::value >::type * = 0 )
    {
    }
};

template< int I > constexpr bool operator==( arg<I> const &, arg<I> const & )
{
    return true;
}



template< int I > struct is_placeholder< arg<I> >
{
    enum _vt { value = I };
};

template< int I > struct is_placeholder< arg<I> (*) () >
{
    enum _vt { value = I };
};



}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/visit_each.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/visit_each.hpp" 3 4
namespace boost {
  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t, long)
  {
    visitor(t);
  }

  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t)
  {
    visit_each(visitor, t, 0);
  }
}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/is_same.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/is_same.hpp" 3 4
namespace boost
{

namespace core
{

template< class T1, class T2 > struct is_same
{
    static const bool value = false;
};

template< class T > struct is_same< T, T >
{
    static const bool value = true;
};

}

}
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/storage.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/storage.hpp" 3 4
namespace boost
{

namespace _bi
{



template<class A1> struct storage1
{
    explicit storage1( A1 a1 ): a1_( a1 ) {}

    template<class V> void accept(V & v) const
    {
        visit_each(v, a1_, 0);
    }

    A1 a1_;
};



template<int I> struct storage1< boost::arg<I> >
{
    explicit storage1( boost::arg<I> ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};

template<int I> struct storage1< boost::arg<I> (*) () >
{
    explicit storage1( boost::arg<I> (*) () ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};





template<class A1, class A2> struct storage2: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a2_, 0);
    }

    A2 a2_;
};



template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};

template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a3_, 0);
    }

    A3 a3_;
};



template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};

template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a4_, 0);
    }

    A4 a4_;
};



template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a5_, 0);
    }

    A5 a5_;
};



template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a6_, 0);
    }

    A6 a6_;
};



template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a7_, 0);
    }

    A7 a7_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a8_, 0);
    }

    A8 a8_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a9_, 0);
    }

    A9 a9_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};



}

}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4






namespace boost
{

template<class T> class weak_ptr;

namespace _bi
{



template<class R, class F> struct result_traits
{
    typedef R type;
};



struct unspecified {};

template<class F> struct result_traits<unspecified, F>
{
    typedef typename F::result_type type;
};

template<class F> struct result_traits< unspecified, reference_wrapper<F> >
{
    typedef typename F::result_type type;
};





template<class T> bool ref_compare( T const & a, T const & b, long )
{
    return a == b;
}

template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
{
    return true;
}

template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
{
    return true;
}

template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
{
    return a.get_pointer() == b.get_pointer();
}



template<class R, class F, class L> class bind_t;

template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
{
    return a.compare( b );
}



template<class T> class value
{
public:

    value(T const & t): t_(t) {}

    T & get() { return t_; }
    T const & get() const { return t_; }

    bool operator==(value const & rhs) const
    {
        return t_ == rhs.t_;
    }

private:

    T t_;
};



template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
{
    return !(a.get() < b.get()) && !(b.get() < a.get());
}



template<class T> class type {};



template<class F> struct unwrapper
{
    static inline F & unwrap( F & f, long )
    {
        return f;
    }

    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
    {
        return rf.get();
    }

    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
    {
        return _mfi::dm<R, T>( pm );
    }
};



class list0
{
public:

    list0() {}

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
    {
        return unwrapper<F>::unwrap(f, 0)();
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F & f, A &, int)
    {
        unwrapper<F>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
    {
        unwrapper<F const>::unwrap(f, 0)();
    }

    template<class V> void accept(V &) const
    {
    }

    bool operator==(list0 const &) const
    {
        return true;
    }
};
# 223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template< class A1 > class list1: private storage1< A1 >
{
private:

    typedef storage1< A1 > base_type;

public:

    explicit list1( A1 a1 ): base_type( a1 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list1 const & rhs) const
    {
        return ref_compare(base_type::a1_, rhs.a1_, 0);
    }
};

struct logical_and;
struct logical_or;

template< class A1, class A2 > class list2: private storage2< A1, A2 >
{
private:

    typedef storage2< A1, A2 > base_type;

public:

    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class A> bool operator()( type<bool>, logical_and & , A & a, int )
    {
        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_and const & , A & a, int ) const
    {
        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_or & , A & a, int )
    {
        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_or const & , A & a, int ) const
    {
        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list2 const & rhs) const
    {
        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
    }
};

template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
{
private:

    typedef storage3< A1, A2, A3 > base_type;

public:

    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list3 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 );
    }
};

template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
{
private:

    typedef storage4< A1, A2, A3, A4 > base_type;

public:

    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list4 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 );
    }
};

template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
{
private:

    typedef storage5< A1, A2, A3, A4, A5 > base_type;

public:

    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list5 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
{
private:

    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;

public:

    list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list6 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
{
private:

    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;

public:

    list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list7 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 );
    }
};

template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
private:

    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;

public:

    list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list8 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
            ref_compare( base_type::a8_, rhs.a8_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
{
private:

    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;

public:

    list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list9 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
            ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
            ref_compare( base_type::a9_, rhs.a9_, 0 );
    }
};
# 870 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template< class A1 > class rrlist1
{
private:

    A1 & a1_;

public:

    explicit rrlist1( A1 & a1 ): a1_( a1 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist1<A1&> a( a1_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist1<A1&> a( a1_ );
        return b.eval( a );
    }
};

template< class A1, class A2 > class rrlist2
{
private:

    A1 & a1_;
    A2 & a2_;

public:

    rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist2<A1&, A2&> a( a1_, a2_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist2<A1&, A2&> a( a1_, a2_ );
        return b.eval( a );
    }
};

template< class A1, class A2, class A3 > class rrlist3
{
private:

    A1 & a1_;
    A2 & a2_;
    A3 & a3_;

public:

    rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
        return b.eval( a );
    }
};

template< class A1, class A2, class A3, class A4 > class rrlist4
{
private:

    A1 & a1_;
    A2 & a2_;
    A3 & a3_;
    A4 & a4_;

public:

    rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
        return b.eval( a );
    }
};

template< class A1, class A2, class A3, class A4, class A5 > class rrlist5
{
private:

    A1 & a1_;
    A2 & a2_;
    A3 & a3_;
    A4 & a4_;
    A5 & a5_;

public:

    rrlist5( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
        return b.eval( a );
    }
};

template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6
{
private:

    A1 & a1_;
    A2 & a2_;
    A3 & a3_;
    A4 & a4_;
    A5 & a5_;
    A6 & a6_;

public:

    rrlist6( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
        return b.eval( a );
    }
};

template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7
{
private:

    A1 & a1_;
    A2 & a2_;
    A3 & a3_;
    A4 & a4_;
    A5 & a5_;
    A6 & a6_;
    A7 & a7_;

public:

    rrlist7( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
        return b.eval( a );
    }
};

template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8
{
private:

    A1 & a1_;
    A2 & a2_;
    A3 & a3_;
    A4 & a4_;
    A5 & a5_;
    A6 & a6_;
    A7 & a7_;
    A8 & a8_;

public:

    rrlist8( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
    A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
    A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
        return b.eval( a );
    }
};

template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9
{
private:

    A1 & a1_;
    A2 & a2_;
    A3 & a3_;
    A4 & a4_;
    A5 & a5_;
    A6 & a6_;
    A7 & a7_;
    A8 & a8_;
    A9 & a9_;

public:

    rrlist9( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ), a9_( a9 ) {}

    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
    A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
    A9 && operator[] (boost::arg<9>) const { return std::forward<A9>( a9_ ); }

    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
    A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
    A9 && operator[] (boost::arg<9> (*) ()) const { return std::forward<A9>( a9_ ); }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
    {
        rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
        return b.eval( a );
    }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
    {
        rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
        return b.eval( a );
    }
};

template<class R, class F, class L> class bind_t
{
private:

    F f_;
    L l_;

public:

    typedef typename result_traits<R, F>::type result_type;
    typedef bind_t this_type;

    bind_t( F f, L const & l ): f_( f ), l_( l ) {}



    result_type operator()()
    {
        list0 a;
        return l_( type<result_type>(), f_, a, 0 );
    }

    result_type operator()() const
    {
        list0 a;
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1> result_type operator()( A1 && a1 )
    {
        rrlist1< A1 > a( a1 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1> result_type operator()( A1 && a1 ) const
    {
        rrlist1< A1 > a( a1 );
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 )
    {
        rrlist2< A1, A2 > a( a1, a2 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) const
    {
        rrlist2< A1, A2 > a( a1, a2 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 )
    {
        rrlist3< A1, A2, A3 > a( a1, a2, a3 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const
    {
        rrlist3< A1, A2, A3 > a( a1, a2, a3 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
    {
        rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const
    {
        rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
    {
        rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) const
    {
        rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
    {
        rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) const
    {
        rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
    {
        rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) const
    {
        rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
    {
        rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) const
    {
        rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
    {
        rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) const
    {
        rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
        return l_( type<result_type>(), f_, a, 0 );
    }



    template<class A> result_type eval( A & a )
    {
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class A> result_type eval( A & a ) const
    {
        return l_( type<result_type>(), f_, a, 0 );
    }

    template<class V> void accept( V & v ) const
    {

        using boost::visit_each;


        visit_each( v, f_, 0 );
        l_.accept( v );
    }

    bool compare( this_type const & rhs ) const
    {
        return ref_compare( f_, rhs.f_, 0 ) && l_ == rhs.l_;
    }
};
# 1517 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
{
    return a.compare(b);
}
# 1571 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template< class T, int I > struct add_value_2
{
    typedef boost::arg<I> type;
};

template< class T > struct add_value_2< T, 0 >
{
    typedef _bi::value< T > type;
};

template<class T> struct add_value
{
    typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
};



template<class T> struct add_value< value<T> >
{
    typedef _bi::value<T> type;
};

template<class T> struct add_value< reference_wrapper<T> >
{
    typedef reference_wrapper<T> type;
};

template<int I> struct add_value< arg<I> >
{
    typedef boost::arg<I> type;
};

template<int I> struct add_value< arg<I> (*) () >
{
    typedef boost::arg<I> (*type) ();
};

template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
{
    typedef bind_t<R, F, L> type;
};
# 1654 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template<class A1> struct list_av_1
{
    typedef typename add_value<A1>::type B1;
    typedef list1<B1> type;
};

template<class A1, class A2> struct list_av_2
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef list2<B1, B2> type;
};

template<class A1, class A2, class A3> struct list_av_3
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef list3<B1, B2, B3> type;
};

template<class A1, class A2, class A3, class A4> struct list_av_4
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef list4<B1, B2, B3, B4> type;
};

template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef list5<B1, B2, B3, B4, B5> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef list6<B1, B2, B3, B4, B5, B6> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef typename add_value<A9>::type B9;
    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
};



struct logical_not
{
    template<class V> bool operator()(V const & v) const { return !v; }
};

template<class R, class F, class L>
    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
    operator! (bind_t<R, F, L> const & f)
{
    typedef list1< bind_t<R, F, L> > list_type;
    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
}
# 1777 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }

struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }

struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }

struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }
# 1817 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template<class V, class T> void visit_each( V & v, value<T> const & t, int )
{
    using boost::visit_each;
    visit_each( v, t.get(), 0 );
}

template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
{
    t.accept( v );
}



}
# 1851 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template< class T > struct is_bind_expression
{
    enum _vt { value = 0 };
};



template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
{
    enum _vt { value = 1 };
};
# 1873 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}



template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(boost::type<R>, F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(boost::type<R>, F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}





template<class F>
    _bi::bind_t<_bi::unspecified, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
}

template<class F, class A1>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
}

template<class F, class A1, class A2>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
}

template<class F, class A1, class A2, class A3>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
}

template<class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 2127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_cc.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_cc.hpp" 3 4
template<class R>
    _bi::bind_t<R, R ( *) () , _bi::list0>
    bind( R ( *f) () )
{
    typedef R ( *F) () ;
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class B1, class A1>
    _bi::bind_t<R, R ( *) (B1) , typename _bi::list_av_1<A1>::type>
    bind( R ( *f) (B1) , A1 a1)
{
    typedef R ( *F) (B1) ;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class B1, class B2, class A1, class A2>
    _bi::bind_t<R, R ( *) (B1, B2) , typename _bi::list_av_2<A1, A2>::type>
    bind( R ( *f) (B1, B2) , A1 a1, A2 a2)
{
    typedef R ( *F) (B1, B2) ;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R,
    class B1, class B2, class B3,
    class A1, class A2, class A3>
    _bi::bind_t<R, R ( *) (B1, B2, B3) , typename _bi::list_av_3<A1, A2, A3>::type>
    bind( R ( *f) (B1, B2, B3) , A1 a1, A2 a2, A3 a3)
{
    typedef R ( *F) (B1, B2, B3) ;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4) , typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind( R ( *f) (B1, B2, B3, B4) , A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef R ( *F) (B1, B2, B3, B4) ;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5) , typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef R ( *F) (B1, B2, B3, B4, B5) ;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6) , typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6) ;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7) , typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7) ;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8) , typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8) ;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9) , typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9) ;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 2128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_cc.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_cc.hpp" 3 4
template<class R>
    _bi::bind_t<R, R ( *) () noexcept, _bi::list0>
    bind( R ( *f) () noexcept)
{
    typedef R ( *F) () noexcept;
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class B1, class A1>
    _bi::bind_t<R, R ( *) (B1) noexcept, typename _bi::list_av_1<A1>::type>
    bind( R ( *f) (B1) noexcept, A1 a1)
{
    typedef R ( *F) (B1) noexcept;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class B1, class B2, class A1, class A2>
    _bi::bind_t<R, R ( *) (B1, B2) noexcept, typename _bi::list_av_2<A1, A2>::type>
    bind( R ( *f) (B1, B2) noexcept, A1 a1, A2 a2)
{
    typedef R ( *F) (B1, B2) noexcept;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R,
    class B1, class B2, class B3,
    class A1, class A2, class A3>
    _bi::bind_t<R, R ( *) (B1, B2, B3) noexcept, typename _bi::list_av_3<A1, A2, A3>::type>
    bind( R ( *f) (B1, B2, B3) noexcept, A1 a1, A2 a2, A3 a3)
{
    typedef R ( *F) (B1, B2, B3) noexcept;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4) noexcept, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind( R ( *f) (B1, B2, B3, B4) noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef R ( *F) (B1, B2, B3, B4) noexcept;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5) noexcept, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef R ( *F) (B1, B2, B3, B4, B5) noexcept;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6) noexcept, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6) noexcept;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7) noexcept, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7) noexcept;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9) noexcept, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9) noexcept;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 2133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4
# 2187 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_mf_cc.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_mf_cc.hpp" 3 4
template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () , A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () const , A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    >::type bind(R ( T::*f) () , A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    >::type bind(R ( T::*f) () const , A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}



template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) , A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) const , A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    >::type bind(R ( T::*f) (B1) , A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    >::type bind(R ( T::*f) (B1) const , A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}



template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) , A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) const , A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    >::type bind(R ( T::*f) (B1, B2) , A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    >::type bind(R ( T::*f) (B1, B2) const , A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) , A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) const , A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    >::type bind(R ( T::*f) (B1, B2, B3) , A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    >::type bind(R ( T::*f) (B1, B2, B3) const , A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 2188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_mf2_cc.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_mf2_cc.hpp" 3 4
template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}



template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}



template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 2189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_mf_cc.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind_mf_cc.hpp" 3 4
template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () noexcept, A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () const noexcept, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    >::type bind(R ( T::*f) () noexcept, A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    >::type bind(R ( T::*f) () const noexcept, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}



template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) noexcept, A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) const noexcept, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    >::type bind(R ( T::*f) (B1) noexcept, A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    >::type bind(R ( T::*f) (B1) const noexcept, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}



template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) noexcept, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) const noexcept, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    >::type bind(R ( T::*f) (B1, B2) noexcept, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    >::type bind(R ( T::*f) (B1, B2) const noexcept, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    >::type bind(R ( T::*f) (B1, B2, B3) noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    >::type bind(R ( T::*f) (B1, B2, B3) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 2194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4
# 2261 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 3 4
namespace _bi
{

template< class Pm, int I > struct add_cref;

template< class M, class T > struct add_cref< M T::*, 0 >
{
    typedef M type;
};

template< class M, class T > struct add_cref< M T::*, 1 >
{




    typedef M const & type;



};

template< class R, class T > struct add_cref< R (T::*) (), 1 >
{
    typedef void type;
};



template< class R, class T > struct add_cref< R (T::*) () const, 1 >
{
    typedef void type;
};



template< class R, class T > struct add_cref< R (T::*) () const noexcept, 1 >
{
    typedef void type;
};





template<class R> struct isref
{
    enum value_type { value = 0 };
};

template<class R> struct isref< R& >
{
    enum value_type { value = 1 };
};

template<class R> struct isref< R* >
{
    enum value_type { value = 1 };
};

template<class Pm, class A1> struct dm_result
{
    typedef typename add_cref< Pm, 1 >::type type;
};

template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
{
    typedef typename bind_t<R, F, L>::result_type result_type;
    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
};

}

template< class A1, class M, class T >

_bi::bind_t<
    typename _bi::dm_result< M T::*, A1 >::type,
    _mfi::dm<M, T>,
    typename _bi::list_av_1<A1>::type
>

bind( M T::*f, A1 a1 )
{
    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
    typedef _mfi::dm<M, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
}



}



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/placeholders.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/placeholders.hpp" 3 4
namespace boost
{

namespace placeholders
{
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/placeholders.hpp" 3 4
static constexpr boost::arg<1> _1;
static constexpr boost::arg<2> _2;
static constexpr boost::arg<3> _3;
static constexpr boost::arg<4> _4;
static constexpr boost::arg<5> _5;
static constexpr boost::arg<6> _6;
static constexpr boost::arg<7> _7;
static constexpr boost::arg<8> _8;
static constexpr boost::arg<9> _9;



}

}
# 2357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind/bind.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/bind.hpp" 3 4
using namespace boost::placeholders;
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/mutex.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ignore_unused.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ignore_unused.hpp" 3 4
namespace boost {



template <typename... Ts>
inline __attribute__ ((__always_inline__)) constexpr void ignore_unused(Ts const& ...)
{}

template <typename... Ts>
inline __attribute__ ((__always_inline__)) constexpr void ignore_unused()
{}
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/ignore_unused.hpp" 3 4
}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/exceptions.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/exceptions.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/system_error.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/system_error.hpp" 3 4
# 1 "/usr/include/c++/10/cassert" 1 3 4
# 41 "/usr/include/c++/10/cassert" 3 4
       
# 42 "/usr/include/c++/10/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 45 "/usr/include/c++/10/cassert" 2 3
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/system_error.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/config.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef/platform.h" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/config.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/api_config.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/config.hpp" 2 3 4
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/auto_link.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/config.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/noncopyable.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cerrno.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cerrno.hpp" 3 4
# 1 "/usr/include/c++/10/cerrno" 1 3 4
# 39 "/usr/include/c++/10/cerrno" 3 4
       
# 40 "/usr/include/c++/10/cerrno" 3
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cerrno.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 2 3 4





namespace boost
{
  namespace system
  {

    class error_code;
    class error_condition;




    template< class T >
    struct is_error_code_enum { static const bool value = false; };

    template< class T >
    struct is_error_condition_enum { static const bool value = false; };



    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
      };

    }






    template<> struct is_error_condition_enum<errc::errc_t>
      { static const bool value = true; };
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
    class error_category;







    const error_category & system_category() noexcept;
    const error_category & generic_category() noexcept;
# 222 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
    class error_category : public noncopyable
    {


    private:

      class std_category: public std::error_category
      {
      private:

        boost::system::error_category const * pc_;

      public:

        explicit std_category( boost::system::error_category const * pc ): pc_( pc )
        {
        }

        virtual const char * name() const noexcept
        {
          return pc_->name();
        }

        virtual std::string message( int ev ) const
        {
          return pc_->message( ev );
        }

        virtual std::error_condition default_error_condition( int ev ) const
          noexcept;
        virtual bool equivalent( int code, const std::error_condition & condition ) const
          noexcept;
        virtual bool equivalent( const std::error_code & code, int condition ) const
          noexcept;
      };

      std_category std_cat_;

    public:

      error_category() noexcept: std_cat_( this ) {}

      operator std::error_category const & () const noexcept
      {



        return std_cat_;
      }
# 317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
    public:
      virtual ~error_category(){}

      virtual const char * name() const noexcept = 0;
      virtual std::string message( int ev ) const = 0;
      inline virtual error_condition default_error_condition( int ev ) const
        noexcept;
      inline virtual bool equivalent( int code,
                                           const error_condition & condition ) const
        noexcept;
      inline virtual bool equivalent( const error_code & code,
                                           int condition ) const noexcept;

      bool operator==(const error_category & rhs) const noexcept
        { return this == &rhs; }
      bool operator!=(const error_category & rhs) const noexcept
        { return this != &rhs; }
      bool operator<( const error_category & rhs ) const noexcept
        { return std::less<const error_category*>()( this, &rhs ); }
    };
# 346 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
    class error_condition
    {
    public:


      error_condition() noexcept : m_val(0), m_cat(&generic_category()) {}
      error_condition( int val, const error_category & cat ) noexcept
        : m_val(val), m_cat(&cat) {}

      template <class ErrorConditionEnum>
        error_condition(ErrorConditionEnum e,
          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type*
            = 0) noexcept
      {
        *this = make_error_condition(e);
      }



      void assign( int val, const error_category & cat ) noexcept
      {
        m_val = val;
        m_cat = &cat;
      }

      template<typename ErrorConditionEnum>
        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>,
          error_condition>::type &
          operator=( ErrorConditionEnum val ) noexcept
      {
        *this = make_error_condition(val);
        return *this;
      }

      void clear() noexcept
      {
        m_val = 0;
        m_cat = &generic_category();
      }


      int value() const noexcept { return m_val; }
      const error_category & category() const noexcept { return *m_cat; }
      std::string message() const { return m_cat->message(value()); }



      explicit operator bool() const noexcept
      {
        return m_val != 0;
      }
# 418 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
      inline friend bool operator==( const error_condition & lhs,
                                     const error_condition & rhs ) noexcept
      {
        return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
      }

      inline friend bool operator<( const error_condition & lhs,
                                    const error_condition & rhs ) noexcept


      {
        return lhs.m_cat < rhs.m_cat
          || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
      }



      operator std::error_condition () const noexcept
      {
        return std::error_condition( value(), category() );
      }



    private:
      int m_val;
      const error_category * m_cat;

    };
# 456 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
    class error_code
    {
    public:


      error_code() noexcept : m_val(0), m_cat(&system_category()) {}
      error_code( int val, const error_category & cat ) noexcept
        : m_val(val), m_cat(&cat) {}

      template <class ErrorCodeEnum>
        error_code(ErrorCodeEnum e,
          typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
          noexcept
      {
        *this = make_error_code(e);
      }


      void assign( int val, const error_category & cat ) noexcept
      {
        m_val = val;
        m_cat = &cat;
      }

      template<typename ErrorCodeEnum>
        typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
          operator=( ErrorCodeEnum val ) noexcept
      {
        *this = make_error_code(val);
        return *this;
      }

      void clear() noexcept
      {
        m_val = 0;
        m_cat = &system_category();
      }


      int value() const noexcept { return m_val; }
      const error_category & category() const noexcept { return *m_cat; }
      error_condition default_error_condition() const noexcept
        { return m_cat->default_error_condition(value()); }
      std::string message() const { return m_cat->message(value()); }



      explicit operator bool() const noexcept
      {
        return m_val != 0;
      }
# 526 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
      inline friend bool operator==( const error_code & lhs,
                                     const error_code & rhs ) noexcept


      {
        return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
      }

      inline friend bool operator<( const error_code & lhs,
                                    const error_code & rhs ) noexcept


      {
        return lhs.m_cat < rhs.m_cat
          || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
      }



      operator std::error_code () const noexcept
      {
        return std::error_code( value(), category() );
      }



    private:
      int m_val;
      const error_category * m_cat;

    };
# 567 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
  }

  namespace detail
  {







    inline system::error_code* throws()
    {
# 588 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 3 4
      return reinterpret_cast<system::error_code*>(8);
    }
  }

  inline system::error_code& throws()
    { return *detail::throws(); }

  namespace system
  {


    inline bool operator!=( const error_code & lhs,
                            const error_code & rhs ) noexcept
    {
      return !(lhs == rhs);
    }

    inline bool operator!=( const error_condition & lhs,
                            const error_condition & rhs ) noexcept
    {
      return !(lhs == rhs);
    }

    inline bool operator==( const error_code & code,
                            const error_condition & condition ) noexcept
    {
      return code.category().equivalent( code.value(), condition )
        || condition.category().equivalent( code, condition.value() );
    }

    inline bool operator!=( const error_code & lhs,
                            const error_condition & rhs ) noexcept
    {
      return !(lhs == rhs);
    }

    inline bool operator==( const error_condition & condition,
                            const error_code & code ) noexcept
    {
      return condition.category().equivalent( code, condition.value() )
        || code.category().equivalent( code.value(), condition );
    }

    inline bool operator!=( const error_condition & lhs,
                            const error_code & rhs ) noexcept
    {
      return !(lhs == rhs);
    }



    template <class charT, class traits>
    inline std::basic_ostream<charT,traits>&
      operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
    {
      os << ec.category().name() << ':' << ec.value();
      return os;
    }

    inline std::size_t hash_value( const error_code & ec )
    {
      return static_cast<std::size_t>(ec.value())
        + reinterpret_cast<std::size_t>(&ec.category());
    }



    namespace errc
    {

      inline error_code make_error_code( errc_t e ) noexcept
        { return error_code( e, generic_category() ); }


      inline error_condition make_error_condition( errc_t e ) noexcept
        { return error_condition( e, generic_category() ); }
    }



    error_condition error_category::default_error_condition( int ev ) const
      noexcept
    {
      return error_condition( ev, *this );
    }

    bool error_category::equivalent( int code,
      const error_condition & condition ) const noexcept
    {
      return default_error_condition( code ) == condition;
    }

    bool error_category::equivalent( const error_code & code,
      int condition ) const noexcept
    {
      return *this == code.category() && code.value() == condition;
    }



    inline std::error_condition error_category::std_category::default_error_condition(
      int ev ) const noexcept
    {
      return pc_->default_error_condition( ev );
    }

    inline bool error_category::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 error_category::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;
      }
    }



  }
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 764 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/error_code.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/system/system_error.hpp" 2 3 4

namespace boost
{
  namespace system
  {


    class __attribute__((__visibility__("default"))) system_error : public std::runtime_error


    {
    public:
      system_error( error_code ec )
          : std::runtime_error(""), m_error_code(ec) {}

      system_error( error_code ec, const std::string & what_arg )
          : std::runtime_error(what_arg), m_error_code(ec) {}

      system_error( error_code ec, const char* what_arg )
          : std::runtime_error(what_arg), m_error_code(ec) {}

      system_error( int ev, const error_category & ecat )
          : std::runtime_error(""), m_error_code(ev,ecat) {}

      system_error( int ev, const error_category & ecat,
        const std::string & what_arg )
          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}

      system_error( int ev, const error_category & ecat,
        const char * what_arg )
          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}

      virtual ~system_error() noexcept {}

      const error_code & code() const noexcept { return m_error_code; }
      const char * what() const noexcept;

    private:
      error_code m_error_code;
      mutable std::string m_what;
    };



    inline const char * system_error::what() const noexcept

    {
      if ( m_what.empty() )
      {

        try

        {
          m_what = this->std::runtime_error::what();
          if ( !m_what.empty() ) m_what += ": ";
          m_what += m_error_code.message();
        }

        catch (...) { return std::runtime_error::what(); }

      }
      return m_what.c_str();
    }

  }
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/exceptions.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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() throw()
        {}


        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() throw()
        {}

    };

    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() throw()
        {}

    };

    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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/exceptions.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/move.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/move.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/delete.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/move.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/move.hpp" 3 4
namespace boost
{
  namespace thread_detail
  {
# 311 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/move.hpp" 3 4
      template <class T>
      typename decay<T>::type
      decay_copy(T&& t)
      {
          return boost::forward<T>(t);
      }
# 367 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/move.hpp" 3 4
  }
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 371 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/move.hpp" 2 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_options.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_options.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_options.hpp" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lockable_traits.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lockable_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lockable_traits.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lockable_traits.hpp" 2 3 4



namespace boost
{
  namespace sync
  {
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lockable_traits.hpp" 3 4
    namespace detail
    {
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lockable_traits.hpp" 3 4
      template<typename T, bool=boost::is_class<T>::value> struct has_member_called_lock { static const bool value=false; }; template<typename T> struct has_member_called_lock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int lock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::lock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); }
; template<typename T, bool=boost::is_class<T>::value> struct has_member_called_unlock { static const bool value=false; }; template<typename T> struct has_member_called_unlock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int unlock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::unlock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); };
      template<typename T, bool=boost::is_class<T>::value> struct has_member_called_try_lock { static const bool value=false; }; template<typename T> struct has_member_called_try_lock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int try_lock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::try_lock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); };

      template<typename T,bool=has_member_called_lock<T>::value >
      struct has_member_lock
      {
        static const bool value=false;
      };

      template<typename T>
      struct has_member_lock<T,true>
      {
        typedef char true_type;
        struct false_type
        {
          true_type dummy[2];
        };

        template<typename U,typename V>
        static true_type has_member(V (U::*)());
        template<typename U>
        static false_type has_member(U);

        static const bool value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type)
                                                                                           ;
      };

      template<typename T,bool=has_member_called_unlock<T>::value >
      struct has_member_unlock
      {
        static const bool value=false;
      };

      template<typename T>
      struct has_member_unlock<T,true>
      {
        typedef char true_type;
        struct false_type
        {
          true_type dummy[2];
        };

        template<typename U,typename V>
        static true_type has_member(V (U::*)());
        template<typename U>
        static false_type has_member(U);

        static const bool value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type)
                                                                                               ;
      };

      template<typename T,bool=has_member_called_try_lock<T>::value >
      struct has_member_try_lock
      {
        static const bool value=false;
      };

      template<typename T>
      struct has_member_try_lock<T,true>
      {
        typedef char true_type;
        struct false_type
        {
          true_type dummy[2];
        };

        template<typename U>
        static true_type has_member(bool (U::*)());
        template<typename U>
        static false_type has_member(U);

        static const bool value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(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

                                                ;
    };
# 175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 206 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lockable_traits.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/thread_time.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/thread_time.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_clock.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_clock.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/c_time.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/c_time.hpp" 3 4
# 1 "/usr/include/c++/10/ctime" 1 3 4
# 39 "/usr/include/c++/10/ctime" 3 4
       
# 40 "/usr/include/c++/10/ctime" 3
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/c_time.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/locale_config.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 2 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 2 3 4
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/auto_link.hpp" 1 3 4
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/compiler_config.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/c_time.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/c_time.hpp" 3 4
namespace boost {
namespace date_time {
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
      }
# 120 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/c_time.hpp" 3 4
  };
}}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/thread_time.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/microsec_time_clock.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/microsec_time_clock.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/microsec_time_clock.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/microsec_time_clock.hpp" 3 4
namespace boost {
namespace date_time {
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/microsec_time_clock.hpp" 3 4
  };


} }
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/thread_time.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/ptime.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/ptime.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_duration.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_duration.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_duration.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/special_defs.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_defs.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/operators.hpp" 1 3 4
# 116 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
     friend bool operator>(const U& x, const T& y) { return y < x; }
     friend bool operator<(const U& x, const T& y) { return y > x; }
     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
     friend 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 bool operator>(const T& x, const T& y) { return y < x; }
     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
     friend 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 bool operator==(const U& y, const T& x) { return x == y; }
     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
     friend 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 bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
};
# 259 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
  }
};
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 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 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 bool operator<=(const T& x, const U& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend bool operator>=(const T& x, const U& y)
    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
  friend bool operator>(const U& x, const T& y)
    { return y < x; }
  friend bool operator<(const U& x, const T& y)
    { return y > x; }
  friend bool operator<=(const U& x, const T& y)
    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
  friend 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 bool operator>(const T& x, const T& y)
    { return y < x; }
  friend bool operator<=(const T& x, const T& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend 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
      > > > > {};
# 662 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/operators.hpp" 3 4
namespace operators_detail
{



struct true_t {};
struct false_t {};

}
# 679 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/operators.hpp" 3 4
template<class T> struct is_chained_base {
  typedef operators_detail::false_t value;
};
# 757 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_duration.hpp" 2 3 4



namespace boost {
namespace date_time {
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

    time_duration() : ticks_(0) {}
    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))
    {}


    time_duration(const time_duration<T, rep_type>& other)
      : ticks_(other.ticks_)
    {}

    time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
    {}

    static duration_type unit()
    {
      return duration_type(0,0,0,1);
    }

    static tick_type ticks_per_second()
    {
      return rep_type::res_adjust();
    }

    static time_resolutions resolution()
    {
      return rep_type::resolution();
    }

    hour_type hours() const
    {
      return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
    }

    min_type minutes() const
    {
      return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
    }

    sec_type seconds() const
    {
      return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
    }

    sec_type total_seconds() const
    {
      return static_cast<sec_type>(ticks() / ticks_per_second());
    }

    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)) ;
    }

    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)) ;
    }

    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)) ;
    }

    fractional_seconds_type fractional_seconds() const
    {
      return (ticks() % ticks_per_second());
    }

    static unsigned short num_fractional_digits()
    {
      return rep_type::num_fractional_digits();
    }
    duration_type invert_sign() const
    {
      return duration_type(ticks_ * (-1));
    }
    bool is_negative() const
    {
      return ticks_ < 0;
    }
    bool operator<(const time_duration& rhs) const
    {
      return ticks_ < rhs.ticks_;
    }
    bool operator==(const time_duration& rhs) const
    {
      return ticks_ == rhs.ticks_;
    }

    duration_type operator-()const
    {
      return duration_type(ticks_ * (-1));
    }
    duration_type operator-(const duration_type& d) const
    {
      return duration_type(ticks_ - d.ticks_);
    }
    duration_type operator+(const duration_type& d) const
    {
      return duration_type(ticks_ + d.ticks_);
    }
    duration_type operator/(int divisor) const
    {
      return duration_type(ticks_ / divisor);
    }
    duration_type operator-=(const duration_type& d)
    {
      ticks_ = ticks_ - d.ticks_;
      return duration_type(ticks_);
    }
    duration_type operator+=(const duration_type& d)
    {
      ticks_ = ticks_ + d.ticks_;
      return duration_type(ticks_);
    }

    duration_type operator/=(int divisor)
    {
      ticks_ = ticks_ / divisor;
      return duration_type(ticks_);
    }

    duration_type operator*(int rhs) const
    {
      return duration_type(ticks_ * rhs);
    }
    duration_type operator*=(int divisor)
    {
      ticks_ = ticks_ * divisor;
      return duration_type(ticks_);
    }
    tick_type ticks() const
    {
      return traits_type::as_number(ticks_);
    }


    bool is_special()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_special();
      }
      else{
        return false;
      }
    }

    bool is_pos_infinity()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_pos_infinity();
      }
      else{
        return false;
      }
    }

    bool is_neg_infinity()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_neg_infinity();
      }
      else{
        return false;
      }
    }

    bool is_not_a_date_time()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_nan();
      }
      else{
        return false;
      }
    }


    impl_type get_rep()const
    {
      return ticks_;
    }

  protected:
    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>
    explicit subsecond_duration(T const& ss,
                                typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
      base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
    {
    }
  };

} }
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_resolution_traits.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_resolution_traits.hpp" 3 4
# 1 "/usr/include/c++/10/ctime" 1 3 4
# 39 "/usr/include/c++/10/ctime" 3 4
       
# 40 "/usr/include/c++/10/ctime" 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_resolution_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_resolution_traits.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/int_adapter.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/int_adapter.hpp" 3 4
namespace boost {
namespace date_time {
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/int_adapter.hpp" 3 4
template<typename int_type_>
class int_adapter {
public:
  typedef int_type_ int_type;
  int_adapter(int_type v) :
    value_(v)
  {}
  static bool has_infinity()
  {
    return true;
  }
  static const int_adapter pos_infinity()
  {
    return (::std::numeric_limits<int_type>::max)();
  }
  static const int_adapter neg_infinity()
  {
    return (::std::numeric_limits<int_type>::min)();
  }
  static const int_adapter not_a_number()
  {
    return (::std::numeric_limits<int_type>::max)()-1;
  }
  static int_adapter max ()
  {
    return (::std::numeric_limits<int_type>::max)()-2;
  }
  static int_adapter min ()
  {
    return (::std::numeric_limits<int_type>::min)()+1;
  }
  static 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 bool is_inf(int_type v)
  {
    return (v == neg_infinity().as_number() ||
            v == pos_infinity().as_number());
  }
  static bool is_neg_inf(int_type v)
  {
    return (v == neg_infinity().as_number());
  }
  static bool is_pos_inf(int_type v)
  {
    return (v == pos_infinity().as_number());
  }
  static bool is_not_a_number(int_type v)
  {
    return (v == not_a_number().as_number());
  }

  static 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 int_type maxcount()
  {
    return (::std::numeric_limits<int_type>::max)()-3;
  }
  bool is_infinity() const
  {
    return (value_ == neg_infinity().as_number() ||
            value_ == pos_infinity().as_number());
  }
  bool is_pos_infinity()const
  {
    return(value_ == pos_infinity().as_number());
  }
  bool is_neg_infinity()const
  {
    return(value_ == neg_infinity().as_number());
  }
  bool is_nan() const
  {
    return (value_ == not_a_number().as_number());
  }
  bool is_special() const
  {
    return(is_infinity() || is_nan());
  }
  bool operator==(const int_adapter& rhs) const
  {
    return (compare(rhs) == 0);
  }
  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);
  }
  bool operator!=(const int_adapter& rhs) const
  {
    return (compare(rhs) != 0);
  }
  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);
  }
  bool operator<(const int_adapter& rhs) const
  {
    return (compare(rhs) == -1);
  }
  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);
  }
  bool operator>(const int_adapter& rhs) const
  {
    return (compare(rhs) == 1);
  }
  int_type as_number() const
  {
    return value_;
  }

  special_values as_special() const
  {
    return int_adapter::to_special(value_);
  }
# 206 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/int_adapter.hpp" 3 4
  template<class rhs_type>
  inline
  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()));
  }

  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>
  inline
  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()));
  }
  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);
  }


  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_);
  }


  int_adapter operator*(const int rhs) const
  {
    if(is_special())
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ * rhs);
  }


  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_);
  }


  int_adapter operator/(const int rhs) const
  {
    if(is_special() && rhs != 0)
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ / rhs);
  }


  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_);
  }


  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_;


  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;
  }





  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());
  }






  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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_resolution_traits.hpp" 2 3 4


namespace boost {
namespace date_time {


  template <typename T>


  inline 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 int_type as_number(impl_type i){ return i;}

    static 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 int_type as_number(impl_type i){ return i.as_number();}

    static bool is_adapted() { return true;}
  };

  struct time_resolution_traits_bi64_impl {
    typedef boost::int64_t int_type;
    typedef boost::int64_t impl_type;
    static int_type as_number(impl_type i){ return i;}

    static 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 int_type as_number(impl_type i){ return i.as_number();}

    static bool is_adapted() { return true;}
  };
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 fractional_seconds_type as_number(impl_type i)
    {
      return frac_sec_type::as_number(i);
    }
    static bool is_adapted()
    {
      return frac_sec_type::is_adapted();
    }





    static const fractional_seconds_type ticks_per_second = resolution_adjust;


    static time_resolutions resolution()
    {
      return res;
    }
    static unsigned short num_fractional_digits()
    {
      return frac_digits;
    }
    static fractional_seconds_type res_adjust()
    {
      return resolution_adjust;
    }

    static 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/year_month_day.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 {
    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
  year_month_day_base<YearType,MonthType,DayType>::year_month_day_base(YearType y,
                                                                       MonthType m,
                                                                       DayType d) :
    year(y),
    month(m),
    day(d)
  {}

} }
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date.hpp" 2 3 4


namespace boost {
namespace date_time {
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
    date(year_type y, month_type m, day_type d)
      : days_(calendar::day_number(ymd_type(y, m, d)))
    {}
    date(const ymd_type& ymd)
      : days_(calendar::day_number(ymd))
    {}

    year_type year() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.year;
    }
    month_type month() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.month;
    }
    day_type day() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.day;
    }
    day_of_week_type day_of_week() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return calendar::day_of_week(ymd);
    }
    ymd_type year_month_day() const
    {
      return calendar::from_day_number(days_);
    }
    bool operator<(const date_type& rhs) const
    {
      return days_ < rhs.days_;
    }
    bool operator==(const date_type& rhs) const
    {
      return days_ == rhs.days_;
    }

    bool is_special()const
    {
      return(is_not_a_date() || is_infinity());
    }

    bool is_not_a_date() const
    {
      return traits_type::is_not_a_number(days_);
    }

    bool is_infinity() const
    {
      return traits_type::is_inf(days_);
    }

    bool is_pos_infinity() const
    {
      return traits_type::is_pos_inf(days_);
    }

    bool is_neg_infinity() const
    {
      return traits_type::is_neg_inf(days_);
    }

    special_values as_special() const
    {
      return traits_type::to_special(days_);
    }
    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());
      }
    }

    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()));
    }
    date_type operator-=(const duration_type& dd)
    {
      *this = *this - dd;
      return date_type(days_);
    }
    date_rep_type day_count() const
    {
      return days_;
    }

    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()));
    }
    date_type operator+=(const duration_type& dd)
    {
      *this = *this + dd;
      return date_type(days_);
    }


  protected:




    explicit date(date_int_type days) : days_(days) {}
    explicit date(date_rep_type days) : days_(days.as_number()) {}
    date_int_type days_;

  };




} }
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 3 4
namespace boost {
namespace date_time {
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

    period(point_rep first_point, point_rep end_point);
    period(point_rep first_point, duration_rep len);
    point_rep begin() const;
    point_rep end() const;
    point_rep last() const;
    duration_rep length() const;
    bool is_null() const;
    bool operator==(const period& rhs) const;
    bool operator<(const period& rhs) const;
    void shift(const duration_rep& d);
    void expand(const duration_rep& d);
    bool contains(const point_rep& point) const;
    bool contains(const period& other) const;
    bool intersects(const period& other) const;
    bool is_adjacent(const period& other) const;
    bool is_before(const point_rep& point) const;
    bool is_after(const point_rep& point) const;
    period intersection(const period& other) const;
    period merge(const period& other) const;
    period span(const period& other) const;
  private:
    point_rep begin_;
    point_rep last_;
  };




  template<class point_rep, class duration_rep>
  inline
  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
  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
  point_rep period<point_rep,duration_rep>::begin() const
  {
    return begin_;
  }


  template<class point_rep, class duration_rep>
  inline
  point_rep period<point_rep,duration_rep>::end() const
  {
    return last_ + duration_rep::unit();
  }


  template<class point_rep, class duration_rep>
  inline
  point_rep period<point_rep,duration_rep>::last() const
  {
    return last_;
  }


  template<class point_rep, class duration_rep>
  inline
  bool period<point_rep,duration_rep>::is_null() const
  {
    return end() <= begin_;
  }


  template<class point_rep, class duration_rep>
  inline
  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
  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
  bool period<point_rep,duration_rep>::operator<(const period& rhs) const
  {
    return (last_ < rhs.begin_);
  }



  template<class point_rep, class duration_rep>
  inline
  void period<point_rep,duration_rep>::shift(const duration_rep& d)
  {
    begin_ = begin_ + d;
    last_ = last_ + d;
  }
# 199 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  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
  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
  bool period<point_rep,duration_rep>::contains(const period<point_rep,duration_rep>& other) const
  {
    return ((begin_ <= other.begin_) && (last_ >= other.last_));
  }
# 235 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  bool
  period<point_rep,duration_rep>::is_adjacent(const period<point_rep,duration_rep>& other) const
  {
    return (other.begin() == end() ||
            begin_ == other.end());
  }
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  bool
  period<point_rep,duration_rep>::is_after(const point_rep& t) const
  {
    if (is_null())
    {
      return false;
    }

    return t < begin_;
  }
# 276 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  bool
  period<point_rep,duration_rep>::is_before(const point_rep& t) const
  {
    if (is_null())
    {
      return false;
    }

    return last_ < t;
  }
# 301 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  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
  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
  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_);
  }
# 363 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_weekday.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_weekday.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/constrained_value.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/constrained_value.hpp" 3 4
namespace boost {


namespace CV {

  enum violation_enum {min_violation, max_violation};
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

    constrained_value(value_type value) : value_((min)())
    {
      assign(value);
    }
    constrained_value& operator=(value_type v)
    {
      assign(v);
      return *this;
    }

    static value_type max () {return (value_policies::max)();}

    static value_type min () {return (value_policies::min)();}

    operator value_type() const {return value_;}
  protected:
    value_type value_;
  private:
    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 mpl::if_<
      is_base_of< std::exception, exception_type >,
      exception_type,
      exception_wrapper
    >::type actual_exception_type;

  public:
    typedef rep_type value_type;
    static rep_type min () { return min_value; }
    static rep_type max () { return max_value; }
    static void on_error(rep_type, rep_type, violation_enum)
    {
      boost::throw_exception(actual_exception_type());
    }
  };



} }
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date_defs.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 greg_weekday : public greg_weekday_rep {
  public:
    typedef boost::date_time::weekdays weekday_enum;
    greg_weekday(value_type day_of_week_num) :
      greg_weekday_rep(day_of_week_num)
    {}

    value_type as_number() const {return value_;}
    const char* as_short_string() const;
    const char* as_long_string() const;

    const wchar_t* as_short_wstring() const;
    const wchar_t* as_long_wstring() const;

    weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}


  };



} }
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_day_of_year.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian_calendar.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian_calendar.hpp" 3 4
namespace boost {
namespace date_time {
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 unsigned short day_of_week(const ymd_type& ymd);
    static int week_number(const ymd_type&ymd);

    static date_int_type day_number(const ymd_type& ymd);
    static date_int_type julian_day_number(const ymd_type& ymd);
    static date_int_type modjulian_day_number(const ymd_type& ymd);
    static ymd_type from_day_number(date_int_type);
    static ymd_type from_julian_day_number(date_int_type);
    static ymd_type from_modjulian_day_number(date_int_type);
    static bool is_leap_year(year_type);
    static unsigned short end_of_month_day(year_type y, month_type m);
    static ymd_type epoch();
    static unsigned short days_in_week();

  };



} }


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian_calendar.ipp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian_calendar.ipp" 3 4
namespace boost {
namespace date_time {



  template<typename ymd_type_, typename date_int_type_>
  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_>
  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_>
  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 = 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_>
  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_>
  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_>
  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_>
  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_>
  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_>
  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_>
  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_>
  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_>
  inline
  unsigned short
  gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
  {
    return 7;
  }


} }
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian_calendar.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_day.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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:
    greg_day(value_type day_of_month) : greg_day_rep(day_of_month) {}
    value_type as_number() const {return value_;}
    operator value_type() const {return value_;}
  private:

  };



} }
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_year.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_year.hpp" 3 4
  class __attribute__((__visibility__("default"))) greg_year : public greg_year_rep {
  public:
    greg_year(value_type year) : greg_year_rep(year) {}
    operator value_type() const {return value_;}
  };



} }
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_month.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_month.hpp" 3 4
# 1 "/usr/include/c++/10/cctype" 1 3 4
# 39 "/usr/include/c++/10/cctype" 3 4
       
# 40 "/usr/include/c++/10/cctype" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_month.hpp" 2 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 greg_month : public greg_month_rep {
  public:
    typedef date_time::months_of_year month_enum;
    typedef std::map<std::string, unsigned short> month_map_type;
    typedef boost::shared_ptr<month_map_type> month_map_ptr_type;

    greg_month(month_enum theMonth) :
      greg_month_rep(static_cast<greg_month_rep::value_type>(theMonth)) {}

    greg_month(value_type theMonth) : greg_month_rep(theMonth) {}

    operator value_type() const {return value_;}

    value_type as_number() const {return value_;}
    month_enum as_enum() const {return static_cast<month_enum>(value_);}
    const char* as_short_string() const;
    const char* as_long_string() const;

    const wchar_t* as_short_wstring() const;
    const wchar_t* as_long_wstring() const;


    static month_map_ptr_type get_month_map_ptr();



    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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_duration.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_duration.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date_duration.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;


    explicit date_duration(duration_rep day_count) : days_(day_count) {}



    date_duration(special_values sv) :
            days_(duration_rep::from_special(sv))
    {}



    date_duration(const date_duration<duration_rep_traits>& other) :
            days_(other.days_)
    {}


    duration_rep get_rep()const
    {
        return days_;
    }
    special_values as_special() const
    {
        return days_.as_special();
    }
    bool is_special()const
    {
        return days_.is_special();
    }

    duration_rep_type days() const
    {
        return duration_rep_traits::as_number(days_);
    }

    static date_duration unit()
    {
        return date_duration<duration_rep_traits>(1);
    }

    bool operator==(const date_duration& rhs) const
    {
        return days_ == rhs.days_;
    }

    bool operator<(const date_duration& rhs) const
    {
        return days_ < rhs.days_;
    }







    date_duration& operator-=(const date_duration& rhs)
    {

        days_ = days_ - rhs.days_;
        return *this;
    }

    date_duration& operator+=(const date_duration& rhs)
    {
        days_ = days_ + rhs.days_;
        return *this;
    }


    date_duration operator-() const
    {
        return date_duration<duration_rep_traits>(get_rep() * (-1));
    }

    date_duration& operator/=(int divisor)
    {
        days_ = days_ / divisor;
        return *this;
    }


    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 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 int_type as_number(impl_type i) { return i.as_number(); }
  };


} }
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;


    explicit date_duration(duration_rep day_count = 0) : base_type(day_count) {}


    date_duration(date_time::special_values sv) : base_type(sv) {}


    date_duration(const date_duration& other) : base_type(static_cast< base_type const& >(other))
    {}


    date_duration(const base_type& other) : base_type(other)
    {}





    bool operator== (const date_duration& rhs) const
    {
      return base_type::operator== (rhs);
    }
    bool operator!= (const date_duration& rhs) const
    {
      return !operator== (rhs);
    }
    bool operator< (const date_duration& rhs) const
    {
      return base_type::operator< (rhs);
    }
    bool operator> (const date_duration& rhs) const
    {
      return !(base_type::operator< (rhs) || base_type::operator== (rhs));
    }
    bool operator<= (const date_duration& rhs) const
    {
      return (base_type::operator< (rhs) || base_type::operator== (rhs));
    }
    bool operator>= (const date_duration& rhs) const
    {
      return !base_type::operator< (rhs);
    }


    date_duration& operator-= (const date_duration& rhs)
    {
      base_type::operator-= (rhs);
      return *this;
    }
    friend date_duration operator- (date_duration rhs, date_duration const& lhs)
    {
      rhs -= lhs;
      return rhs;
    }


    date_duration& operator+= (const date_duration& rhs)
    {
      base_type::operator+= (rhs);
      return *this;
    }
    friend date_duration operator+ (date_duration rhs, date_duration const& lhs)
    {
      rhs += lhs;
      return rhs;
    }


    date_duration operator- ()const
    {
      return date_duration(get_rep() * (-1));
    }


    date_duration& operator/= (int divisor)
    {
      base_type::operator/= (divisor);
      return *this;
    }
    friend date_duration operator/ (date_duration rhs, int lhs)
    {
      rhs /= lhs;
      return rhs;
    }


    static date_duration unit()
    {
      return date_duration(base_type::unit().get_rep());
    }
  };


  typedef date_duration days;

} }


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date_duration_types.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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:
    weeks_duration(typename duration_config::impl_type w)
      : date_duration<duration_config>(w * 7) {}
    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:
      months_duration(int_rep num) : _m(num) {}
      months_duration(special_values sv) : _m(sv)
      {
        _m = int_rep::from_special(sv);
      }
      int_rep number_of_months() const { return _m; }

      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));
      }
      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));
      }
      bool operator==(const months_type& rhs) const
      {
        return(_m == rhs._m);
      }
      bool operator!=(const months_type& rhs) const
      {
        return(_m != rhs._m);
      }
      months_type operator+(const months_type& rhs)const
      {
        return months_type(_m + rhs._m);
      }
      months_type& operator+=(const months_type& rhs)
      {
        _m = _m + rhs._m;
        return *this;
      }
      months_type operator-(const months_type& rhs)const
      {
        return months_type(_m - rhs._m);
      }
      months_type& operator-=(const months_type& rhs)
      {
        _m = _m - rhs._m;
        return *this;
      }
      months_type operator*(const int_type rhs)const
      {
        return months_type(_m * rhs);
      }
      months_type& operator*=(const int_type rhs)
      {
        _m = _m * rhs;
        return *this;
      }
      months_type operator/(const int_type rhs)const
      {
        return months_type(_m / rhs);
      }
      months_type& operator/=(const int_type rhs)
      {
        _m = _m / rhs;
        return *this;
      }
      months_type operator+(const years_type& y)const
      {
        return months_type(y.number_of_years() * 12 + _m);
      }
      months_type& operator+=(const years_type& y)
      {
        _m = y.number_of_years() * 12 + _m;
        return *this;
      }
      months_type operator-(const years_type& y) const
      {
        return months_type(_m - y.number_of_years() * 12);
      }
      months_type& operator-=(const years_type& y)
      {
        _m = _m - y.number_of_years() * 12;
        return *this;
      }


      friend date_type operator+(const date_type& d, const months_type& m)
      {
        return d + m.get_offset(d);
      }
      friend date_type operator+=(date_type& d, const months_type& m)
      {
        return d += m.get_offset(d);
      }
      friend date_type operator-(const date_type& d, const months_type& m)
      {

        return d + m.get_neg_offset(d);
      }
      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:
      years_duration(int_rep num) : _y(num) {}
      years_duration(special_values sv) : _y(sv)
      {
        _y = int_rep::from_special(sv);
      }
      int_rep number_of_years() const { return _y; }

      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));
      }
      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));
      }
      bool operator==(const years_type& rhs) const
      {
        return(_y == rhs._y);
      }
      bool operator!=(const years_type& rhs) const
      {
        return(_y != rhs._y);
      }
      years_type operator+(const years_type& rhs)const
      {
        return years_type(_y + rhs._y);
      }
      years_type& operator+=(const years_type& rhs)
      {
        _y = _y + rhs._y;
        return *this;
      }
      years_type operator-(const years_type& rhs)const
      {
        return years_type(_y - rhs._y);
      }
      years_type& operator-=(const years_type& rhs)
      {
        _y = _y - rhs._y;
        return *this;
      }
      years_type operator*(const int_type rhs)const
      {
        return years_type(_y * rhs);
      }
      years_type& operator*=(const int_type rhs)
      {
        _y = _y * rhs;
        return *this;
      }
      years_type operator/(const int_type rhs)const
      {
        return years_type(_y / rhs);
      }
      years_type& operator/=(const int_type rhs)
      {
        _y = _y / rhs;
        return *this;
      }
      months_type operator+(const months_type& m) const
      {
        return(months_type(_y * 12 + m.number_of_months()));
      }
      months_type operator-(const months_type& m) const
      {
        return(months_type(_y * 12 - m.number_of_months()));
      }


      friend date_type operator+(const date_type& d, const years_type& y)
      {
        return d + y.get_offset(d);
      }
      friend date_type operator+=(date_type& d, const years_type& y)
      {
        return d += y.get_offset(d);
      }
      friend date_type operator-(const date_type& d, const years_type& y)
      {

        return d + y.get_neg_offset(d);
      }
      friend date_type operator-=(date_type& d, const years_type& y)
      {

        return d += y.get_neg_offset(d);
      }

    private:
      int_rep _y;
  };

}}
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_duration_types.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_duration_types.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_date.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;


    date():
      date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(not_a_date_time))
    {}


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

    explicit date(const ymd_type& ymd)
      : date_time::date<date, gregorian_calendar, date_duration>(ymd)
    {}

    explicit date(const date_int_type& rhs):
      date_time::date<date,gregorian_calendar, date_duration>(rhs)
    {}

    explicit date(date_rep_type rhs):
      date_time::date<date,gregorian_calendar, date_duration>(rhs)
    {}

    explicit date(special_values sv):
      date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(sv))
    {
      if (sv == min_date_time)
      {
        *this = date(1400, 1, 1);
      }
      if (sv == max_date_time)
      {
        *this = date(9999, 12, 31);
      }

    }

    date_int_type julian_day() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::julian_day_number(ymd);
    }

    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);
    }

    date_int_type modjulian_day() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::modjulian_day_number(ymd);
    }

    int week_number() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::week_number(ymd);
    }

    date_int_type day_number() const
    {
      return days_;
    }

    date end_of_month() const
    {
      ymd_type ymd = year_month_day();
      short eom_day = gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
      return date(ymd.year, ymd.month, eom_day);
    }

   private:

  };



} }
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/adjust_functors.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/adjust_functors.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/wrapping_int.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/wrapping_int.hpp" 3 4
namespace boost {
namespace date_time {
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 int_type wrap_value() {return wrap_val;}

  wrapping_int(int_type v) : value_(v) {}

  int_type as_int() const {return value_;}
  operator int_type() const {return value_;}





  template< typename IntT >
  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 >
  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 >
  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 int_type wrap_value() {return wrap_max;}
  static int_type min_value() {return wrap_min;}


  wrapping_int2(int_type v) : value_(v) {
    if(value_ < wrap_min)
    {
      value_ = wrap_min;
    }
    if(value_ > wrap_max)
    {
      value_ = wrap_max;
    }
  }

  int_type as_int() const {return value_;}
  operator int_type() const {return value_;}





  template< typename IntT >
  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 >
  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 >
  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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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:
    weeks_duration(duration_rep w)
      : date_duration(w * 7) {}
    weeks_duration(date_time::special_values sv)
      : date_duration(sv) {}
  };

  typedef weeks_duration weeks;

}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date_generators.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date_generators.hpp" 3 4
   date_type get_date(year_type y) const
   {
     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_;
   }






   virtual std::string to_string() const
   {
     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_;
 };



  const char* nth_as_str(int n);
# 177 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
    {
      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_);
    }


    virtual std::string to_string() const
    {
     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
    {
      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_;
    }


    virtual std::string to_string() const
    {
     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_;
  };
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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
    {
      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_;
    }


    virtual std::string to_string() const
    {
      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_;
   };
# 375 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_;
  };
# 413 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date_clock_device.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/date_iterator.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
    date_type operator*() {return current_;}
    date_type* operator->() {return &current_;}
    bool operator< (const date_type& d) {return current_ < d;}
    bool operator<= (const date_type& d) {return current_ <= d;}
    bool operator> (const date_type& d) {return current_ > d;}
    bool operator>= (const date_type& d) {return current_ >= d;}
    bool operator== (const date_type& d) {return current_ == d;}
    bool operator!= (const date_type& d) {return current_ != d;}
  private:
    date_type current_;
  };
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4



namespace boost {
namespace posix_time {
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
  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;
    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)
    {}
    time_duration() :
      date_time::time_duration<time_duration, time_res_traits>(0,0,0)
    {}

    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:
    explicit time_duration(impl_type tick_count) :
      date_time::time_duration<time_duration, time_res_traits>(tick_count)
    {}
  };
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_system_split.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_system_split.hpp" 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 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 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 date_type get_date(const time_rep_type& val)
    {
      return date_type(val.day);
    }
    static 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 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 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 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 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 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 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 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_system_counted.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

    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();
      }
    }
    explicit counted_time_rep(int_type count) :
      time_count_(count)
    {}
    explicit counted_time_rep(impl_type count) :
      time_count_(count)
    {}
    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);
      }
    }

    unsigned long day_count() const
    {
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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());
    }
    int_type time_count() const
    {
      return resolution_traits::as_number(time_count_);
    }
    int_type tod() const
    {
      return resolution_traits::as_number(time_count_) % frac_sec_per_day();
    }
    static 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;
    }
    bool is_pos_infinity()const
    {
      return impl_type::is_pos_inf(time_count_.as_number());
    }
    bool is_neg_infinity()const
    {
      return impl_type::is_neg_inf(time_count_.as_number());
    }
    bool is_not_a_date_time()const
    {
      return impl_type::is_not_a_number(time_count_.as_number());
    }
    bool is_special()const
    {
      return time_count_.is_special();
    }
    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 void unused_var(const T&) {}

    static 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 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 date_type get_date(const time_rep_type& val)
    {
      return val.date();
    }
    static 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 bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return (lhs.time_count() == rhs.time_count());
    }
    static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return (lhs.time_count() < rhs.time_count());
    }
    static 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 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 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 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 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4



namespace boost {
namespace posix_time {
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/ptime.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time.hpp" 3 4
namespace boost {
namespace date_time {
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;


    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))
    {}
    base_time(special_values sv) :
      time_(time_system::get_time_rep(sv))
    {}
    base_time(const time_rep_type& rhs) :
      time_(rhs)
    {}
    date_type date() const
    {
      return time_system::get_date(time_);
    }
    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();
    }


    bool is_not_a_date_time() const
    {
      return time_.is_not_a_date_time();
    }

    bool is_infinity() const
    {
      return (is_pos_infinity() || is_neg_infinity());
    }

    bool is_pos_infinity() const
    {
      return time_.is_pos_infinity();
    }

    bool is_neg_infinity() const
    {
      return time_.is_neg_infinity();
    }

    bool is_special() const
    {
      return(is_not_a_date_time() || is_infinity());
    }

    bool operator==(const time_type& rhs) const
    {
      return time_system::is_equal(time_,rhs.time_);
    }

    bool operator<(const time_type& rhs) const
    {
      return time_system::is_less(time_,rhs.time_);
    }

    time_duration_type operator-(const time_type& rhs) const
    {
      return time_system::subtract_times(time_, rhs.time_);
    }

    time_type operator+(const date_duration_type& dd) const
    {
      return time_system::add_days(time_, dd);
    }
    time_type operator+=(const date_duration_type& dd)
    {
      time_ = (time_system::get_time_rep(date() + dd, time_of_day()));
      return time_type(time_);
    }

    time_type operator-(const date_duration_type& dd) const
    {
      return time_system::subtract_days(time_, dd);
    }
    time_type operator-=(const date_duration_type& dd)
    {
      time_ = (time_system::get_time_rep(date() - dd, time_of_day()));
      return time_type(time_);
    }

    time_type operator+(const time_duration_type& td) const
    {
      return time_type(time_system::add_time_duration(time_, td));
    }
    time_type operator+=(const time_duration_type& td)
    {
      time_ = (time_system::get_time_rep(date(), time_of_day() + td));
      return time_type(time_);
    }

    time_type operator-(const time_duration_type& rhs) const
    {
      return time_system::subtract_time_duration(time_, rhs);
    }
    time_type operator-=(const time_duration_type& td)
    {
      time_ = (time_system::get_time_rep(date(), time_of_day() - td));
      return time_type(time_);
    }

  protected:
    time_rep_type time_;
  };





} }
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;

    ptime(gregorian::date d,time_duration_type td) : date_time::base_time<time_type,time_system_type>(d,td)
    {}

    explicit ptime(gregorian::date d) : date_time::base_time<time_type,time_system_type>(d,time_duration_type(0,0,0))
    {}

    ptime(const time_rep_type& rhs):
      date_time::base_time<time_type,time_system_type>(rhs)
    {}

    ptime(const special_values sv) : date_time::base_time<time_type,time_system_type>(sv)
    {}


    ptime() : date_time::base_time<time_type,time_system_type>(gregorian::date(not_a_date_time), time_duration_type(not_a_date_time))
    {}


  };



} }
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/date_duration_operators.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
namespace boost {
namespace posix_time {
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
  inline
  ptime
  operator+(const ptime& t, const boost::gregorian::months& m)
  {
    return t + m.get_offset(t.date());
  }




  inline
  ptime
  operator+=(ptime& t, const boost::gregorian::months& m)
  {

    return t += m.get_offset(t.date());
  }




  inline
  ptime
  operator-(const ptime& t, const boost::gregorian::months& m)
  {

    return t + m.get_neg_offset(t.date());
  }




  inline
  ptime
  operator-=(ptime& t, const boost::gregorian::months& m)
  {
    return t += m.get_neg_offset(t.date());
  }






  inline
  ptime
  operator+(const ptime& t, const boost::gregorian::years& y)
  {
    return t + y.get_offset(t.date());
  }




  inline
  ptime
  operator+=(ptime& t, const boost::gregorian::years& y)
  {
    return t += y.get_offset(t.date());
  }




  inline
  ptime
  operator-(const ptime& t, const boost::gregorian::years& y)
  {

    return t + y.get_neg_offset(t.date());
  }




  inline
  ptime
  operator-=(ptime& t, const boost::gregorian::years& y)
  {

    return t += y.get_neg_offset(t.date());
  }

}}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_duration.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/cast.hpp" 1 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/cast.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/converter.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/converter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/conversion_traits.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/conversion_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/conversion_traits.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/conversion_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/meta.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/meta.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/equal_to.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/equal_to.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    >
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;
    };
};
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template< typename T > struct equal_to_tag
{
    typedef typename T::tag type;
};
# 241 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
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
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
{
# 278 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
   

};

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> { }; }

}}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 3 4
namespace boost { namespace mpl {
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/comparison_op.hpp" 3 4
template<>
struct equal_to_impl<integral_c_tag,integral_c_tag>
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value == N2::value ) >
    {





    };
};



}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/equal_to.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/meta.hpp" 3 4
   };
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/int_float_mixture_enum.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<int_float_mixture_enum, integral_to_integral> int2int_c ;
  typedef mpl::integral_c<int_float_mixture_enum, integral_to_float> int2float_c ;
  typedef mpl::integral_c<int_float_mixture_enum, float_to_integral> float2int_c ;
  typedef mpl::integral_c<int_float_mixture_enum, float_to_float> float2float_c ;







  template<class T,class S>
  struct get_int_float_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_integer > S_int ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_integer > T_int ;

    typedef typename
      for_both<S_int, T_int, int2int_c, int2float_c, float2int_c, float2float_c>::type
        type ;
  } ;
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/sign_mixture.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/sign_mixture.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/sign_mixture_enum.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/sign_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
  typedef mpl::integral_c<sign_mixture_enum, signed_to_signed> sig2sig_c ;
  typedef mpl::integral_c<sign_mixture_enum, signed_to_unsigned> sig2unsig_c ;
  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_signed> unsig2sig_c ;







  template<class T,class S>
  struct get_sign_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_signed > S_signed ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_signed > T_signed ;

    typedef typename
      for_both<S_signed, T_signed, sig2sig_c, sig2unsig_c, unsig2sig_c, unsig2unsig_c>::type
        type ;
  } ;
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_udt> builtin2udt_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_builtin> udt2builtin_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_udt> udt2udt_c ;
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/is_subranged.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/multiplies.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/multiplies.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/times.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/times.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    >
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;
    };
};
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template< typename T > struct times_tag
{
    typedef typename T::tag type;
};
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
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>
{
   




};



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 1 3 4
# 1274 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3 , typename N4
    >
struct times< N1 , N2 , N3 , N4 , na>

    : times< times< times< N1 , N2> , N3> , N4>
{
   




};
# 1275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2 , typename N3
    >
struct times< N1 , N2 , N3 , na , na>

    : times< times< N1 , N2> , N3>
{
   




};
# 1280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
template<
      typename N1 , typename N2
    >
struct times< N1 , N2 , na , na , na>
# 1285 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/reverse1.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
    : times_impl<
          typename times_tag<N1>::type
        , typename times_tag<N2>::type
        >::template apply<N1,N2>::type
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
{



   
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/numeric_op.hpp" 3 4
};

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> { }; }

}}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
namespace boost { namespace mpl {
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
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
                )
            >
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
    {
    };
};

}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/times.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/multiplies.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/multiplies.hpp" 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/is_subranged.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/converter.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/converter_policies.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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:

    virtual const char * what() const throw()
      { return "bad numeric conversion: overflow"; }
};

class negative_overflow : public bad_numeric_cast
{
  public:

    virtual const char * what() const throw()
      { return "bad numeric conversion: negative overflow"; }
};
class positive_overflow : public bad_numeric_cast
{
  public:

    virtual const char * what() const throw()
      { 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/converter.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/converter.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/converter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/bounds.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/bounds.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/bounds.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/bounds.hpp" 2 3 4

namespace boost { namespace numeric
{

template<class N>
struct bounds : boundsdetail::get_impl<N>::type
{} ;

} }
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/cast.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/numeric_cast_traits.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/numeric_cast_traits.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp" 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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/numeric/conversion/numeric_cast_traits.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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>
      explicit hours(T const& h,
          typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
      time_duration(numeric_cast<hour_type>(h), 0, 0)
    {}
  };





  class __attribute__((__visibility__("default"))) minutes : public time_duration
  {
  public:
      template <typename T>
      explicit minutes(T const& m,
          typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
      time_duration(0, numeric_cast<min_type>(m),0)
    {}
  };





  class __attribute__((__visibility__("default"))) seconds : public time_duration
  {
  public:
      template <typename T>
      explicit seconds(T const& s,
          typename boost::enable_if<boost::is_integral<T>, void>::type* = 0) :
      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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
} }
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/time_period.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/time_iterator.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
    }
    time_type operator*() {return current_;}
    time_type* operator->() {return &current_;}
    bool operator< (const time_type& t) {return current_ < t;}
    bool operator<= (const time_type& t) {return current_ <= t;}
    bool operator!= (const time_type& t) {return current_ != t;}
    bool operator== (const time_type& t) {return current_ == t;}
    bool operator> (const time_type& t) {return current_ > t;}
    bool operator>= (const time_type& t) {return current_ >= t;}

  private:
    time_type current_;
    time_duration_type offset_;
  };



} }
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/dst_rules.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_minutes)
      {
        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_minutes.hours() * 60 + dst_length_minutes.minutes());

        return local_is_dst(current_day, time_of_day,
                            dst_start_day, start_minutes,
                            dst_end_day, end_minutes,
                            length_minutes);
      }
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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, gregorian::Mar);
          return ssim.get_date(year);
        } else {

          fkday fsia(Sunday, gregorian::Apr);
          return fsia.get_date(year);
        }
      }

      static date_type local_dst_end_day(year_type year)
      {
        if (year >= year_type(2007)) {

          fkday fsin(Sunday, gregorian::Nov);
          return fsin.get_date(year);
        } else {

          lkday lsio(Sunday, gregorian::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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/thread_time.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/thread_time.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/time_point.hpp" 1 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/time_point.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 1 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/config.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/config.hpp" 2 3 4
# 212 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/auto_link.hpp" 1 3 4
# 213 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/config.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/detail/static_assert.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4

# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/config.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/config.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/abs.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/sign.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/gcd.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/mpl/aux_/config/dependent_nttp.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/lcm.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/mpl/lcm.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio_fwd.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio_fwd.hpp" 3 4
       
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio_fwd.hpp" 3


namespace boost
{
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio_fwd.hpp" 3
}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/overflow_helpers.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/overflow_helpers.hpp" 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/detail/overflow_helpers.hpp" 3 4
       
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 2 3 4
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 3 4
       
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 3


namespace boost
{
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 3
    typedef ratio<num, den> type;
};
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/ratio/ratio.hpp" 3
}
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/common_type.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/common_type.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/type_traits/detail/mp_defer.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/detail/is_evenly_divisible_by.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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* = 0
            ) : rep_(r) { }







        duration& operator=(const duration& rhs) = 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* = 0
        )
            : 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();
    }
# 636 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 796 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/duration.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/time_point.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/time_point.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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* = 0
        )
            : d_(t.time_since_epoch())
        {
        }


        constexpr
        duration time_since_epoch() const
        {
            return d_;
        }
# 215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 377 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/time_point.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 1229 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_types.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/xtime.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/xtime.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/xtime.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/conversion.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/conversion.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/conversion.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/conversion.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/filetime_functions.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/conversion.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/conversion.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/gregorian/conversion.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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(static_cast<long>(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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/date_time/posix_time/conversion.hpp" 3 4
} }
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/xtime.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 xtime get_xtime(boost::system_time const& abs_time)
{
    xtime res;
    boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);

    res.sec=static_cast<xtime::xtime_sec_t>(time_since_epoch.total_seconds());
    res.nsec=static_cast<xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
    return res;
}

inline int xtime_get(struct 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 xtime& xt1, const xtime& xt2)
{
    if (xt1.sec == xt2.sec)
        return (int)(xt1.nsec - xt2.nsec);
    else
        return (xt1.sec > xt2.sec) ? 1 : -1;
}

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/xtime.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 1 3 4
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/detail/system.hpp" 1 3 4
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/clock_string.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/clock_string.hpp" 3 4
namespace boost
{
  namespace chrono
  {

    template<class Clock, class CharT>
    struct clock_string;

  }

}
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 2 3 4

# 1 "/usr/include/c++/10/ctime" 1 3 4
# 39 "/usr/include/c++/10/ctime" 3 4
       
# 40 "/usr/include/c++/10/ctime" 3
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 2 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 2 3 4
# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 229 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/system_clocks.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/chrono/ceil.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 2 3 4

namespace boost
{

typedef boost::intmax_t time_max_t;
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 3 4
        timespec ts;
        if ( ::clock_gettime( 0, &ts ) )
        {
          (static_cast<void> (0));
          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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 3 4
      timespec ts;
      if ( ::clock_gettime( 1, &ts ) )
      {
        (static_cast<void> (0));
        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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 477 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/platform_time.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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)
            {
                ((void)(!pthread_mutex_lock(m)));
            }
            void unlock() noexcept
            {
                ((void)(!pthread_mutex_unlock(m)));
                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_)
            {
                ((void)(!pthread_mutex_unlock(m)));
            }
            ~pthread_mutex_scoped_unlock() noexcept
            {
                ((void)(!pthread_mutex_lock(m)));
            }

        };
    }
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_helpers.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_helpers.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_helpers.hpp" 2 3 4

namespace boost
{
    namespace pthread
    {
      inline int cond_init(pthread_cond_t& cond) {


              pthread_condattr_t attr;
              int res = pthread_condattr_init(&attr);
              if (res)
              {
                return res;
              }
              pthread_condattr_setclock(&attr, 1);
              res=pthread_cond_init(&cond,&attr);
              pthread_condattr_destroy(&attr);
              return res;




      }
    }
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/pthread_helpers.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4





namespace boost
{
  namespace posix {

    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_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_unlock(pthread_mutex_t* m)
    {
      int ret;
      do
      {
          ret = ::pthread_mutex_unlock(m);
      } while (ret == 4);
      return ret;
    }
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 3 4
  }
    class mutex
    {
    private:
        pthread_mutex_t m;
    public:
        mutex(mutex const&) = delete; mutex& operator=(mutex const&) = delete;

        mutex()
        {
            int const res=pthread_mutex_init(&m,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: mutex constructor failed in pthread_mutex_init"));
            }
        }
        ~mutex()
        {
          int const res = posix::pthread_mutex_destroy(&m);
          boost::ignore_unused(res);
          (static_cast<void> (0));
        }

        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()
        {
            int res = posix::pthread_mutex_unlock(&m);
            (void)res;
            (static_cast<void> (0));




        }

        bool try_lock()
        {
            int res;
            do
            {
                res = pthread_mutex_trylock(&m);
            } while (res == 4);
            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=pthread_mutex_init(&m,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: timed_mutex constructor failed in pthread_mutex_init"));
            }

            int const res2=pthread::cond_init(cond);
            if(res2)
            {
                ((void)(!posix::pthread_mutex_destroy(&m)));
                boost::throw_exception(thread_resource_error(res2, "boost:: timed_mutex constructor failed in pthread::cond_init"));
            }
            is_locked=false;

        }
        ~timed_mutex()
        {
            ((void)(!posix::pthread_mutex_destroy(&m)));

            ((void)(!pthread_cond_destroy(&cond)));

        }


        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);
# 220 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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));
        }
# 275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 3 4
        void lock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            while(is_locked)
            {
                ((void)(!pthread_cond_wait(&cond,&m)));
            }
            is_locked=true;
        }

        void unlock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            is_locked=false;
            ((void)(!pthread_cond_signal(&cond)));
        }

        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=pthread_cond_timedwait(&cond,&m,&timeout.getTs());
                if(cond_res==110)
                {
                    break;
                }
                (static_cast<void> (0));
            }
            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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 389 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/mutex.hpp" 2 3 4







namespace boost
{
  namespace sync
  {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/mutex.hpp" 3 4
  }
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/condition_variable.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/condition_variable.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_guard.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_guard.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/lockable_wrapper.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/lockable_wrapper.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/lockable_wrapper.hpp" 2 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_guard.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/lock_guard.hpp" 2 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable_fwd.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/cv_status.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/cv_status.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/scoped_enum.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/core/scoped_enum.hpp" 3 4
       


namespace boost
{
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/cv_status.hpp" 2 3 4

namespace boost
{


  enum class cv_status
  {
    no_timeout,
    timeout
  }
  ;
}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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=pthread_mutex_init(&internal_mutex,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
            }

            res = pthread::cond_init(cond);
            if (res)
            {


                ((void)(!pthread_mutex_destroy(&internal_mutex)));

                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread::cond_init"));
            }
        }
        ~condition_variable()
        {
            int ret;


            do {
              ret = pthread_mutex_destroy(&internal_mutex);
            } while (ret == 4);
            (static_cast<void> (0));

            do {
              ret = pthread_cond_destroy(&cond);
            } while (ret == 4);
            (static_cast<void> (0));
        }

        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);
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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,
            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);
# 163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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,
            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);
# 233 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 347 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/enable_shared_from_this.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/enable_shared_from_this.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/enable_shared_from_this.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/enable_shared_from_this.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/weak_ptr.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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;
    }
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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 & 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();
    }

    void reset() noexcept
    {
        this_type().swap(*this);
    }

    void swap(this_type & other) noexcept
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<typename Y>
    void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2) noexcept
    {
        px = px2;
        pn = r.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;
    }






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);
}

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/enable_shared_from_this.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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<void> (0));
        return p;
    }

    shared_ptr<T const> shared_from_this() const
    {
        shared_ptr<T const> p( weak_this_ );
        (static_cast<void> (0));
        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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/enable_shared_from_this.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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_);
            ((void)(!res && "pthread_attr_init failed"));
        }
        ~thread_attributes() {
          int res = pthread_attr_destroy(&val_);
          ((void)(!res && "pthread_attr_destroy failed"));
        }

        void set_stack_size(std::size_t size) noexcept {
          if (size==0) return;



          std::size_t page_size = ::sysconf( _SC_PAGESIZE);


          if (size<16384) size=16384;

          size = ((size+page_size-1)/page_size)*page_size;
          int res = pthread_attr_setstacksize(&val_, size);
          ((void)(!res && "pthread_attr_setstacksize failed"));
        }

        std::size_t get_stack_size() const noexcept {
            std::size_t size;
            int res = pthread_attr_getstacksize(&val_, &size);
            ((void)(!res && "pthread_attr_getstacksize failed"));
            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
        {
            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
            void* value;

            tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
                          void* value_):
                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;
                    ((void)(!pthread_mutex_lock(m)));
                }
                else
                {
                    ((void)(!pthread_mutex_lock(m)));
                }
            }
            void unlock_if_locked()
            {
              if ( ! done) {
                if (set)
                {
                    ((void)(!pthread_mutex_unlock(m)));
                    lock_guard<mutex> guard(thread_info->data_mutex);
                    thread_info->cond_mutex=__null;
                    thread_info->current_cond=__null;
                }
                else
                {
                    ((void)(!pthread_mutex_unlock(m)));
                }
                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();
            }
          }
# 394 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 3 4
        }
    }
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 399 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable.hpp" 2 3 4

namespace boost
{

    namespace this_thread
    {
        void __attribute__((__visibility__("default"))) interruption_point();
    }


    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 = pthread_cond_wait(&cond,the_mutex);
            check_for_interruption.unlock_if_locked();
            guard.deactivate();




        }

        this_thread::interruption_point();

        if(res && res != 4)
        {
            boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait"));
        }
    }
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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=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);

        ((void)(!pthread_cond_signal(&cond)));
    }

    inline void condition_variable::notify_all() noexcept
    {

        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);

        ((void)(!pthread_cond_broadcast(&cond)));
    }

    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=pthread_mutex_init(&internal_mutex,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
            }
            int const res2 = pthread::cond_init(cond);
            if(res2)
            {
                ((void)(!pthread_mutex_destroy(&internal_mutex)));
                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in pthread::cond_init"));
            }
        }
        ~condition_variable_any()
        {
            ((void)(!pthread_mutex_destroy(&internal_mutex)));
            ((void)(!pthread_cond_destroy(&cond)));
        }

        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=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);
# 244 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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,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);
# 282 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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,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);
# 346 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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);
            ((void)(!pthread_cond_signal(&cond)));
        }

        void notify_all() noexcept
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            ((void)(!pthread_cond_broadcast(&cond)));
        }
    private:
# 466 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/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=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 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 501 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/condition_variable.hpp" 2 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/thread_interruption.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/detail/thread_interruption.hpp" 3 4
namespace boost
{
    namespace this_thread
    {
        class __attribute__((__visibility__("default"))) disable_interruption
        {
          bool interruption_was_enabled;
          friend class restore_interruption;
        public:
            disable_interruption(disable_interruption const&) = delete; disable_interruption& operator=(disable_interruption const&) = delete;
            disable_interruption() noexcept;
            ~disable_interruption() noexcept;
        };

        class __attribute__((__visibility__("default"))) restore_interruption
        {
        public:
            restore_interruption(restore_interruption const&) = delete; restore_interruption& operator=(restore_interruption const&) = delete;
            explicit restore_interruption(disable_interruption& d) noexcept;
            ~restore_interruption() noexcept;
        };
    }
}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_prefix.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4

namespace boost
{
    class shared_mutex
    {
    private:
        class state_data
        {
        public:
            state_data () :
              shared_count(0),
              exclusive(false),
              upgrade(false),
              exclusive_waiting_blocked(false)
            {}

            void assert_free() const
            {
                (static_cast<void> (0));
                (static_cast<void> (0));
                (static_cast<void> (0));
            }

            void assert_locked() const
            {
                (static_cast<void> (0));
                (static_cast<void> (0));
                (static_cast<void> (0));
            }

            void assert_lock_shared () const
            {
                (static_cast<void> (0));
                (static_cast<void> (0));



            }

            void assert_lock_upgraded () const
            {
                (static_cast<void> (0));
                (static_cast<void> (0));
                (static_cast<void> (0));
            }

            void assert_lock_not_upgraded () const
            {
                (static_cast<void> (0));
            }

            bool can_lock () const
            {
                return ! (shared_count || exclusive);
            }

            void lock ()
            {
                exclusive = true;
            }

            void unlock ()
            {
                exclusive = false;
                exclusive_waiting_blocked = false;
            }

            bool can_lock_shared () const
            {
                return ! (exclusive || exclusive_waiting_blocked);
            }

            bool no_shared () const
            {
                return shared_count==0;
            }

            bool one_shared () const
            {
                return shared_count==1;
            }

            void lock_shared ()
            {
                ++shared_count;
            }


            void unlock_shared ()
            {
                --shared_count;
            }

            void lock_upgrade ()
            {
                ++shared_count;
                upgrade=true;
            }
            bool can_lock_upgrade () const
            {
                return ! (exclusive || exclusive_waiting_blocked || upgrade);
            }

            void unlock_upgrade ()
            {
                upgrade=false;
                --shared_count;
            }


            unsigned shared_count;
            bool exclusive;
            bool upgrade;
            bool exclusive_waiting_blocked;
        };



        state_data state;
        boost::mutex state_change;
        boost::condition_variable shared_cond;
        boost::condition_variable exclusive_cond;
        boost::condition_variable upgrade_cond;

        void release_waiters()
        {
            exclusive_cond.notify_one();
            shared_cond.notify_all();
        }

    public:

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

        shared_mutex()
        {
        }

        ~shared_mutex()
        {
        }

        void lock_shared()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            shared_cond.wait(lk, boost::bind(&state_data::can_lock_shared, boost::ref(state)));
            state.lock_shared();
        }

        bool try_lock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);

            if(!state.can_lock_shared())
            {
                return false;
            }
            state.lock_shared();
            return true;
        }


        bool timed_lock_shared(system_time const& timeout)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_shared, boost::ref(state))))
            {
                return false;
            }
            state.lock_shared();
            return true;
        }

        template<typename TimeDuration>
        bool timed_lock_shared(TimeDuration const & relative_time)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_shared, boost::ref(state))))
            {
                return false;
            }
            state.lock_shared();
            return true;
        }


        template <class Rep, class Period>
        bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);
          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_shared, boost::ref(state))))
          {
              return false;
          }
          state.lock_shared();
          return true;
        }

        void unlock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.assert_lock_shared();
            state.unlock_shared();
            if (state.no_shared())
            {
                if (state.upgrade)
                {


                    state.upgrade=false;
                    state.exclusive=true;

                    upgrade_cond.notify_one();
                }
                else
                {
                    state.exclusive_waiting_blocked=false;

                }
                release_waiters();
            }
        }

        void lock()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            state.exclusive_waiting_blocked=true;
            exclusive_cond.wait(lk, boost::bind(&state_data::can_lock, boost::ref(state)));
            state.exclusive=true;
        }


        bool timed_lock(system_time const& timeout)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            state.exclusive_waiting_blocked=true;
            if(!exclusive_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock, boost::ref(state))))
            {
                state.exclusive_waiting_blocked=false;
                release_waiters();
                return false;
            }
            state.exclusive=true;
            return true;
        }

        template<typename TimeDuration>
        bool timed_lock(TimeDuration const & relative_time)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            state.exclusive_waiting_blocked=true;
            if(!exclusive_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock, boost::ref(state))))
            {
                state.exclusive_waiting_blocked=false;
                release_waiters();
                return false;
            }
            state.exclusive=true;
            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>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);
          state.exclusive_waiting_blocked=true;
          if(!exclusive_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock, boost::ref(state))))
          {
              state.exclusive_waiting_blocked=false;
              release_waiters();
              return false;
          }
          state.exclusive=true;
          return true;
        }


        bool try_lock()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            if(!state.can_lock())
            {
                return false;
            }
            state.exclusive=true;
            return true;
        }

        void unlock()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.assert_locked();
            state.exclusive=false;
            state.exclusive_waiting_blocked=false;
            state.assert_free();
            release_waiters();
        }

        void lock_upgrade()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            shared_cond.wait(lk, boost::bind(&state_data::can_lock_upgrade, boost::ref(state)));
            state.lock_shared();
            state.upgrade=true;
        }


        bool timed_lock_upgrade(system_time const& timeout)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            if(!shared_cond.timed_wait(lk, timeout, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))))
            {
                return false;
            }
            state.lock_shared();
            state.upgrade=true;
            return true;
        }

        template<typename TimeDuration>
        bool timed_lock_upgrade(TimeDuration const & relative_time)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            if(!shared_cond.timed_wait(lk, relative_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))))
            {
                return false;
            }
            state.lock_shared();
            state.upgrade=true;
            return true;
        }


        template <class Rep, class Period>
        bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);
          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::can_lock_upgrade, boost::ref(state))))
          {
              return false;
          }
          state.lock_shared();
          state.upgrade=true;
          return true;
        }

        bool try_lock_upgrade()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            if(!state.can_lock_upgrade())
            {
                return false;
            }
            state.lock_shared();
            state.upgrade=true;
            state.assert_lock_upgraded();
            return true;
        }

        void unlock_upgrade()
        {
            boost::unique_lock<boost::mutex> lk(state_change);

            state.unlock_upgrade();
            if(state.no_shared())
            {
                state.exclusive_waiting_blocked=false;
                release_waiters();
            } else {
                shared_cond.notify_all();
            }
        }


        void unlock_upgrade_and_lock()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            state.assert_lock_upgraded();
            state.unlock_shared();
            upgrade_cond.wait(lk, boost::bind(&state_data::no_shared, boost::ref(state)));
            state.upgrade=false;
            state.exclusive=true;
            state.assert_locked();
        }

        void unlock_and_lock_upgrade()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.assert_locked();
            state.exclusive=false;
            state.upgrade=true;
            state.lock_shared();
            state.exclusive_waiting_blocked=false;
            state.assert_lock_upgraded();
            release_waiters();
        }

        bool try_unlock_upgrade_and_lock()
        {
          boost::unique_lock<boost::mutex> lk(state_change);
          state.assert_lock_upgraded();
          if( !state.exclusive
              && !state.exclusive_waiting_blocked
              && state.upgrade
              && state.shared_count==1)
          {
            state.shared_count=0;
            state.exclusive=true;
            state.upgrade=false;
            state.assert_locked();
            return true;
          }
          return false;
        }

        template <class Rep, class Period>
        bool
        try_unlock_upgrade_and_lock_for(
                                const chrono::duration<Rep, Period>& rel_time)
        {
          return try_unlock_upgrade_and_lock_until(
                                 chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool
        try_unlock_upgrade_and_lock_until(
                          const chrono::time_point<Clock, Duration>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);
          state.assert_lock_upgraded();
          if(!shared_cond.wait_until(lk, abs_time, boost::bind(&state_data::one_shared, boost::ref(state))))
          {
              return false;
          }
          state.upgrade=false;
          state.exclusive=true;
          state.exclusive_waiting_blocked=false;
          state.shared_count=0;
          return true;
        }



        void unlock_and_lock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.assert_locked();
            state.exclusive=false;
            state.lock_shared();
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
# 586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 3 4
        void unlock_upgrade_and_lock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.assert_lock_upgraded();
            state.upgrade=false;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
# 635 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 3 4
    };

    typedef shared_mutex upgrade_mutex;
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/abi_suffix.hpp" 1 3 4
# 641 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/shared_mutex.hpp" 2 3 4







namespace boost
{
  typedef shared_mutex shared_timed_mutex;
  namespace sync
  {
# 54 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/thread/shared_mutex.hpp" 3 4
  }
}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 2




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/iso_8601.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/iso_8601.h"

# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/iso_8601.h"
namespace ceph {
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/iso_8601.h"
boost::optional<ceph::real_time> from_iso_8601(
  boost::string_ref s, const bool ws_terminates = true) noexcept;

enum class iso_8601_format {
  Y, YM, YMD, YMDh, YMDhm, YMDhms, YMDhmsn
};

std::string to_iso_8601(const ceph::real_time t,
   const iso_8601_format f = iso_8601_format::YMDhmsn)
  noexcept;
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 1 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 2 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 2 3 4
# 374 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 3 4

# 374 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 3 4
namespace rapidjson {





typedef unsigned SizeType;
}



namespace rapidjson {
using std::size_t;
}
# 401 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 3 4
# 1 "/usr/include/c++/10/cassert" 1 3 4
# 41 "/usr/include/c++/10/cassert" 3 4
       
# 42 "/usr/include/c++/10/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 45 "/usr/include/c++/10/cassert" 2 3
# 402 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 2 3 4
# 413 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 3 4
namespace rapidjson {
template <bool x> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
template<int x> struct StaticAssertTest {};
}
# 600 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/rapidjson.h" 3 4
namespace rapidjson {


enum Type {
    kNullType = 0,
    kFalseType = 1,
    kTrueType = 2,
    kObjectType = 3,
    kArrayType = 4,
    kStringType = 5,
    kNumberType = 6
};

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 2 3 4
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 3 4
namespace rapidjson {
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 3 4
enum ParseErrorCode {
    kParseErrorNone = 0,

    kParseErrorDocumentEmpty,
    kParseErrorDocumentRootNotSingular,

    kParseErrorValueInvalid,

    kParseErrorObjectMissName,
    kParseErrorObjectMissColon,
    kParseErrorObjectMissCommaOrCurlyBracket,

    kParseErrorArrayMissCommaOrSquareBracket,

    kParseErrorStringUnicodeEscapeInvalidHex,
    kParseErrorStringUnicodeSurrogateInvalid,
    kParseErrorStringEscapeInvalid,
    kParseErrorStringMissQuotationMark,
    kParseErrorStringInvalidEncoding,

    kParseErrorNumberTooBig,
    kParseErrorNumberMissFraction,
    kParseErrorNumberMissExponent,

    kParseErrorTermination,
    kParseErrorUnspecificSyntaxError
};
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 3 4
struct ParseResult {
public:

    ParseResult() : code_(kParseErrorNone), offset_(0) {}

    ParseResult(ParseErrorCode code, size_t offset) : code_(code), offset_(offset) {}


    ParseErrorCode Code() const { return code_; }

    size_t Offset() const { return offset_; }


    operator bool() const { return !IsError(); }

    bool IsError() const { return code_ != kParseErrorNone; }

    bool operator==(const ParseResult& that) const { return code_ == that.code_; }
    bool operator==(ParseErrorCode code) const { return code_ == code; }
    friend bool operator==(ParseErrorCode code, const ParseResult & err) { return code == err.code_; }


    void Clear() { Set(kParseErrorNone); }

    void Set(ParseErrorCode code, size_t offset = 0) { code_ = code; offset_ = offset; }

private:
    ParseErrorCode code_;
    size_t offset_;
};
# 147 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 3 4
typedef const char* (*GetParseErrorFunc)(ParseErrorCode);

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/en.h" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/en.h" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/error.h" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/en.h" 2 3 4







namespace rapidjson {
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rapidjson/include/rapidjson/error/en.h" 3 4
inline const char* GetParseError_En(ParseErrorCode parseErrorCode) {
    switch (parseErrorCode) {
        case kParseErrorNone: return "No error.";

        case kParseErrorDocumentEmpty: return "The document is empty.";
        case kParseErrorDocumentRootNotSingular: return "The document root must not be followed by other values.";

        case kParseErrorValueInvalid: return "Invalid value.";

        case kParseErrorObjectMissName: return "Missing a name for object member.";
        case kParseErrorObjectMissColon: return "Missing a colon after a name of object member.";
        case kParseErrorObjectMissCommaOrCurlyBracket: return "Missing a comma or '}' after an object member.";

        case kParseErrorArrayMissCommaOrSquareBracket: return "Missing a comma or ']' after an array element.";

        case kParseErrorStringUnicodeEscapeInvalidHex: return "Incorrect hex digit after \\u escape in string.";
        case kParseErrorStringUnicodeSurrogateInvalid: return "The surrogate pair in string is invalid.";
        case kParseErrorStringEscapeInvalid: return "Invalid escape character in string.";
        case kParseErrorStringMissQuotationMark: return "Missing a closing quotation mark in string.";
        case kParseErrorStringInvalidEncoding: return "Invalid encoding in string.";

        case kParseErrorNumberTooBig: return "Number too big to be stored in double.";
        case kParseErrorNumberMissFraction: return "Miss fraction part in number.";
        case kParseErrorNumberMissExponent: return "Miss exponent in number.";

        case kParseErrorTermination: return "Terminate parsing due to Handler error.";
        case kParseErrorUnspecificSyntaxError: return "Unspecific syntax error.";

        default: return "Unknown error.";
    }
}

}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 2



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy_keywords.h" 1







# 7 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy_keywords.h"
namespace rgw {
namespace IAM {

enum class TokenKind {
  pseudo, top, statement, cond_op, cond_key, version_key, effect_key,
  princ_type
};

enum class TokenID {

  Top,


  Version, Id, Statement,


  Sid, Effect, Principal, NotPrincipal, Action, NotAction,
  Resource, NotResource, Condition,





  StringEquals, StringNotEquals, StringEqualsIgnoreCase,
  StringNotEqualsIgnoreCase, StringLike, StringNotLike,


  NumericEquals, NumericNotEquals, NumericLessThan, NumericLessThanEquals,
  NumericGreaterThan, NumericGreaterThanEquals,


  DateEquals, DateNotEquals, DateLessThan, DateLessThanEquals,
  DateGreaterThan, DateGreaterThanEquals,


  Bool,


  BinaryEquals,


  IpAddress, NotIpAddress,


  ArnEquals, ArnNotEquals, ArnLike, ArnNotLike,


  Null,
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy_keywords.h"
  CondKey,





  v2008_10_17,
  v2012_10_17,




  Allow,
  Deny,


  AWS,
  Federated,
  Service,
  CanonicalUser
};


enum class Version {
  v2008_10_17,
  v2012_10_17
};


enum class Effect {
  Allow,
  Deny,
  Pass
};

enum class Type {
  string,
  number,
  date,
  boolean,
  binary,
  ipaddr,
  arn,
  null
};
}
}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 1







# 1 "/usr/include/c++/10/stdlib.h" 1 3
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 2
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 2




struct ltstr_nocase
{
  bool operator()(const std::string& s1, const std::string& s2) const
  {
    return strcasecmp(s1.c_str(), s2.c_str()) < 0;
  }
};

static inline int stringcasecmp(const std::string& s1, const std::string& s2)
{
  return strcasecmp(s1.c_str(), s2.c_str());
}

static inline int stringcasecmp(const std::string& s1, const char *s2)
{
  return strcasecmp(s1.c_str(), s2);
}

static inline int stringcasecmp(const std::string& s1, int ofs, int size, const std::string& s2)
{
  return strncasecmp(s1.c_str() + ofs, s2.c_str(), size);
}

static inline int stringtoll(const std::string& s, int64_t *val)
{
  char *end;

  long long result = strtoll(s.c_str(), &end, 10);
  if (result == 0x7fffffffffffffffLL)
    return -
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  if (*end)
    return -
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  *val = (int64_t)result;

  return 0;
}

static inline int stringtoull(const std::string& s, uint64_t *val)
{
  char *end;

  unsigned long long result = strtoull(s.c_str(), &end, 10);
  if (result == 
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
               (0x7fffffffffffffffLL * 2ULL + 1)
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                         )
    return -
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  if (*end)
    return -
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  *val = (uint64_t)result;

  return 0;
}

static inline int stringtol(const std::string& s, int32_t *val)
{
  char *end;

  long result = strtol(s.c_str(), &end, 10);
  if (result == 0x7fffffffffffffffL)
    return -
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  if (*end)
    return -
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  *val = (int32_t)result;

  return 0;
}

static inline int stringtoul(const std::string& s, uint32_t *val)
{
  char *end;

  unsigned long result = strtoul(s.c_str(), &end, 10);
  if (result == 
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
               (0x7fffffffffffffffL * 2UL + 1UL)
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                        )
    return -
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  if (*end)
    return -
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h" 3 4
           22
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_string.h"
                 ;

  *val = (uint32_t)result;

  return 0;
}




template<std::size_t N = 128>
static inline boost::container::small_vector<char, N>
sview2cstr(const boost::string_view& sv)
{
  boost::container::small_vector<char, N> cstr;
  cstr.reserve(sv.size() + sizeof('\0'));

  cstr.assign(std::begin(sv), std::end(sv));
  cstr.push_back('\0');

  return cstr;
}





template<size_t N>
static inline constexpr size_t sarrlen(const char (&arr)[N]) {
  return N - 1;
}

namespace detail {


static inline constexpr size_t sum() { return 0; }
template <typename... Args>
constexpr size_t sum(size_t v, Args... args) { return v + sum(args...); }


template <typename T>
struct string_traits {
  static constexpr size_t size(const T& s) { return s.size(); }
};

template <>
struct string_traits<const char*> {
  static size_t size(const char* s) { return std::strlen(s); }
};
template <>
struct string_traits<char*> : string_traits<const char*> {};

template <std::size_t N>
struct string_traits<const char[N]> {
  static constexpr size_t size_(const char* s, size_t i) {
    return i < N ? (*(s + i) == '\0' ? i : size_(s, i + 1))
        : throw std::invalid_argument("Unterminated string constant.");
  }
  static constexpr size_t size(const char(&s)[N]) { return size_(s, 0); }
};
template <std::size_t N>
struct string_traits<char[N]> : string_traits<const char[N]> {};


static inline void append_to(std::string& s) {}
template <typename... Args>
void append_to(std::string& s, const boost::string_view& v, const Args&... args)
{
  s.append(v.begin(), v.end());
  append_to(s, args...);
}


static inline void join_next(std::string& s, const boost::string_view& d) {}
template <typename... Args>
void join_next(std::string& s, const boost::string_view& d,
               const boost::string_view& v, const Args&... args)
{
  s.append(d.begin(), d.end());
  s.append(v.begin(), v.end());
  join_next(s, d, args...);
}

static inline void join(std::string& s, const boost::string_view& d) {}
template <typename... Args>
void join(std::string& s, const boost::string_view& d,
          const boost::string_view& v, const Args&... args)
{
  s.append(v.begin(), v.end());
  join_next(s, d, args...);
}

}


template <typename T>
constexpr size_t string_size(const T& s)
{
  return detail::string_traits<T>::size(s);
}



template <typename... Args>
std::string string_cat_reserve(const Args&... args)
{
  size_t total_size = detail::sum(string_size(args)...);
  std::string result;
  result.reserve(total_size);
  detail::append_to(result, args...);
  return result;
}



template <typename... Args>
std::string string_join_reserve(const boost::string_view& delim,
                                const Args&... args)
{
  size_t delim_size = delim.size() * std::max<ssize_t>(0, sizeof...(args) - 1);
  size_t total_size = detail::sum(string_size(args)...) + delim_size;
  std::string result;
  result.reserve(total_size);
  detail::join(result, delim, args...);
  return result;
}
template <typename... Args>
std::string string_join_reserve(char delim, const Args&... args)
{
  return string_join_reserve(boost::string_view{&delim, 1}, args...);
}



static constexpr uint32_t MATCH_CASE_INSENSITIVE = 0x01;



extern bool match_wildcards(boost::string_view pattern,
                            boost::string_view input,
                            uint32_t flags = 0);
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_arn.h" 1



       



class rgw_obj;
class rgw_bucket;

namespace rgw {

enum struct Partition {
  aws, aws_cn, aws_us_gov, wildcard




};

enum struct Service {
  apigateway, appstream, artifact, autoscaling, aws_portal, acm,
  cloudformation, cloudfront, cloudhsm, cloudsearch, cloudtrail,
  cloudwatch, events, logs, codebuild, codecommit, codedeploy,
  codepipeline, cognito_idp, cognito_identity, cognito_sync,
  config, datapipeline, dms, devicefarm, directconnect,
  ds, dynamodb, ec2, ecr, ecs, ssm, elasticbeanstalk, elasticfilesystem,
  elasticloadbalancing, elasticmapreduce, elastictranscoder, elasticache,
  es, gamelift, glacier, health, iam, importexport, inspector, iot,
  kms, kinesisanalytics, firehose, kinesis, lambda, lightsail,
  machinelearning, aws_marketplace, aws_marketplace_management,
  mobileanalytics, mobilehub, opsworks, opsworks_cm, polly,
  redshift, rds, route53, route53domains, sts, servicecatalog,
  ses, sns, sqs, s3, swf, sdb, states, storagegateway, support,
  trustedadvisor, waf, workmail, workspaces, wildcard
};





struct ARN {
  Partition partition;
  Service service;
  std::string region;


  std::string account;
  std::string resource;

  ARN()
    : partition(Partition::wildcard), service(Service::wildcard) {}
  ARN(Partition partition, Service service, std::string region,
      std::string account, std::string resource)
    : partition(partition), service(service), region(std::move(region)),
      account(std::move(account)), resource(std::move(resource)) {}
  ARN(const rgw_obj& o);
  ARN(const rgw_bucket& b);
  ARN(const rgw_bucket& b, const std::string& o);
  ARN(const std::string& resource_name, const std::string& type, const std::string& tenant, bool has_path=false);

  static boost::optional<ARN> parse(const std::string& s,
        bool wildcard = false);
  std::string to_string() const;


  bool match(const ARN& candidate) const;
};

inline std::string to_string(const ARN& a) {
  return a.to_string();
}

inline std::ostream& operator <<(std::ostream& m, const ARN& a) {
  return m << to_string(a);
}

bool operator ==(const ARN& l, const ARN& r);
bool operator <(const ARN& l, const ARN& r);
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_arn.h"
struct ARNResource {
  constexpr static const char* const wildcard = "*";
  std::string resource_type;
  std::string resource;
  std::string qualifier;

  ARNResource() : resource_type(""), resource(wildcard), qualifier("") {}

  ARNResource(const std::string& _resource_type, const std::string& _resource, const std::string& _qualifier) :
    resource_type(std::move(_resource_type)), resource(std::move(_resource)), qualifier(std::move(_qualifier)) {}

  static boost::optional<ARNResource> parse(const std::string& s);

  std::string to_string() const;
};

inline std::string to_string(const ARNResource& r) {
  return r.to_string();
}

}

namespace std {
template<>
struct hash<::rgw::Service> {
  size_t operator()(const ::rgw::Service& s) const noexcept {

    return hash<int>()(static_cast<int>(s));
  }
};
}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h" 2

class RGWRados;
namespace rgw {
namespace auth {
class Identity;
}
}
struct rgw_obj;
struct rgw_bucket;

namespace rgw {
namespace IAM {

static constexpr std::uint64_t s3GetObject = 0;
static constexpr std::uint64_t s3GetObjectVersion = 1;
static constexpr std::uint64_t s3PutObject = 2;
static constexpr std::uint64_t s3GetObjectAcl = 3;
static constexpr std::uint64_t s3GetObjectVersionAcl = 4;
static constexpr std::uint64_t s3PutObjectAcl = 5;
static constexpr std::uint64_t s3PutObjectVersionAcl = 6;
static constexpr std::uint64_t s3DeleteObject = 7;
static constexpr std::uint64_t s3DeleteObjectVersion = 8;
static constexpr std::uint64_t s3ListMultipartUploadParts = 9;
static constexpr std::uint64_t s3AbortMultipartUpload = 10;
static constexpr std::uint64_t s3GetObjectTorrent = 11;
static constexpr std::uint64_t s3GetObjectVersionTorrent = 12;
static constexpr std::uint64_t s3RestoreObject = 13;
static constexpr std::uint64_t s3CreateBucket = 14;
static constexpr std::uint64_t s3DeleteBucket = 15;
static constexpr std::uint64_t s3ListBucket = 16;
static constexpr std::uint64_t s3ListBucketVersions = 17;
static constexpr std::uint64_t s3ListAllMyBuckets = 18;
static constexpr std::uint64_t s3ListBucketMultipartUploads = 19;
static constexpr std::uint64_t s3GetAccelerateConfiguration = 20;
static constexpr std::uint64_t s3PutAccelerateConfiguration = 21;
static constexpr std::uint64_t s3GetBucketAcl = 22;
static constexpr std::uint64_t s3PutBucketAcl = 23;
static constexpr std::uint64_t s3GetBucketCORS = 24;
static constexpr std::uint64_t s3PutBucketCORS = 25;
static constexpr std::uint64_t s3GetBucketVersioning = 26;
static constexpr std::uint64_t s3PutBucketVersioning = 27;
static constexpr std::uint64_t s3GetBucketRequestPayment = 28;
static constexpr std::uint64_t s3PutBucketRequestPayment = 29;
static constexpr std::uint64_t s3GetBucketLocation = 30;
static constexpr std::uint64_t s3GetBucketPolicy = 31;
static constexpr std::uint64_t s3DeleteBucketPolicy = 32;
static constexpr std::uint64_t s3PutBucketPolicy = 33;
static constexpr std::uint64_t s3GetBucketNotification = 34;
static constexpr std::uint64_t s3PutBucketNotification = 35;
static constexpr std::uint64_t s3GetBucketLogging = 36;
static constexpr std::uint64_t s3PutBucketLogging = 37;
static constexpr std::uint64_t s3GetBucketTagging = 38;
static constexpr std::uint64_t s3PutBucketTagging = 39;
static constexpr std::uint64_t s3GetBucketWebsite = 40;
static constexpr std::uint64_t s3PutBucketWebsite = 41;
static constexpr std::uint64_t s3DeleteBucketWebsite = 42;
static constexpr std::uint64_t s3GetLifecycleConfiguration = 43;
static constexpr std::uint64_t s3PutLifecycleConfiguration = 44;
static constexpr std::uint64_t s3PutReplicationConfiguration = 45;
static constexpr std::uint64_t s3GetReplicationConfiguration = 46;
static constexpr std::uint64_t s3DeleteReplicationConfiguration = 47;
static constexpr std::uint64_t s3GetObjectTagging = 48;
static constexpr std::uint64_t s3PutObjectTagging = 49;
static constexpr std::uint64_t s3DeleteObjectTagging = 50;
static constexpr std::uint64_t s3GetObjectVersionTagging = 51;
static constexpr std::uint64_t s3PutObjectVersionTagging = 52;
static constexpr std::uint64_t s3DeleteObjectVersionTagging = 53;
static constexpr std::uint64_t s3PutBucketObjectLockConfiguration = 54;
static constexpr std::uint64_t s3GetBucketObjectLockConfiguration = 55;
static constexpr std::uint64_t s3PutObjectRetention = 56;
static constexpr std::uint64_t s3GetObjectRetention = 57;
static constexpr std::uint64_t s3PutObjectLegalHold = 58;
static constexpr std::uint64_t s3GetObjectLegalHold = 59;
static constexpr std::uint64_t s3BypassGovernanceRetention = 60;
static constexpr std::uint64_t s3All = 61;

static constexpr std::uint64_t iamPutUserPolicy = 62;
static constexpr std::uint64_t iamGetUserPolicy = 63;
static constexpr std::uint64_t iamDeleteUserPolicy = 64;
static constexpr std::uint64_t iamListUserPolicies = 65;
static constexpr std::uint64_t iamCreateRole = 66;
static constexpr std::uint64_t iamDeleteRole = 67;
static constexpr std::uint64_t iamModifyRole = 68;
static constexpr std::uint64_t iamGetRole = 69;
static constexpr std::uint64_t iamListRoles = 70;
static constexpr std::uint64_t iamPutRolePolicy = 71;
static constexpr std::uint64_t iamGetRolePolicy = 72;
static constexpr std::uint64_t iamListRolePolicies = 73;
static constexpr std::uint64_t iamDeleteRolePolicy = 74;
static constexpr std::uint64_t iamAll = 75;
static constexpr std::uint64_t stsAssumeRole = 76;
static constexpr std::uint64_t stsAssumeRoleWithWebIdentity = 77;
static constexpr std::uint64_t stsGetSessionToken = 78;
static constexpr std::uint64_t stsAll = 79;

static constexpr std::uint64_t s3Count = s3BypassGovernanceRetention + 1;
static constexpr std::uint64_t allCount = stsAll + 1;

using Action_t = bitset<allCount>;
using NotAction_t = Action_t;

static const Action_t None(0);
static const Action_t s3AllValue("1111111111111111111111111111111111111111111111111111111111111");
static const Action_t iamAllValue("111111111111100000000000000000000000000000000000000000000000000000000000000");
static const Action_t stsAllValue("1110000000000000000000000000000000000000000000000000000000000000000000000000000");

static const Action_t allValue("11111111111111111111111111111111111111111111111111111111111111111111111111111111");

namespace {


inline int op_to_perm(std::uint64_t op) {
  switch (op) {
  case s3GetObject:
  case s3GetObjectTorrent:
  case s3GetObjectVersion:
  case s3GetObjectVersionTorrent:
  case s3GetObjectTagging:
  case s3GetObjectVersionTagging:
  case s3GetObjectRetention:
  case s3GetObjectLegalHold:
  case s3ListAllMyBuckets:
  case s3ListBucket:
  case s3ListBucketMultipartUploads:
  case s3ListBucketVersions:
  case s3ListMultipartUploadParts:
    return 0x01;

  case s3AbortMultipartUpload:
  case s3CreateBucket:
  case s3DeleteBucket:
  case s3DeleteObject:
  case s3DeleteObjectVersion:
  case s3PutObject:
  case s3PutObjectTagging:
  case s3PutObjectVersionTagging:
  case s3DeleteObjectTagging:
  case s3DeleteObjectVersionTagging:
  case s3RestoreObject:
  case s3PutObjectRetention:
  case s3PutObjectLegalHold:
  case s3BypassGovernanceRetention:
    return 0x02;

  case s3GetAccelerateConfiguration:
  case s3GetBucketAcl:
  case s3GetBucketCORS:
  case s3GetBucketLocation:
  case s3GetBucketLogging:
  case s3GetBucketNotification:
  case s3GetBucketPolicy:
  case s3GetBucketRequestPayment:
  case s3GetBucketTagging:
  case s3GetBucketVersioning:
  case s3GetBucketWebsite:
  case s3GetLifecycleConfiguration:
  case s3GetObjectAcl:
  case s3GetObjectVersionAcl:
  case s3GetReplicationConfiguration:
  case s3GetBucketObjectLockConfiguration:
    return 0x04;

  case s3DeleteBucketPolicy:
  case s3DeleteBucketWebsite:
  case s3DeleteReplicationConfiguration:
  case s3PutAccelerateConfiguration:
  case s3PutBucketAcl:
  case s3PutBucketCORS:
  case s3PutBucketLogging:
  case s3PutBucketNotification:
  case s3PutBucketPolicy:
  case s3PutBucketRequestPayment:
  case s3PutBucketTagging:
  case s3PutBucketVersioning:
  case s3PutBucketWebsite:
  case s3PutLifecycleConfiguration:
  case s3PutObjectAcl:
  case s3PutObjectVersionAcl:
  case s3PutReplicationConfiguration:
  case s3PutBucketObjectLockConfiguration:
    return 0x08;

  case s3All:
    return ( 0x01 | 0x02 | 0x04 | 0x08 );
  }
  return 0xFF00;
}
}

using Environment = boost::container::flat_map<std::string, std::string>;

using Address = std::bitset<128>;
struct MaskedIP {
  bool v6;
  Address addr;




  unsigned int prefix;
};

std::ostream& operator <<(std::ostream& m, const MaskedIP& ip);

inline bool operator ==(const MaskedIP& l, const MaskedIP& r) {
  auto shift = std::max((l.v6 ? 128 : 32) - ((int) l.prefix),
   (r.v6 ? 128 : 32) - ((int) r.prefix));
  do { static const ceph::assert_data assert_data_ctx = {"shift >= 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_iam_policy.h", 240, __PRETTY_FUNCTION__}; ((shift >= 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
  return (l.addr >> shift) == (r.addr >> shift);
}

struct Condition {
  TokenID op;




  std::string key;
  bool ifexists = false;




  std::vector<std::string> vals;

  Condition() = default;
  Condition(TokenID op, const char* s, std::size_t len, bool ifexists)
    : op(op), key(s, len), ifexists(ifexists) {}

  bool eval(const Environment& e) const;

  static boost::optional<double> as_number(const std::string& s) {
    std::size_t p = 0;

    try {
      double d = std::stod(s, &p);
      if (p < s.length()) {
 return boost::none;
      }

      return d;
    } catch (const std::logic_error& e) {
      return boost::none;
    }
  }

  static boost::optional<ceph::real_time> as_date(const std::string& s) {
    std::size_t p = 0;

    try {
      double d = std::stod(s, &p);
      if (p == s.length()) {
 return ceph::real_time(
   std::chrono::seconds(static_cast<uint64_t>(d)) +
   std::chrono::nanoseconds(
     static_cast<uint64_t>((d - static_cast<uint64_t>(d))
      * 1000000000)));
      }

      return from_iso_8601(boost::string_ref(s), false);
    } catch (const std::logic_error& e) {
      return boost::none;
    }
  }

  static boost::optional<bool> as_bool(const std::string& s) {
    std::size_t p = 0;

    if (s.empty() || boost::iequals(s, "false")) {
      return false;
    }

    try {
      double d = std::stod(s, &p);
      if (p == s.length()) {
 return !((d == +0.0) || (d == -0.0) || std::isnan(d));
      }
    } catch (const std::logic_error& e) {

    }

    return true;
  }

  static boost::optional<ceph::bufferlist> as_binary(const std::string& s) {

    ceph::bufferlist base64;

    base64.push_back(buffer::create_static(
         s.length(),
         const_cast<char*>(s.data())));

    ceph::bufferlist bin;

    try {
      base64.decode_base64(bin);
    } catch (const ceph::buffer::malformed_input& e) {
      return boost::none;
    }
    return bin;
  }

  static boost::optional<MaskedIP> as_network(const std::string& s);


  struct ci_equal_to {
    bool operator ()(const std::string& s1,
       const std::string& s2) const {
      return boost::iequals(s1, s2);
    }
  };

  struct string_like {
    bool operator ()(const std::string& input,
                     const std::string& pattern) const {
      return match_wildcards(pattern, input, 0);
    }
  };

  struct ci_starts_with {
    bool operator()(const std::string& s1,
      const std::string& s2) const {
      return boost::istarts_with(s1, s2);
    }
  };

  template<typename F>
  static bool orrible(F&& f, const std::string& c,
        const std::vector<std::string>& v) {
    for (const auto& d : v) {
      if (std::forward<F>(f)(c, d)) {
 return true;
      }
    }
    return false;
  }

  template<typename F, typename X>
  static bool shortible(F&& f, X& x, const std::string& c,
   const std::vector<std::string>& v) {
    auto xc = std::forward<X>(x)(c);
    if (!xc) {
      return false;
    }

    for (const auto& d : v) {
      auto xd = std::forward<X>(x)(d);
      if (!xd) {
 continue;
      }

      if (std::forward<F>(f)(*xc, *xd)) {
 return true;
      }
    }
    return false;
  }

  template <typename F>
  bool has_key_p(const std::string& _key, F p) const {
    return p(key, _key);
  }
};

std::ostream& operator <<(std::ostream& m, const Condition& c);

struct Statement {
  boost::optional<std::string> sid = boost::none;

  boost::container::flat_set<rgw::auth::Principal> princ;
  boost::container::flat_set<rgw::auth::Principal> noprinc;



  Effect effect = Effect::Deny;

  Action_t action = 0;
  NotAction_t notaction = 0;

  boost::container::flat_set<ARN> resource;
  boost::container::flat_set<ARN> notresource;

  std::vector<Condition> conditions;

  Effect eval(const Environment& e,
       boost::optional<const rgw::auth::Identity&> ida,
       std::uint64_t action, const ARN& resource) const;

  Effect eval_principal(const Environment& e,
         boost::optional<const rgw::auth::Identity&> ida) const;

  Effect eval_conditions(const Environment& e) const;
};

std::ostream& operator <<(ostream& m, const Statement& s);

struct PolicyParseException : public std::exception {
  rapidjson::ParseResult pr;

  explicit PolicyParseException(rapidjson::ParseResult&& pr)
    : pr(pr) { }
  const char* what() const noexcept override {
    return rapidjson::GetParseError_En(pr.Code());
  }
};

struct Policy {
  std::string text;
  Version version = Version::v2008_10_17;
  boost::optional<std::string> id = boost::none;

  std::vector<Statement> statements;

  Policy(CephContext* cct, const std::string& tenant,
  const bufferlist& text);

  Effect eval(const Environment& e,
       boost::optional<const rgw::auth::Identity&> ida,
       std::uint64_t action, const ARN& resource) const;

  Effect eval_principal(const Environment& e,
       boost::optional<const rgw::auth::Identity&> ida) const;

  Effect eval_conditions(const Environment& e) const;

  template <typename F>
  bool has_conditional(const string& conditional, F p) const {
    for (const auto&s: statements){
      if (std::any_of(s.conditions.begin(), s.conditions.end(),
        [&](const Condition& c) { return c.has_key_p(conditional, p);}))
 return true;
    }
    return false;
  }

  bool has_conditional(const string& c) const {
    return has_conditional(c, Condition::ci_equal_to());
  }

  bool has_partial_conditional(const string& c) const {
    return has_conditional(c, Condition::ci_starts_with());
  }
};

std::ostream& operator <<(ostream& m, const Policy& p);
}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_quota.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_quota.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/lru_map.h" 1





template <class K, class V>
class lru_map {
  struct entry {
    V value;
    typename std::list<K>::iterator lru_iter;
  };

  std::map<K, entry> entries;
  std::list<K> entries_lru;

  ceph::mutex lock = ceph::make_mutex("lru_map::lock");

  size_t max;

public:
  class UpdateContext {
    public:
      virtual ~UpdateContext() {}


      virtual bool update(V *v) = 0;
  };

  bool _find(const K& key, V *value, UpdateContext *ctx);
  void _add(const K& key, V& value);

public:
  lru_map(int _max) : max(_max) {}
  virtual ~lru_map() {}

  bool find(const K& key, V& value);







  bool find_and_update(const K& key, V *value, UpdateContext *ctx);
  void add(const K& key, V& value);
  void erase(const K& key);
};

template <class K, class V>
bool lru_map<K, V>::_find(const K& key, V *value, UpdateContext *ctx)
{
  typename std::map<K, entry>::iterator iter = entries.find(key);
  if (iter == entries.end()) {
    return false;
  }

  entry& e = iter->second;
  entries_lru.erase(e.lru_iter);

  bool r = true;

  if (ctx)
    r = ctx->update(&e.value);

  if (value)
    *value = e.value;

  entries_lru.push_front(key);
  e.lru_iter = entries_lru.begin();

  return r;
}

template <class K, class V>
bool lru_map<K, V>::find(const K& key, V& value)
{
  std::lock_guard l(lock);
  return _find(key, &value, 
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/lru_map.h" 3 4
                           __null
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/lru_map.h"
                               );
}

template <class K, class V>
bool lru_map<K, V>::find_and_update(const K& key, V *value, UpdateContext *ctx)
{
  std::lock_guard l(lock);
  return _find(key, value, ctx);
}

template <class K, class V>
void lru_map<K, V>::_add(const K& key, V& value)
{
  typename std::map<K, entry>::iterator iter = entries.find(key);
  if (iter != entries.end()) {
    entry& e = iter->second;
    entries_lru.erase(e.lru_iter);
  }

  entries_lru.push_front(key);
  entry& e = entries[key];
  e.value = value;
  e.lru_iter = entries_lru.begin();

  while (entries.size() > max) {
    typename std::list<K>::reverse_iterator riter = entries_lru.rbegin();
    iter = entries.find(*riter);

    entries.erase(iter);
    entries_lru.pop_back();
  }
}


template <class K, class V>
void lru_map<K, V>::add(const K& key, V& value)
{
  std::lock_guard l(lock);
  _add(key, value);
}

template <class K, class V>
void lru_map<K, V>::erase(const K& key)
{
  std::lock_guard l(lock);
  typename std::map<K, entry>::iterator iter = entries.find(key);
  if (iter == entries.end())
    return;

  entry& e = iter->second;
  entries_lru.erase(e.lru_iter);
  entries.erase(iter);
}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_quota.h" 2



static inline int64_t rgw_rounded_kb(int64_t bytes)
{
  return (bytes + 1023) / 1024;
}

class RGWRados;
class JSONObj;

struct RGWQuotaInfo {
  template<class T> friend class RGWQuotaCache;
protected:




  int64_t max_size_soft_threshold;
  int64_t max_objs_soft_threshold;

public:
  int64_t max_size;
  int64_t max_objects;
  bool enabled;


  bool check_on_raw;

  RGWQuotaInfo()
    : max_size_soft_threshold(-1),
      max_objs_soft_threshold(-1),
      max_size(-1),
      max_objects(-1),
      enabled(false),
      check_on_raw(false) {
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    if (max_size < 0) {
      encode(-rgw_rounded_kb(abs(max_size)), bl);
    } else {
      encode(rgw_rounded_kb(max_size), bl);
    }
    encode(max_objects, bl);
    encode(enabled, bl);
    encode(max_size, bl);
    encode(check_on_raw, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (3 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "3" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    int64_t max_size_kb;
    decode(max_size_kb, bl);
    decode(max_objects, bl);
    decode(enabled, bl);
    if (struct_v < 2) {
      max_size = max_size_kb * 1024;
    } else {
      decode(max_size, bl);
    }
    if (struct_v >= 3) {
      decode(check_on_raw, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;

  void decode_json(JSONObj *obj);

};
inline void encode(const RGWQuotaInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWQuotaInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_bucket;

class RGWQuotaHandler {
public:
  RGWQuotaHandler() {}
  virtual ~RGWQuotaHandler() {
  }
  virtual int check_quota(const rgw_user& bucket_owner, rgw_bucket& bucket,
                          RGWQuotaInfo& user_quota, RGWQuotaInfo& bucket_quota,
     uint64_t num_objs, uint64_t size) = 0;

  virtual int check_bucket_shards(uint64_t max_objs_per_shard, uint64_t num_shards,
      const rgw_user& bucket_owner, const rgw_bucket& bucket,
      RGWQuotaInfo& bucket_quota, uint64_t num_objs, bool& need_resharding,
                                  uint32_t *suggested_num_shards) = 0;

  virtual void update_stats(const rgw_user& bucket_owner, rgw_bucket& bucket, int obj_delta, uint64_t added_bytes, uint64_t removed_bytes) = 0;

  static RGWQuotaHandler *generate_handler(RGWRados *store, bool quota_threads);
  static void free_handler(RGWQuotaHandler *handler);
};


void rgw_apply_default_bucket_quota(RGWQuotaInfo& quota, const ConfigProxy& conf);
void rgw_apply_default_user_quota(RGWQuotaInfo& quota, const ConfigProxy& conf);
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/async/yield_context.h" 1
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/async/yield_context.h"
       

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/config.hpp" 1 3 4
# 996 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/config.hpp" 3 4
# 1 "/usr/include/linux/version.h" 1 3 4
# 997 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/config.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/type_traits.hpp" 1 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/type_traits.hpp" 3 4

# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/type_traits.hpp" 3 4
namespace boost {
namespace asio {


using std::add_const;
using std::conditional;
using std::decay;
using std::enable_if;
using std::false_type;
using std::integral_constant;
using std::is_base_of;
using std::is_class;
using std::is_const;
using std::is_convertible;
using std::is_function;
using std::is_same;
using std::remove_pointer;
using std::remove_reference;





using std::result_of;

using std::true_type;
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/type_traits.hpp" 3 4
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_type.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_type.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_type.hpp" 2 3 4

namespace boost {
namespace asio {
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_type.hpp" 3 4
template <typename CompletionToken, typename Signature, typename = void>
struct handler_type
{

  typedef typename conditional<
    is_same<CompletionToken, typename decay<CompletionToken>::type>::value,
    decay<CompletionToken>,
    handler_type<typename decay<CompletionToken>::type, Signature>
  >::type::type type;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_type.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 2 3 4

namespace boost {
namespace asio {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 3 4
template <typename CompletionToken, typename Signature = void>

class async_result
{
public:
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 3 4
  typedef typename handler_type<CompletionToken, Signature>::type
    completion_handler_type;



  typedef typename async_result<completion_handler_type>::type return_type;
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 3 4
  explicit async_result(completion_handler_type& h)



    : legacy_result_(h)

  {
    (void)h;
  }


  return_type get()
  {



    return legacy_result_.get();

  }

private:
  async_result(const async_result&) = delete;
  async_result& operator=(const async_result&) = delete;




  async_result<completion_handler_type> legacy_result_;

};
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 3 4
template <typename Handler>
class async_result<Handler>
{
public:

  typedef void type;







  explicit async_result(Handler&)
  {
  }


  type get()
  {
  }
};






template <typename CompletionToken, typename Signature>
struct async_completion
{

  typedef typename boost::asio::async_result<
    typename decay<CompletionToken>::type,
      Signature>::completion_handler_type completion_handler_type;







  explicit async_completion(CompletionToken& token)
    : completion_handler(static_cast<typename conditional<
        is_same<CompletionToken, completion_handler_type>::value,
        completion_handler_type&, CompletionToken&&>::type>(token)),
      result(completion_handler)
  {
  }
# 179 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 3 4
  typename conditional<
    is_same<CompletionToken, completion_handler_type>::value,
    completion_handler_type&, completion_handler_type>::type completion_handler;





  async_result<typename decay<CompletionToken>::type, Signature> result;
};

namespace detail {

template <typename CompletionToken, typename Signature>
struct async_result_helper
  : async_result<typename decay<CompletionToken>::type, Signature>
{
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 203 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/async_result.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/noncopyable.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/noncopyable.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/noncopyable.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class noncopyable
{
protected:
  noncopyable() {}
  ~noncopyable() {}
private:
  noncopyable(const noncopyable&);
  const noncopyable& operator=(const noncopyable&);
};

}

using boost::asio::detail::noncopyable;

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/noncopyable.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wrapped_handler.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wrapped_handler.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/bind_handler.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/bind_handler.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_allocator.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_allocator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_allocator.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename>
struct associated_allocator_check
{
  typedef void type;
};

template <typename T, typename E, typename = void>
struct associated_allocator_impl
{
  typedef E type;

  static type get(const T&, const E& e) noexcept
  {
    return e;
  }
};

template <typename T, typename E>
struct associated_allocator_impl<T, E,
  typename associated_allocator_check<typename T::allocator_type>::type>
{
  typedef typename T::allocator_type type;

  static type get(const T& t, const E&) noexcept
  {
    return t.get_allocator();
  }
};

}
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_allocator.hpp" 3 4
template <typename T, typename Allocator = std::allocator<void> >
struct associated_allocator
{





  typedef typename detail::associated_allocator_impl<T, Allocator>::type type;




  static type get(const T& t,
      const Allocator& a = Allocator()) noexcept
  {
    return detail::associated_allocator_impl<T, Allocator>::get(t, a);
  }
};





template <typename T>
inline typename associated_allocator<T>::type
get_associated_allocator(const T& t) noexcept
{
  return associated_allocator<T>::get(t);
}





template <typename T, typename Allocator>
inline typename associated_allocator<T, Allocator>::type
get_associated_allocator(const T& t, const Allocator& a) noexcept
{
  return associated_allocator<T, Allocator>::get(t, a);
}



template <typename T, typename Allocator = std::allocator<void> >
using associated_allocator_t
  = typename associated_allocator<T, Allocator>::type;



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 132 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_allocator.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/bind_handler.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_executor.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_executor.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_executor.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_executor.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct executor_memfns_base
{
  void context();
  void on_work_started();
  void on_work_finished();
  void dispatch();
  void post();
  void defer();
};

template <typename T>
struct executor_memfns_derived
  : T, executor_memfns_base
{
};

template <typename T, T>
struct executor_memfns_check
{
};

template <typename>
char (&context_memfn_helper(...))[2];

template <typename T>
char context_memfn_helper(
    executor_memfns_check<
      void (executor_memfns_base::*)(),
      &executor_memfns_derived<T>::context>*);

template <typename>
char (&on_work_started_memfn_helper(...))[2];

template <typename T>
char on_work_started_memfn_helper(
    executor_memfns_check<
      void (executor_memfns_base::*)(),
      &executor_memfns_derived<T>::on_work_started>*);

template <typename>
char (&on_work_finished_memfn_helper(...))[2];

template <typename T>
char on_work_finished_memfn_helper(
    executor_memfns_check<
      void (executor_memfns_base::*)(),
      &executor_memfns_derived<T>::on_work_finished>*);

template <typename>
char (&dispatch_memfn_helper(...))[2];

template <typename T>
char dispatch_memfn_helper(
    executor_memfns_check<
      void (executor_memfns_base::*)(),
      &executor_memfns_derived<T>::dispatch>*);

template <typename>
char (&post_memfn_helper(...))[2];

template <typename T>
char post_memfn_helper(
    executor_memfns_check<
      void (executor_memfns_base::*)(),
      &executor_memfns_derived<T>::post>*);

template <typename>
char (&defer_memfn_helper(...))[2];

template <typename T>
char defer_memfn_helper(
    executor_memfns_check<
      void (executor_memfns_base::*)(),
      &executor_memfns_derived<T>::defer>*);

template <typename T>
struct is_executor_class
  : integral_constant<bool,
      sizeof(context_memfn_helper<T>(0)) != 1 &&
      sizeof(on_work_started_memfn_helper<T>(0)) != 1 &&
      sizeof(on_work_finished_memfn_helper<T>(0)) != 1 &&
      sizeof(dispatch_memfn_helper<T>(0)) != 1 &&
      sizeof(post_memfn_helper<T>(0)) != 1 &&
      sizeof(defer_memfn_helper<T>(0)) != 1>
{
};

template <typename T>
struct is_executor
  : conditional<is_class<T>::value,
      is_executor_class<T>,
      false_type>::type
{
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_executor.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_executor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_executor.hpp" 2 3 4

namespace boost {
namespace asio {
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_executor.hpp" 3 4
template <typename T>
struct is_executor



  : boost::asio::detail::is_executor<T>

{
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_executor.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_executor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 2 3 4

namespace boost {
namespace asio {

class system_context;
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 3 4
class system_executor
{
public:

  system_context& context() const noexcept;





  void on_work_started() const noexcept
  {
  }





  void on_work_finished() const noexcept
  {
  }
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 3 4
  template <typename Function, typename Allocator>
  void dispatch(Function&& f, const Allocator& a) const;
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 3 4
  template <typename Function, typename Allocator>
  void post(Function&& f, const Allocator& a) const;
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 3 4
  template <typename Function, typename Allocator>
  void defer(Function&& f, const Allocator& a) const;





  friend bool operator==(const system_executor&,
      const system_executor&) noexcept
  {
    return true;
  }





  friend bool operator!=(const system_executor&,
      const system_executor&) noexcept
  {
    return false;
  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_executor.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/fenced_block.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/fenced_block.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/std_fenced_block.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/std_fenced_block.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/std_fenced_block.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class std_fenced_block
  : private noncopyable
{
public:
  enum half_t { half };
  enum full_t { full };


  explicit std_fenced_block(half_t)
  {
  }


  explicit std_fenced_block(full_t)
  {
    std::atomic_thread_fence(std::memory_order_acquire);
  }


  ~std_fenced_block()
  {
    std::atomic_thread_fence(std::memory_order_release);
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/std_fenced_block.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/fenced_block.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/fenced_block.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {





typedef std_fenced_block fenced_block;
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/fenced_block.hpp" 3 4
}
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/memory.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/memory.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {


using std::shared_ptr;
using std::weak_ptr;






using std::addressof;




}


using std::allocator_arg_t;
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/memory.hpp" 3 4
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/recycling_allocator.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/recycling_allocator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_context.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_context.hpp" 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/call_stack.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/call_stack.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/tss_ptr.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/tss_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/keyword_tss_ptr.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/keyword_tss_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/keyword_tss_ptr.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename T>
class keyword_tss_ptr
  : private noncopyable
{
public:

  keyword_tss_ptr()
  {
  }


  ~keyword_tss_ptr()
  {
  }


  operator T*() const
  {
    return value_;
  }


  void operator=(T* value)
  {
    value_ = value;
  }

private:
  static __thread T* value_;
};

template <typename T>
__thread T* keyword_tss_ptr<T>::value_;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/keyword_tss_ptr.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/tss_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/tss_ptr.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename T>
class tss_ptr



  : public keyword_tss_ptr<T>





{
public:
  void operator=(T* value)
  {



    keyword_tss_ptr<T>::operator=(value);





  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/call_stack.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/call_stack.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {



template <typename Key, typename Value = unsigned char>
class call_stack
{
public:

  class context
    : private noncopyable
  {
  public:

    explicit context(Key* k)
      : key_(k),
        next_(call_stack<Key, Value>::top_)
    {
      value_ = reinterpret_cast<unsigned char*>(this);
      call_stack<Key, Value>::top_ = this;
    }


    context(Key* k, Value& v)
      : key_(k),
        value_(&v),
        next_(call_stack<Key, Value>::top_)
    {
      call_stack<Key, Value>::top_ = this;
    }


    ~context()
    {
      call_stack<Key, Value>::top_ = next_;
    }


    Value* next_by_key() const
    {
      context* elem = next_;
      while (elem)
      {
        if (elem->key_ == key_)
          return elem->value_;
        elem = elem->next_;
      }
      return 0;
    }

  private:
    friend class call_stack<Key, Value>;


    Key* key_;


    Value* value_;


    context* next_;
  };

  friend class context;



  static Value* contains(Key* k)
  {
    context* elem = top_;
    while (elem)
    {
      if (elem->key_ == k)
        return elem->value_;
      elem = elem->next_;
    }
    return 0;
  }


  static Value* top()
  {
    context* elem = top_;
    return elem ? elem->value_ : 0;
  }

private:

  static tss_ptr<context> top_;
};

template <typename Key, typename Value>
tss_ptr<typename call_stack<Key, Value>::context>
call_stack<Key, Value>::top_;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/call_stack.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_context.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class thread_info_base;


class thread_context
{
public:

  typedef call_stack<thread_context, thread_info_base> thread_call_stack;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_context.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_info_base.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_info_base.hpp" 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_info_base.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_info_base.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class thread_info_base
  : private noncopyable
{
public:
  struct default_tag
  {
    enum { mem_index = 0 };
  };

  struct awaitee_tag
  {
    enum { mem_index = 1 };
  };

  thread_info_base()
  {
    for (int i = 0; i < max_mem_index; ++i)
      reusable_memory_[i] = 0;
  }

  ~thread_info_base()
  {
    for (int i = 0; i < max_mem_index; ++i)
      if (reusable_memory_[i])
        ::operator delete(reusable_memory_[i]);
  }

  static void* allocate(thread_info_base* this_thread, std::size_t size)
  {
    return allocate(default_tag(), this_thread, size);
  }

  static void deallocate(thread_info_base* this_thread,
      void* pointer, std::size_t size)
  {
    deallocate(default_tag(), this_thread, pointer, size);
  }

  template <typename Purpose>
  static void* allocate(Purpose, thread_info_base* this_thread,
      std::size_t size)
  {
    std::size_t chunks = (size + chunk_size - 1) / chunk_size;

    if (this_thread && this_thread->reusable_memory_[Purpose::mem_index])
    {
      void* const pointer = this_thread->reusable_memory_[Purpose::mem_index];
      this_thread->reusable_memory_[Purpose::mem_index] = 0;

      unsigned char* const mem = static_cast<unsigned char*>(pointer);
      if (static_cast<std::size_t>(mem[0]) >= chunks)
      {
        mem[size] = mem[0];
        return pointer;
      }

      ::operator delete(pointer);
    }

    void* const pointer = ::operator new(chunks * chunk_size + 1);
    unsigned char* const mem = static_cast<unsigned char*>(pointer);
    mem[size] = (chunks <= (0x7f * 2 + 1)) ? static_cast<unsigned char>(chunks) : 0;
    return pointer;
  }

  template <typename Purpose>
  static void deallocate(Purpose, thread_info_base* this_thread,
      void* pointer, std::size_t size)
  {
    if (size <= chunk_size * (0x7f * 2 + 1))
    {
      if (this_thread && this_thread->reusable_memory_[Purpose::mem_index] == 0)
      {
        unsigned char* const mem = static_cast<unsigned char*>(pointer);
        mem[0] = mem[size];
        this_thread->reusable_memory_[Purpose::mem_index] = pointer;
        return;
      }
    }

    ::operator delete(pointer);
  }

private:
  enum { chunk_size = 4 };
  enum { max_mem_index = 2 };
  void* reusable_memory_[max_mem_index];
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename T>
class recycling_allocator
{
public:
  typedef T value_type;

  template <typename U>
  struct rebind
  {
    typedef recycling_allocator<U> other;
  };

  recycling_allocator()
  {
  }

  template <typename U>
  recycling_allocator(const recycling_allocator<U>&)
  {
  }

  T* allocate(std::size_t n)
  {
    typedef thread_context::thread_call_stack call_stack;
    void* p = thread_info_base::allocate(call_stack::top(), sizeof(T) * n);
    return static_cast<T*>(p);
  }

  void deallocate(T* p, std::size_t n)
  {
    typedef thread_context::thread_call_stack call_stack;
    thread_info_base::deallocate(call_stack::top(), p, sizeof(T) * n);
  }
};

template <>
class recycling_allocator<void>
{
public:
  typedef void value_type;

  template <typename U>
  struct rebind
  {
    typedef recycling_allocator<U> other;
  };

  recycling_allocator()
  {
  }

  template <typename U>
  recycling_allocator(const recycling_allocator<U>&)
  {
  }
};

template <typename Allocator>
struct get_recycling_allocator
{
  typedef Allocator type;
  static type get(const Allocator& a) { return a; }
};

template <typename T>
struct get_recycling_allocator<std::allocator<T> >
{
  typedef recycling_allocator<T> type;
  static type get(const std::allocator<T>&) { return type(); }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 2 3 4

namespace boost {
namespace asio {
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 3 4
inline void* asio_handler_allocate(
    std::size_t size, ...);
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 3 4
inline void asio_handler_deallocate(
    void* pointer, std::size_t size, ...);

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/handler_alloc_hook.ipp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/handler_alloc_hook.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4

namespace boost {
namespace asio {

void* asio_handler_allocate(std::size_t size, ...)
{

  return detail::thread_info_base::allocate(
      detail::thread_context::thread_call_stack::top(), size);



}

void asio_handler_deallocate(void* pointer, std::size_t size, ...)
{

  detail::thread_info_base::deallocate(
      detail::thread_context::thread_call_stack::top(), pointer, size);




}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4




namespace boost_asio_handler_alloc_helpers {

template <typename Handler>
inline void* allocate(std::size_t s, Handler& h)
{



  using boost::asio::asio_handler_allocate;
  return asio_handler_allocate(s, boost::asio::detail::addressof(h));

}

template <typename Handler>
inline void deallocate(void* p, std::size_t s, Handler& h)
{



  using boost::asio::asio_handler_deallocate;
  asio_handler_deallocate(p, s, boost::asio::detail::addressof(h));

}

}

namespace boost {
namespace asio {
namespace detail {

template <typename Handler, typename T>
class hook_allocator
{
public:
  typedef T value_type;

  template <typename U>
  struct rebind
  {
    typedef hook_allocator<Handler, U> other;
  };

  explicit hook_allocator(Handler& h)
    : handler_(h)
  {
  }

  template <typename U>
  hook_allocator(const hook_allocator<Handler, U>& a)
    : handler_(a.handler_)
  {
  }

  T* allocate(std::size_t n)
  {
    return static_cast<T*>(
        boost_asio_handler_alloc_helpers::allocate(sizeof(T) * n, handler_));
  }

  void deallocate(T* p, std::size_t n)
  {
    boost_asio_handler_alloc_helpers::deallocate(p, sizeof(T) * n, handler_);
  }


  Handler& handler_;
};

template <typename Handler>
class hook_allocator<Handler, void>
{
public:
  typedef void value_type;

  template <typename U>
  struct rebind
  {
    typedef hook_allocator<Handler, U> other;
  };

  explicit hook_allocator(Handler& h)
    : handler_(h)
  {
  }

  template <typename U>
  hook_allocator(const hook_allocator<Handler, U>& a)
    : handler_(a.handler_)
  {
  }


  Handler& handler_;
};

template <typename Handler, typename Allocator>
struct get_hook_allocator
{
  typedef Allocator type;

  static type get(Handler&, const Allocator& a)
  {
    return a;
  }
};

template <typename Handler, typename T>
struct get_hook_allocator<Handler, std::allocator<T> >
{
  typedef hook_allocator<Handler, T> type;

  static type get(Handler& handler, const std::allocator<T>&)
  {
    return type(handler);
  }
};

}
}
}
# 235 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_invoke_helpers.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_invoke_helpers.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_invoke_hook.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_invoke_hook.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_invoke_hook.hpp" 2 3 4

namespace boost {
namespace asio {
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_invoke_hook.hpp" 3 4
template <typename Function>
inline void asio_handler_invoke(Function& function, ...)
{
  function();
}


template <typename Function>
inline void asio_handler_invoke(const Function& function, ...)
{
  Function tmp(function);
  tmp();
}



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_invoke_hook.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4




namespace boost_asio_handler_invoke_helpers {

template <typename Function, typename Context>
inline void invoke(Function& function, Context& context)
{




  using boost::asio::asio_handler_invoke;
  asio_handler_invoke(function, boost::asio::detail::addressof(context));

}

template <typename Function, typename Context>
inline void invoke(const Function& function, Context& context)
{




  using boost::asio::asio_handler_invoke;
  asio_handler_invoke(function, boost::asio::detail::addressof(context));

}

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_operation.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_operation.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_tracking.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_tracking.hpp" 3 4
namespace boost {
namespace asio {

class execution_context;

}
}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_tracking.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_tracking.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
# 232 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_tracking.hpp" 3 4
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_tracking.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/handler_tracking.ipp" 1 3 4
# 240 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_tracking.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/op_queue.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/op_queue.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/op_queue.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Operation>
class op_queue;

class op_queue_access
{
public:
  template <typename Operation>
  static Operation* next(Operation* o)
  {
    return static_cast<Operation*>(o->next_);
  }

  template <typename Operation1, typename Operation2>
  static void next(Operation1*& o1, Operation2* o2)
  {
    o1->next_ = o2;
  }

  template <typename Operation>
  static void destroy(Operation* o)
  {
    o->destroy();
  }

  template <typename Operation>
  static Operation*& front(op_queue<Operation>& q)
  {
    return q.front_;
  }

  template <typename Operation>
  static Operation*& back(op_queue<Operation>& q)
  {
    return q.back_;
  }
};

template <typename Operation>
class op_queue
  : private noncopyable
{
public:

  op_queue()
    : front_(0),
      back_(0)
  {
  }


  ~op_queue()
  {
    while (Operation* op = front_)
    {
      pop();
      op_queue_access::destroy(op);
    }
  }


  Operation* front()
  {
    return front_;
  }


  void pop()
  {
    if (front_)
    {
      Operation* tmp = front_;
      front_ = op_queue_access::next(front_);
      if (front_ == 0)
        back_ = 0;
      op_queue_access::next(tmp, static_cast<Operation*>(0));
    }
  }


  void push(Operation* h)
  {
    op_queue_access::next(h, static_cast<Operation*>(0));
    if (back_)
    {
      op_queue_access::next(back_, h);
      back_ = h;
    }
    else
    {
      front_ = back_ = h;
    }
  }



  template <typename OtherOperation>
  void push(op_queue<OtherOperation>& q)
  {
    if (Operation* other_front = op_queue_access::front(q))
    {
      if (back_)
        op_queue_access::next(back_, other_front);
      else
        front_ = other_front;
      back_ = op_queue_access::back(q);
      op_queue_access::front(q) = 0;
      op_queue_access::back(q) = 0;
    }
  }


  bool empty() const
  {
    return front_ == 0;
  }


  bool is_enqueued(Operation* o) const
  {
    return op_queue_access::next(o) != 0 || back_ == o;
  }

private:
  friend class op_queue_access;


  Operation* front_;


  Operation* back_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/op_queue.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class scheduler;



class scheduler_operation
{
public:
  typedef scheduler_operation operation_type;

  void complete(void* owner, const boost::system::error_code& ec,
      std::size_t bytes_transferred)
  {
    func_(owner, this, ec, bytes_transferred);
  }

  void destroy()
  {
    func_(0, this, boost::system::error_code(), 0);
  }

protected:
  typedef void (*func_type)(void*,
      scheduler_operation*,
      const boost::system::error_code&, std::size_t);

  scheduler_operation(func_type func)
    : next_(0),
      func_(func),
      task_result_(0)
  {
  }


  ~scheduler_operation()
  {
  }

private:
  friend class op_queue_access;
  scheduler_operation* next_;
  func_type func_;
protected:
  friend class scheduler;
  unsigned int task_result_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler, typename Alloc,
    typename Operation = scheduler_operation>
class executor_op : public Operation
{
public:
  struct ptr { const Alloc* a; void* v; executor_op* p; ~ptr() { reset(); } static executor_op* allocate(const Alloc& a) { typedef typename ::boost::asio::detail::get_recycling_allocator< Alloc>::type recycling_allocator_type; typename std::allocator_traits<recycling_allocator_type>::template rebind_alloc<executor_op> a1( ::boost::asio::detail::get_recycling_allocator<Alloc>::get(a)); return a1.allocate(1); } void reset() { if (p) { p->~executor_op(); p = 0; } if (v) { typedef typename ::boost::asio::detail::get_recycling_allocator< Alloc>::type recycling_allocator_type; typename std::allocator_traits<recycling_allocator_type>::template rebind_alloc<executor_op> a1( ::boost::asio::detail::get_recycling_allocator<Alloc>::get(*a)); a1.deallocate(static_cast<executor_op*>(v), 1); v = 0; } } };

  template <typename H>
  executor_op(H&& h, const Alloc& allocator)
    : Operation(&executor_op::do_complete),
      handler_(static_cast<H&&>(h)),
      allocator_(allocator)
  {
  }

  static void do_complete(void* owner, Operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    executor_op* o(static_cast<executor_op*>(base));
    Alloc allocator(o->allocator_);
    ptr p = { detail::addressof(allocator), o, o };

    (void)0;







    Handler handler(static_cast<Handler&&>(o->handler_));
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      boost_asio_handler_invoke_helpers::invoke(handler, handler);
      (void)0;
    }
  }

private:
  Handler handler_;
  Alloc allocator_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/executor_op.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_executor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/global.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/global.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_global.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_global.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_global.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename T>
struct posix_global_impl
{

  static void do_init()
  {
    instance_.static_ptr_ = instance_.ptr_ = new T;
  }


  ~posix_global_impl()
  {
    delete static_ptr_;
  }

  static ::pthread_once_t init_once_;
  static T* static_ptr_;
  static posix_global_impl instance_;
  T* ptr_;
};

template <typename T>
::pthread_once_t posix_global_impl<T>::init_once_ = 0;

template <typename T>
T* posix_global_impl<T>::static_ptr_ = 0;

template <typename T>
posix_global_impl<T> posix_global_impl<T>::instance_;

template <typename T>
T& posix_global()
{
  int result = ::pthread_once(
      &posix_global_impl<T>::init_once_,
      &posix_global_impl<T>::do_init);

  if (result != 0)
    std::terminate();

  return *posix_global_impl<T>::instance_.ptr_;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_global.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/global.hpp" 2 3 4






namespace boost {
namespace asio {
namespace detail {

template <typename T>
inline T& global()
{





  return posix_global<T>();



}

}
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_executor.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/variadic_templates.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 2 3 4

namespace boost {
namespace asio {

class execution_context;
class io_context;


template <typename Service> Service& use_service(execution_context&);
template <typename Service> Service& use_service(io_context&);
template <typename Service> void add_service(execution_context&, Service*);
template <typename Service> bool has_service(execution_context&);


namespace detail { class service_registry; }
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
class execution_context
  : private noncopyable
{
public:
  class id;
  class service;

protected:

  inline execution_context();


  inline ~execution_context();
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  inline void shutdown();
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  inline void destroy();

public:

  enum fork_event
  {

    fork_prepare,


    fork_parent,


    fork_child
  };
# 194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  inline void notify_fork(fork_event event);
# 207 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  template <typename Service>
  friend Service& use_service(execution_context& e);
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  template <typename Service>
  friend Service& use_service(io_context& ioc);
# 246 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  template <typename Service, typename... Args>
  friend Service& make_service(execution_context& e,
      Args&&... args);
# 284 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  template <typename Service>
  friend void add_service(execution_context& e, Service* svc);
# 297 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 3 4
  template <typename Service>
  friend bool has_service(execution_context& e);

private:

  boost::asio::detail::service_registry* service_registry_;
};


class execution_context::id
  : private noncopyable
{
public:

  id() {}
};


class execution_context::service
  : private noncopyable
{
public:

  execution_context& context();

protected:




  inline service(execution_context& owner);


  inline virtual ~service();

private:

  virtual void shutdown() = 0;







  inline virtual void notify_fork(
      execution_context::fork_event event);

  friend class boost::asio::detail::service_registry;
  struct key
  {
    key() : type_info_(0), id_(0) {}
    const std::type_info* type_info_;
    const execution_context::id* id_;
  } key_;

  execution_context& owner_;
  service* next_;
};



class service_already_exists
  : public std::logic_error
{
public:
  inline service_already_exists();
};



class invalid_service_owner
  : public std::logic_error
{
public:
  inline invalid_service_owner();
};

namespace detail {


template <typename Type>
class service_id
  : public execution_context::id
{
};


template <typename Type>
class execution_context_service_base
  : public execution_context::service
{
public:
  static service_id<Type> id;


  execution_context_service_base(execution_context& e)
    : execution_context::service(e)
  {
  }
};

template <typename Type>
service_id<Type> execution_context_service_base<Type>::id;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 407 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_type_requirements.hpp" 1 3 4
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {





template <typename Handler>
auto zero_arg_copyable_handler_test(Handler h, void*)
  -> decltype(
    sizeof(Handler(static_cast<const Handler&>(h))),
    ((h)()),
    char(0));

template <typename Handler>
char (&zero_arg_copyable_handler_test(Handler, ...))[2];

template <typename Handler, typename Arg1>
auto one_arg_handler_test(Handler h, Arg1* a1)
  -> decltype(
    sizeof(Handler(static_cast<Handler&&>(h))),
    ((h)(*a1)),
    char(0));

template <typename Handler>
char (&one_arg_handler_test(Handler h, ...))[2];

template <typename Handler, typename Arg1, typename Arg2>
auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
  -> decltype(
    sizeof(Handler(static_cast<Handler&&>(h))),
    ((h)(*a1, *a2)),
    char(0));

template <typename Handler>
char (&two_arg_handler_test(Handler, ...))[2];

template <typename Handler, typename Arg1, typename Arg2>
auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2)
  -> decltype(
    sizeof(Handler(static_cast<Handler&&>(h))),
    ((h)(*a1, static_cast<Arg2&&>(*a2))),
    char(0));

template <typename Handler>
char (&two_arg_move_handler_test(Handler, ...))[2];
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
template <typename T> T& lvref();
template <typename T> T& lvref(T);
template <typename T> const T& clvref();
template <typename T> const T& clvref(T);

template <typename T> T rvref();
template <typename T> T rvref(T);




template <typename T> char argbyv(T);

template <int>
struct handler_type_requirements
{
};
# 554 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
}
}
}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_ptr.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_ptr.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename T>
class scoped_ptr
{
public:

  explicit scoped_ptr(T* p = 0)
    : p_(p)
  {
  }


  ~scoped_ptr()
  {
    delete p_;
  }


  T* get()
  {
    return p_;
  }


  T* operator->()
  {
    return p_;
  }


  T& operator*()
  {
    return *p_;
  }


  void reset(T* p = 0)
  {
    delete p_;
    p_ = p;
  }


  T* release()
  {
    T* tmp = p_;
    p_ = 0;
    return tmp;
  }

private:

  scoped_ptr(const scoped_ptr&);
  scoped_ptr& operator=(const scoped_ptr&);

  T* p_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_ptr.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/mutex.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_mutex.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_lock.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_lock.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_lock.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


template <typename Mutex>
class scoped_lock
  : private noncopyable
{
public:

  enum adopt_lock_t { adopt_lock };


  scoped_lock(Mutex& m, adopt_lock_t)
    : mutex_(m),
      locked_(true)
  {
  }


  explicit scoped_lock(Mutex& m)
    : mutex_(m)
  {
    mutex_.lock();
    locked_ = true;
  }


  ~scoped_lock()
  {
    if (locked_)
      mutex_.unlock();
  }


  void lock()
  {
    if (!locked_)
    {
      mutex_.lock();
      locked_ = true;
    }
  }


  void unlock()
  {
    if (locked_)
    {
      mutex_.unlock();
      locked_ = false;
    }
  }


  bool locked() const
  {
    return locked_;
  }


  Mutex& mutex()
  {
    return mutex_;
  }

private:

  Mutex& mutex_;


  bool locked_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scoped_lock.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_mutex.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_mutex.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class posix_event;

class posix_mutex
  : private noncopyable
{
public:
  typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;


  inline posix_mutex();


  ~posix_mutex()
  {
    ::pthread_mutex_destroy(&mutex_);
  }


  void lock()
  {
    (void)::pthread_mutex_lock(&mutex_);
  }


  void unlock()
  {
    (void)::pthread_mutex_unlock(&mutex_);
  }

private:
  friend class posix_event;
  ::pthread_mutex_t mutex_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_mutex.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_mutex.ipp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_mutex.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_mutex.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_error.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_error.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_error.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

inline void do_throw_error(const boost::system::error_code& err);

inline void do_throw_error(const boost::system::error_code& err,
    const char* location);

inline void throw_error(const boost::system::error_code& err)
{
  if (err)
    do_throw_error(err);
}

inline void throw_error(const boost::system::error_code& err,
    const char* location)
{
  if (err)
    do_throw_error(err, location);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_error.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/throw_error.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/throw_error.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_error.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_exception.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_exception.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {


using boost::throw_exception;
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_exception.hpp" 3 4
}
}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

void do_throw_error(const boost::system::error_code& err)
{
  boost::system::system_error e(err);
  boost::asio::detail::throw_exception(e);
}

void do_throw_error(const boost::system::error_code& err, const char* location)
{
  boost::system::system_error e(err, location);
  boost::asio::detail::throw_exception(e);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/throw_error.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 3 4
# 1 "/usr/include/c++/10/cerrno" 1 3 4
# 39 "/usr/include/c++/10/cerrno" 3 4
       
# 40 "/usr/include/c++/10/cerrno" 3
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 2 3 4
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 2 3 4

namespace boost {
namespace asio {
namespace error {

enum basic_errors
{

  access_denied = 13,


  address_family_not_supported = 97,


  address_in_use = 98,


  already_connected = 106,


  already_started = 114,


  broken_pipe = 32

                                     ,


  connection_aborted = 103,


  connection_refused = 111,


  connection_reset = 104,


  bad_descriptor = 9,


  fault = 14,


  host_unreachable = 113,


  in_progress = 115,


  interrupted = 4,


  invalid_argument = 22,


  message_size = 90,


  name_too_long = 36,


  network_down = 100,


  network_reset = 102,


  network_unreachable = 101,


  no_descriptors = 24,


  no_buffer_space = 105,


  no_memory = 12

                                      ,


  no_permission = 1

                                     ,


  no_protocol_option = 92,


  no_such_device = 19

                                      ,


  not_connected = 107,


  not_socket = 88,


  operation_aborted = 125

                                         ,


  operation_not_supported = 95,


  shut_down = 108,


  timed_out = 110,


  try_again = 11

                                      ,


  would_block = 11
};

enum netdb_errors
{

  host_not_found = 1,


  host_not_found_try_again = 2,


  no_data = 4,


  no_recovery = 3
};

enum addrinfo_errors
{

  service_not_found = -8

                                                ,


  socket_type_not_supported = -7


};

enum misc_errors
{

  already_open = 1,


  eof,


  not_found,


  fd_set_failure
};

inline const boost::system::error_category& get_system_category()
{
  return boost::system::system_category();
}



extern inline
const boost::system::error_category& get_netdb_category();

extern inline
const boost::system::error_category& get_addrinfo_category();
# 255 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 3 4
extern inline
const boost::system::error_category& get_misc_category();

static const boost::system::error_category&
  system_category __attribute__((__unused__))
  = boost::asio::error::get_system_category();
static const boost::system::error_category&
  netdb_category __attribute__((__unused__))
  = boost::asio::error::get_netdb_category();
static const boost::system::error_category&
  addrinfo_category __attribute__((__unused__))
  = boost::asio::error::get_addrinfo_category();
static const boost::system::error_category&
  misc_category __attribute__((__unused__))
  = boost::asio::error::get_misc_category();

}
}
}

namespace boost {
namespace system {

template<> struct is_error_code_enum<boost::asio::error::basic_errors>
{
  static const bool value = true;
};

template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
{
  static const bool value = true;
};

template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
{
  static const bool value = true;
};

template<> struct is_error_code_enum<boost::asio::error::misc_errors>
{
  static const bool value = true;
};

}
}

namespace boost {
namespace asio {
namespace error {

inline boost::system::error_code make_error_code(basic_errors e)
{
  return boost::system::error_code(
      static_cast<int>(e), get_system_category());
}

inline boost::system::error_code make_error_code(netdb_errors e)
{
  return boost::system::error_code(
      static_cast<int>(e), get_netdb_category());
}

inline boost::system::error_code make_error_code(addrinfo_errors e)
{
  return boost::system::error_code(
      static_cast<int>(e), get_addrinfo_category());
}

inline boost::system::error_code make_error_code(misc_errors e)
{
  return boost::system::error_code(
      static_cast<int>(e), get_misc_category());
}

}
namespace stream_errc {

  using error::eof;
  using error::not_found;
}
namespace socket_errc {

  using error::already_open;
  using error::not_found;
}
namespace resolver_errc {

  using error::host_not_found;
  const error::netdb_errors try_again = error::host_not_found_try_again;
  using error::service_not_found;
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 350 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 2 3 4
# 358 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/error.ipp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/error.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/error.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/error.ipp" 2 3 4

namespace boost {
namespace asio {
namespace error {



namespace detail {

class netdb_category : public boost::system::error_category
{
public:
  const char* name() const noexcept
  {
    return "asio.netdb";
  }

  std::string message(int value) const
  {
    if (value == error::host_not_found)
      return "Host not found (authoritative)";
    if (value == error::host_not_found_try_again)
      return "Host not found (non-authoritative), try again later";
    if (value == error::no_data)
      return "The query is valid, but it does not have associated data";
    if (value == error::no_recovery)
      return "A non-recoverable error occurred during database lookup";
    return "asio.netdb error";
  }
};

}

const boost::system::error_category& get_netdb_category()
{
  static detail::netdb_category instance;
  return instance;
}

namespace detail {

class addrinfo_category : public boost::system::error_category
{
public:
  const char* name() const noexcept
  {
    return "asio.addrinfo";
  }

  std::string message(int value) const
  {
    if (value == error::service_not_found)
      return "Service not found";
    if (value == error::socket_type_not_supported)
      return "Socket type not supported";
    return "asio.addrinfo error";
  }
};

}

const boost::system::error_category& get_addrinfo_category()
{
  static detail::addrinfo_category instance;
  return instance;
}



namespace detail {

class misc_category : public boost::system::error_category
{
public:
  const char* name() const noexcept
  {
    return "asio.misc";
  }

  std::string message(int value) const
  {
    if (value == error::already_open)
      return "Already open";
    if (value == error::eof)
      return "End of file";
    if (value == error::not_found)
      return "Element not found";
    if (value == error::fd_set_failure)
      return "The descriptor does not fit into the select call's fd_set";
    return "asio.misc error";
  }
};

}

const boost::system::error_category& get_misc_category()
{
  static detail::misc_category instance;
  return instance;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/error.ipp" 2 3 4
# 359 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/error.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

posix_mutex::posix_mutex()
{
  int error = ::pthread_mutex_init(&mutex_, 0);
  boost::system::error_code ec(error,
      boost::asio::error::get_system_category());
  boost::asio::detail::throw_error(ec, "mutex");
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/mutex.hpp" 2 3 4






namespace boost {
namespace asio {
namespace detail {






typedef posix_mutex mutex;




}
}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 2 3 4

namespace boost {
namespace asio {

class io_context;

namespace detail {

template <typename T>
class typeid_wrapper {};

class service_registry
  : private noncopyable
{
public:

  inline service_registry(execution_context& owner);


  inline ~service_registry();


  inline void shutdown_services();


  inline void destroy_services();


  inline void notify_fork(execution_context::fork_event fork_ev);




  template <typename Service>
  Service& use_service();






  template <typename Service>
  Service& use_service(io_context& owner);



  template <typename Service>
  void add_service(Service* new_service);


  template <typename Service>
  bool has_service() const;

private:

  template <typename Service>
  static void init_key(execution_context::service::key& key, ...);



  template <typename Service>
  static void init_key(execution_context::service::key& key,
      typename enable_if<
        is_base_of<typename Service::key_type, Service>::value>::type*);



  inline static void init_key_from_id(
      execution_context::service::key& key,
      const execution_context::id& id);



  template <typename Service>
  static void init_key_from_id(execution_context::service::key& key,
      const service_id<Service>& );



  inline static bool keys_match(
      const execution_context::service::key& key1,
      const execution_context::service::key& key2);


  typedef execution_context::service*(*factory_type)(void*);


  template <typename Service, typename Owner>
  static execution_context::service* create(void* owner);


  inline static void destroy(execution_context::service* service);


  struct auto_service_ptr;
  friend struct auto_service_ptr;
  struct auto_service_ptr
  {
    execution_context::service* ptr_;
    ~auto_service_ptr() { destroy(ptr_); }
  };




  inline execution_context::service* do_use_service(
      const execution_context::service::key& key,
      factory_type factory, void* owner);



  inline void do_add_service(
      const execution_context::service::key& key,
      execution_context::service* new_service);


  inline bool do_has_service(
      const execution_context::service::key& key) const;


  mutable boost::asio::detail::mutex mutex_;


  execution_context& owner_;


  execution_context::service* first_service_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 160 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Service>
Service& service_registry::use_service()
{
  execution_context::service::key key;
  init_key<Service>(key, 0);
  factory_type factory = &service_registry::create<Service, execution_context>;
  return *static_cast<Service*>(do_use_service(key, factory, &owner_));
}

template <typename Service>
Service& service_registry::use_service(io_context& owner)
{
  execution_context::service::key key;
  init_key<Service>(key, 0);
  factory_type factory = &service_registry::create<Service, io_context>;
  return *static_cast<Service*>(do_use_service(key, factory, &owner));
}

template <typename Service>
void service_registry::add_service(Service* new_service)
{
  execution_context::service::key key;
  init_key<Service>(key, 0);
  return do_add_service(key, new_service);
}

template <typename Service>
bool service_registry::has_service() const
{
  execution_context::service::key key;
  init_key<Service>(key, 0);
  return do_has_service(key);
}

template <typename Service>
inline void service_registry::init_key(
    execution_context::service::key& key, ...)
{
  init_key_from_id(key, Service::id);
}


template <typename Service>
void service_registry::init_key(execution_context::service::key& key,
    typename enable_if<
      is_base_of<typename Service::key_type, Service>::value>::type*)
{
  key.type_info_ = &typeid(typeid_wrapper<Service>);
  key.id_ = 0;
}

template <typename Service>
void service_registry::init_key_from_id(execution_context::service::key& key,
    const service_id<Service>& )
{
  key.type_info_ = &typeid(typeid_wrapper<Service>);
  key.id_ = 0;
}


template <typename Service, typename Owner>
execution_context::service* service_registry::create(void* owner)
{
  return new Service(*static_cast<Owner*>(owner));
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.hpp" 2 3 4
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.ipp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

service_registry::service_registry(execution_context& owner)
  : owner_(owner),
    first_service_(0)
{
}

service_registry::~service_registry()
{
}

void service_registry::shutdown_services()
{
  execution_context::service* service = first_service_;
  while (service)
  {
    service->shutdown();
    service = service->next_;
  }
}

void service_registry::destroy_services()
{
  while (first_service_)
  {
    execution_context::service* next_service = first_service_->next_;
    destroy(first_service_);
    first_service_ = next_service;
  }
}

void service_registry::notify_fork(execution_context::fork_event fork_ev)
{



  std::vector<execution_context::service*> services;
  {
    boost::asio::detail::mutex::scoped_lock lock(mutex_);
    execution_context::service* service = first_service_;
    while (service)
    {
      services.push_back(service);
      service = service->next_;
    }
  }





  std::size_t num_services = services.size();
  if (fork_ev == execution_context::fork_prepare)
    for (std::size_t i = 0; i < num_services; ++i)
      services[i]->notify_fork(fork_ev);
  else
    for (std::size_t i = num_services; i > 0; --i)
      services[i - 1]->notify_fork(fork_ev);
}

void service_registry::init_key_from_id(execution_context::service::key& key,
    const execution_context::id& id)
{
  key.type_info_ = 0;
  key.id_ = &id;
}

bool service_registry::keys_match(
    const execution_context::service::key& key1,
    const execution_context::service::key& key2)
{
  if (key1.id_ && key2.id_)
    if (key1.id_ == key2.id_)
      return true;
  if (key1.type_info_ && key2.type_info_)
    if (*key1.type_info_ == *key2.type_info_)
      return true;
  return false;
}

void service_registry::destroy(execution_context::service* service)
{
  delete service;
}

execution_context::service* service_registry::do_use_service(
    const execution_context::service::key& key,
    factory_type factory, void* owner)
{
  boost::asio::detail::mutex::scoped_lock lock(mutex_);


  execution_context::service* service = first_service_;
  while (service)
  {
    if (keys_match(service->key_, key))
      return service;
    service = service->next_;
  }




  lock.unlock();
  auto_service_ptr new_service = { factory(owner) };
  new_service.ptr_->key_ = key;
  lock.lock();



  service = first_service_;
  while (service)
  {
    if (keys_match(service->key_, key))
      return service;
    service = service->next_;
  }


  new_service.ptr_->next_ = first_service_;
  first_service_ = new_service.ptr_;
  new_service.ptr_ = 0;
  return first_service_;
}

void service_registry::do_add_service(
    const execution_context::service::key& key,
    execution_context::service* new_service)
{
  if (&owner_ != &new_service->context())
    boost::asio::detail::throw_exception(invalid_service_owner());

  boost::asio::detail::mutex::scoped_lock lock(mutex_);


  execution_context::service* service = first_service_;
  while (service)
  {
    if (keys_match(service->key_, key))
      boost::asio::detail::throw_exception(service_already_exists());
    service = service->next_;
  }


  new_service->key_ = key;
  new_service->next_ = first_service_;
  first_service_ = new_service;
}

bool service_registry::do_has_service(
    const execution_context::service::key& key) const
{
  boost::asio::detail::mutex::scoped_lock lock(mutex_);

  execution_context::service* service = first_service_;
  while (service)
  {
    if (keys_match(service->key_, key))
      return true;
    service = service->next_;
  }

  return false;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 198 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4
# 164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/service_registry.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename Service>
inline Service& use_service(execution_context& e)
{

  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));

  return e.service_registry_->template use_service<Service>();
}




template <typename Service, typename... Args>
Service& make_service(execution_context& e, Args&&... args)
{
  detail::scoped_ptr<Service> svc(
      new Service(e, static_cast<Args&&>(args)...));
  e.service_registry_->template add_service<Service>(svc.get());
  Service& result = *svc;
  svc.release();
  return result;
}
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 3 4
template <typename Service>
inline void add_service(execution_context& e, Service* svc)
{

  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));

  e.service_registry_->template add_service<Service>(svc);
}

template <typename Service>
inline bool has_service(execution_context& e)
{

  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));

  return e.service_registry_->template has_service<Service>();
}

inline execution_context& execution_context::service::context()
{
  return owner_;
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.hpp" 2 3 4
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.ipp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.ipp" 2 3 4

namespace boost {
namespace asio {

execution_context::execution_context()
  : service_registry_(new boost::asio::detail::service_registry(*this))
{
}

execution_context::~execution_context()
{
  shutdown();
  destroy();
  delete service_registry_;
}

void execution_context::shutdown()
{
  service_registry_->shutdown_services();
}

void execution_context::destroy()
{
  service_registry_->destroy_services();
}

void execution_context::notify_fork(
    boost::asio::execution_context::fork_event event)
{
  service_registry_->notify_fork(event);
}

execution_context::service::service(execution_context& owner)
  : owner_(owner),
    next_(0)
{
}

execution_context::service::~service()
{
}

void execution_context::service::notify_fork(execution_context::fork_event)
{
}

service_already_exists::service_already_exists()
  : std::logic_error("Service already exists.")
{
}

invalid_service_owner::invalid_service_owner()
  : std::logic_error("Invalid service owner.")
{
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/execution_context.ipp" 2 3 4
# 411 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/execution_context.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/atomic_count.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/atomic_count.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {





typedef std::atomic<long> atomic_count;
inline void increment(atomic_count& a, long b) { a += b; }





}
}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_event.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_event.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


class conditionally_enabled_mutex
  : private noncopyable
{
public:

  class scoped_lock
    : private noncopyable
  {
  public:

    enum adopt_lock_t { adopt_lock };


    scoped_lock(conditionally_enabled_mutex& m, adopt_lock_t)
      : mutex_(m),
        locked_(m.enabled_)
    {
    }


    explicit scoped_lock(conditionally_enabled_mutex& m)
      : mutex_(m)
    {
      if (m.enabled_)
      {
        mutex_.mutex_.lock();
        locked_ = true;
      }
      else
        locked_ = false;
    }


    ~scoped_lock()
    {
      if (locked_)
        mutex_.mutex_.unlock();
    }


    void lock()
    {
      if (mutex_.enabled_ && !locked_)
      {
        mutex_.mutex_.lock();
        locked_ = true;
      }
    }


    void unlock()
    {
      if (locked_)
      {
        mutex_.unlock();
        locked_ = false;
      }
    }


    bool locked() const
    {
      return locked_;
    }


    boost::asio::detail::mutex& mutex()
    {
      return mutex_.mutex_;
    }

  private:
    friend class conditionally_enabled_event;
    conditionally_enabled_mutex& mutex_;
    bool locked_;
  };


  explicit conditionally_enabled_mutex(bool enabled)
    : enabled_(enabled)
  {
  }


  ~conditionally_enabled_mutex()
  {
  }


  bool enabled() const
  {
    return enabled_;
  }


  void lock()
  {
    if (enabled_)
      mutex_.lock();
  }


  void unlock()
  {
    if (enabled_)
      mutex_.unlock();
  }

private:
  friend class scoped_lock;
  friend class conditionally_enabled_event;
  boost::asio::detail::mutex mutex_;
  const bool enabled_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/event.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/event.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/assert.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/assert.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/assert.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class posix_event
  : private noncopyable
{
public:

  inline posix_event();


  ~posix_event()
  {
    ::pthread_cond_destroy(&cond_);
  }


  template <typename Lock>
  void signal(Lock& lock)
  {
    this->signal_all(lock);
  }


  template <typename Lock>
  void signal_all(Lock& lock)
  {
    (static_cast<void> (0));
    (void)lock;
    state_ |= 1;
    ::pthread_cond_broadcast(&cond_);
  }


  template <typename Lock>
  void unlock_and_signal_one(Lock& lock)
  {
    (static_cast<void> (0));
    state_ |= 1;
    bool have_waiters = (state_ > 1);
    lock.unlock();
    if (have_waiters)
      ::pthread_cond_signal(&cond_);
  }


  template <typename Lock>
  bool maybe_unlock_and_signal_one(Lock& lock)
  {
    (static_cast<void> (0));
    state_ |= 1;
    if (state_ > 1)
    {
      lock.unlock();
      ::pthread_cond_signal(&cond_);
      return true;
    }
    return false;
  }


  template <typename Lock>
  void clear(Lock& lock)
  {
    (static_cast<void> (0));
    (void)lock;
    state_ &= ~std::size_t(1);
  }


  template <typename Lock>
  void wait(Lock& lock)
  {
    (static_cast<void> (0));
    while ((state_ & 1) == 0)
    {
      state_ += 2;
      ::pthread_cond_wait(&cond_, &lock.mutex().mutex_);
      state_ -= 2;
    }
  }


  template <typename Lock>
  bool wait_for_usec(Lock& lock, long usec)
  {
    (static_cast<void> (0));
    if ((state_ & 1) == 0)
    {
      state_ += 2;
      timespec ts;
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 3 4
      if (::clock_gettime(1, &ts) == 0)
      {
        ts.tv_sec += usec / 1000000;
        ts.tv_nsec = (usec % 1000000) * 1000;
        ts.tv_sec += ts.tv_nsec / 1000000000;
        ts.tv_nsec = ts.tv_nsec % 1000000000;
        ::pthread_cond_timedwait(&cond_,
            &lock.mutex().mutex_, &ts);
      }



      state_ -= 2;
    }
    return (state_ & 1) != 0;
  }

private:
  ::pthread_cond_t cond_;
  std::size_t state_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_event.ipp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_event.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

posix_event::posix_event()
  : state_(0)
{





  ::pthread_condattr_t attr;
  ::pthread_condattr_init(&attr);
  int error = ::pthread_condattr_setclock(&attr, 1);
  if (error == 0)
    error = ::pthread_cond_init(&cond_, &attr);



  boost::system::error_code ec(error,
      boost::asio::error::get_system_category());
  boost::asio::detail::throw_error(ec, "event");
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
# 160 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_event.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/event.hpp" 2 3 4






namespace boost {
namespace asio {
namespace detail {






typedef posix_event event;




}
}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/null_event.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/null_event.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/null_event.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class null_event
  : private noncopyable
{
public:

  null_event()
  {
  }


  ~null_event()
  {
  }


  template <typename Lock>
  void signal(Lock&)
  {
  }


  template <typename Lock>
  void signal_all(Lock&)
  {
  }


  template <typename Lock>
  void unlock_and_signal_one(Lock&)
  {
  }


  template <typename Lock>
  bool maybe_unlock_and_signal_one(Lock&)
  {
    return false;
  }


  template <typename Lock>
  void clear(Lock&)
  {
  }


  template <typename Lock>
  void wait(Lock&)
  {
    do_wait();
  }


  template <typename Lock>
  bool wait_for_usec(Lock&, long usec)
  {
    do_wait_for_usec(usec);
    return true;
  }

private:
  inline static void do_wait();
  inline static void do_wait_for_usec(long usec);
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/null_event.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/null_event.ipp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/null_event.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/null_event.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

void null_event::do_wait()
{





  ::pause();

}

void null_event::do_wait_for_usec(long usec)
{
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/null_event.ipp" 3 4
  timeval tv;
  tv.tv_sec = usec / 1000000;
  tv.tv_usec = usec % 1000000;
  ::select(0, 0, 0, 0, &tv);

}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/null_event.ipp" 2 3 4
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/null_event.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


class conditionally_enabled_event
  : private noncopyable
{
public:

  conditionally_enabled_event()
  {
  }


  ~conditionally_enabled_event()
  {
  }


  void signal(conditionally_enabled_mutex::scoped_lock& lock)
  {
    if (lock.mutex_.enabled_)
      event_.signal(lock);
  }


  void signal_all(conditionally_enabled_mutex::scoped_lock& lock)
  {
    if (lock.mutex_.enabled_)
      event_.signal_all(lock);
  }


  void unlock_and_signal_one(
      conditionally_enabled_mutex::scoped_lock& lock)
  {
    if (lock.mutex_.enabled_)
      event_.unlock_and_signal_one(lock);
  }


  bool maybe_unlock_and_signal_one(
      conditionally_enabled_mutex::scoped_lock& lock)
  {
    if (lock.mutex_.enabled_)
      return event_.maybe_unlock_and_signal_one(lock);
    else
      return false;
  }


  void clear(conditionally_enabled_mutex::scoped_lock& lock)
  {
    if (lock.mutex_.enabled_)
      event_.clear(lock);
  }


  void wait(conditionally_enabled_mutex::scoped_lock& lock)
  {
    if (lock.mutex_.enabled_)
      event_.wait(lock);
    else
      null_event().wait(lock);
  }


  bool wait_for_usec(
      conditionally_enabled_mutex::scoped_lock& lock, long usec)
  {
    if (lock.mutex_.enabled_)
      return event_.wait_for_usec(lock, usec);
    else
      return null_event().wait_for_usec(lock, usec);
  }

private:
  boost::asio::detail::event event_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_fwd.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_fwd.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {






typedef class epoll_reactor reactor;
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_fwd.hpp" 3 4
}
}
}
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct scheduler_thread_info;

class scheduler
  : public execution_context_service_base<scheduler>,
    public thread_context
{
public:
  typedef scheduler_operation operation;



  inline scheduler(boost::asio::execution_context& ctx,
      int concurrency_hint = 0);


  inline void shutdown();


  inline void init_task();


  inline std::size_t run(boost::system::error_code& ec);


  inline std::size_t run_one(boost::system::error_code& ec);


  inline std::size_t wait_one(
      long usec, boost::system::error_code& ec);


  inline std::size_t poll(boost::system::error_code& ec);


  inline std::size_t poll_one(boost::system::error_code& ec);


  inline void stop();


  inline bool stopped() const;


  inline void restart();


  void work_started()
  {
    ++outstanding_work_;
  }



  inline void compensating_work_started();


  void work_finished()
  {
    if (--outstanding_work_ == 0)
      stop();
  }


  bool can_dispatch()
  {
    return thread_call_stack::contains(this) != 0;
  }



  inline void post_immediate_completion(
      operation* op, bool is_continuation);



  inline void post_deferred_completion(operation* op);



  inline void post_deferred_completions(op_queue<operation>& ops);



  inline void do_dispatch(operation* op);



  inline void abandon_operations(op_queue<operation>& ops);


  int concurrency_hint() const
  {
    return concurrency_hint_;
  }

private:

  typedef conditionally_enabled_mutex mutex;


  typedef conditionally_enabled_event event;


  typedef scheduler_thread_info thread_info;


  inline std::size_t do_run_one(mutex::scoped_lock& lock,
      thread_info& this_thread, const boost::system::error_code& ec);


  inline std::size_t do_wait_one(mutex::scoped_lock& lock,
      thread_info& this_thread, long usec, const boost::system::error_code& ec);


  inline std::size_t do_poll_one(mutex::scoped_lock& lock,
      thread_info& this_thread, const boost::system::error_code& ec);


  inline void stop_all_threads(mutex::scoped_lock& lock);


  inline void wake_one_thread_and_unlock(
      mutex::scoped_lock& lock);


  struct task_cleanup;
  friend struct task_cleanup;


  struct work_cleanup;
  friend struct work_cleanup;


  const bool one_thread_;


  mutable mutex mutex_;


  event wakeup_event_;


  reactor* task_;


  struct task_operation : operation
  {
    task_operation() : operation(0) {}
  } task_operation_;


  bool task_interrupted_;


  atomic_count outstanding_work_;


  op_queue<operation> op_queue_;


  bool stopped_;


  bool shutdown_;


  const int concurrency_hint_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/concurrency_hint.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/limits.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/object_pool.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/object_pool.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/object_pool.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Object>
class object_pool;

class object_pool_access
{
public:
  template <typename Object>
  static Object* create()
  {
    return new Object;
  }

  template <typename Object, typename Arg>
  static Object* create(Arg arg)
  {
    return new Object(arg);
  }

  template <typename Object>
  static void destroy(Object* o)
  {
    delete o;
  }

  template <typename Object>
  static Object*& next(Object* o)
  {
    return o->next_;
  }

  template <typename Object>
  static Object*& prev(Object* o)
  {
    return o->prev_;
  }
};

template <typename Object>
class object_pool
  : private noncopyable
{
public:

  object_pool()
    : live_list_(0),
      free_list_(0)
  {
  }


  ~object_pool()
  {
    destroy_list(live_list_);
    destroy_list(free_list_);
  }


  Object* first()
  {
    return live_list_;
  }


  Object* alloc()
  {
    Object* o = free_list_;
    if (o)
      free_list_ = object_pool_access::next(free_list_);
    else
      o = object_pool_access::create<Object>();

    object_pool_access::next(o) = live_list_;
    object_pool_access::prev(o) = 0;
    if (live_list_)
      object_pool_access::prev(live_list_) = o;
    live_list_ = o;

    return o;
  }


  template <typename Arg>
  Object* alloc(Arg arg)
  {
    Object* o = free_list_;
    if (o)
      free_list_ = object_pool_access::next(free_list_);
    else
      o = object_pool_access::create<Object>(arg);

    object_pool_access::next(o) = live_list_;
    object_pool_access::prev(o) = 0;
    if (live_list_)
      object_pool_access::prev(live_list_) = o;
    live_list_ = o;

    return o;
  }


  void free(Object* o)
  {
    if (live_list_ == o)
      live_list_ = object_pool_access::next(o);

    if (object_pool_access::prev(o))
    {
      object_pool_access::next(object_pool_access::prev(o))
        = object_pool_access::next(o);
    }

    if (object_pool_access::next(o))
    {
      object_pool_access::prev(object_pool_access::next(o))
        = object_pool_access::prev(o);
    }

    object_pool_access::next(o) = free_list_;
    object_pool_access::prev(o) = 0;
    free_list_ = o;
  }

private:

  void destroy_list(Object* list)
  {
    while (list)
    {
      Object* o = list;
      list = object_pool_access::next(o);
      object_pool_access::destroy(o);
    }
  }


  Object* live_list_;


  Object* free_list_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 172 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/object_pool.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_op.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/operation.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/operation.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {




typedef scheduler_operation operation;


}
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_op.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class reactor_op
  : public operation
{
public:

  boost::system::error_code ec_;


  std::size_t bytes_transferred_;



  enum status { not_done, done, done_and_exhausted };


  status perform()
  {
    return perform_func_(this);
  }

protected:
  typedef status (*perform_func_type)(reactor_op*);

  reactor_op(perform_func_type perform_func, func_type complete_func)
    : operation(complete_func),
      bytes_transferred_(0),
      perform_func_(perform_func)
  {
  }

private:
  perform_func_type perform_func_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor_op.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/select_interrupter.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/select_interrupter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/eventfd_select_interrupter.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/eventfd_select_interrupter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class eventfd_select_interrupter
{
public:

  inline eventfd_select_interrupter();


  inline ~eventfd_select_interrupter();


  inline void recreate();


  inline void interrupt();


  inline bool reset();


  int read_descriptor() const
  {
    return read_descriptor_;
  }

private:

  inline void open_descriptors();


  inline void close_descriptors();





  int read_descriptor_;





  int write_descriptor_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 3 4
# 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) throw ();


extern int eventfd_read (int __fd, eventfd_t *__value);


extern int eventfd_write (int __fd, eventfd_t __value);

}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/cstdint.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/cstdint.hpp" 3 4
namespace boost {
namespace asio {


using std::int16_t;
using std::int_least16_t;
using std::uint16_t;
using std::uint_least16_t;
using std::int32_t;
using std::int_least32_t;
using std::uint32_t;
using std::uint_least32_t;
using std::int64_t;
using std::int_least64_t;
using std::uint64_t;
using std::uint_least64_t;
using std::uintmax_t;
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/cstdint.hpp" 3 4
}
}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/eventfd_select_interrupter.hpp" 1 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

eventfd_select_interrupter::eventfd_select_interrupter()
{
  open_descriptors();
}

void eventfd_select_interrupter::open_descriptors()
{
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 3 4
  write_descriptor_ = read_descriptor_ =
    ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);




  if (read_descriptor_ == -1 && (*__errno_location ()) == 22)
  {
    write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
    if (read_descriptor_ != -1)
    {
      ::fcntl(read_descriptor_, 4, 04000);
      ::fcntl(read_descriptor_, 2, 1);
    }
  }


  if (read_descriptor_ == -1)
  {
    int pipe_fds[2];
    if (pipe(pipe_fds) == 0)
    {
      read_descriptor_ = pipe_fds[0];
      ::fcntl(read_descriptor_, 4, 04000);
      ::fcntl(read_descriptor_, 2, 1);
      write_descriptor_ = pipe_fds[1];
      ::fcntl(write_descriptor_, 4, 04000);
      ::fcntl(write_descriptor_, 2, 1);
    }
    else
    {
      boost::system::error_code ec((*__errno_location ()),
          boost::asio::error::get_system_category());
      boost::asio::detail::throw_error(ec, "eventfd_select_interrupter");
    }
  }
}

eventfd_select_interrupter::~eventfd_select_interrupter()
{
  close_descriptors();
}

void eventfd_select_interrupter::close_descriptors()
{
  if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_)
    ::close(write_descriptor_);
  if (read_descriptor_ != -1)
    ::close(read_descriptor_);
}

void eventfd_select_interrupter::recreate()
{
  close_descriptors();

  write_descriptor_ = -1;
  read_descriptor_ = -1;

  open_descriptors();
}

void eventfd_select_interrupter::interrupt()
{
  uint64_t counter(1UL);
  int result = ::write(write_descriptor_, &counter, sizeof(uint64_t));
  (void)result;
}

bool eventfd_select_interrupter::reset()
{
  if (write_descriptor_ == read_descriptor_)
  {
    for (;;)
    {

      uint64_t counter(0);
      (*__errno_location ()) = 0;
      int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
      if (bytes_read < 0 && (*__errno_location ()) == 4)
        continue;
      bool was_interrupted = (bytes_read > 0);
      return was_interrupted;
    }
  }
  else
  {
    for (;;)
    {

      char data[1024];
      int bytes_read = ::read(read_descriptor_, data, sizeof(data));
      if (bytes_read < 0 && (*__errno_location ()) == 4)
        continue;
      bool was_interrupted = (bytes_read > 0);
      while (bytes_read == sizeof(data))
        bytes_read = ::read(read_descriptor_, data, sizeof(data));
      return was_interrupted;
    }
  }
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/select_interrupter.hpp" 2 3 4




namespace boost {
namespace asio {
namespace detail {




typedef eventfd_select_interrupter select_interrupter;




}
}
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 3 4
# 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, ...) throw ();

}
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4




# 1 "/usr/include/poll.h" 1 3 4
# 1 "/usr/include/sys/poll.h" 1 3 4
# 25 "/usr/include/sys/poll.h" 3 4
# 1 "/usr/include/bits/poll.h" 1 3 4
# 26 "/usr/include/sys/poll.h" 2 3 4







typedef unsigned long int nfds_t;


struct pollfd
  {
    int fd;
    short int events;
    short int revents;
  };


extern "C" {
# 54 "/usr/include/sys/poll.h" 3 4
extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);
# 63 "/usr/include/sys/poll.h" 3 4
extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
    const struct timespec *__timeout,
    const __sigset_t *__ss);


}




# 1 "/usr/include/bits/poll2.h" 1 3 4
# 24 "/usr/include/bits/poll2.h" 3 4
extern "C" {

extern int __poll_alias (struct pollfd *__fds, nfds_t __nfds, int __timeout) __asm__ ("" "poll")
                               ;
extern int __poll_chk (struct pollfd *__fds, nfds_t __nfds, int __timeout,
         long unsigned int __fdslen);
extern int __poll_chk_warn (struct pollfd *__fds, nfds_t __nfds, int __timeout, long unsigned int __fdslen) __asm__ ("" "__poll_chk")


  __attribute__((__warning__ ("poll called with fds buffer too small file nfds entries")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
poll (struct pollfd *__fds, nfds_t __nfds, int __timeout)
{
  if (__builtin_object_size (__fds, 2 > 1) != (long unsigned int) -1)
    {
      if (! __builtin_constant_p (__nfds))
 return __poll_chk (__fds, __nfds, __timeout, __builtin_object_size (__fds, 2 > 1));
      else if (__builtin_object_size (__fds, 2 > 1) / sizeof (*__fds) < __nfds)
 return __poll_chk_warn (__fds, __nfds, __timeout, __builtin_object_size (__fds, 2 > 1));
    }

  return __poll_alias (__fds, __nfds, __timeout);
}



extern int __ppoll_alias (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, const __sigset_t *__ss) __asm__ ("" "ppoll")

                                          ;
extern int __ppoll_chk (struct pollfd *__fds, nfds_t __nfds,
   const struct timespec *__timeout,
   const __sigset_t *__ss, long unsigned int __fdslen);
extern int __ppoll_chk_warn (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, const __sigset_t *__ss, long unsigned int __fdslen) __asm__ ("" "__ppoll_chk")




  __attribute__((__warning__ ("ppoll called with fds buffer too small file nfds entries")));

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) int
ppoll (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout,
       const __sigset_t *__ss)
{
  if (__builtin_object_size (__fds, 2 > 1) != (long unsigned int) -1)
    {
      if (! __builtin_constant_p (__nfds))
 return __ppoll_chk (__fds, __nfds, __timeout, __ss, __builtin_object_size (__fds, 2 > 1));
      else if (__builtin_object_size (__fds, 2 > 1) / sizeof (*__fds) < __nfds)
 return __ppoll_chk_warn (__fds, __nfds, __timeout, __ss,
     __builtin_object_size (__fds, 2 > 1));
    }

  return __ppoll_alias (__fds, __nfds, __timeout, __ss);
}


}
# 74 "/usr/include/sys/poll.h" 2 3 4
# 2 "/usr/include/poll.h" 2 3 4
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 3 4
# 1 "/usr/include/sys/un.h" 1 3 4
# 26 "/usr/include/sys/un.h" 3 4
extern "C" {


struct sockaddr_un
  {
    sa_family_t sun_family;
    char sun_path[108];
  };
# 44 "/usr/include/sys/un.h" 3 4
}
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4


# 1 "/usr/include/netinet/tcp.h" 1 3 4
# 93 "/usr/include/netinet/tcp.h" 3 4
typedef uint32_t tcp_seq;




struct tcphdr
  {
    __extension__ union
    {
      struct
      {
 uint16_t th_sport;
 uint16_t th_dport;
 tcp_seq th_seq;
 tcp_seq th_ack;

 uint8_t th_x2:4;
 uint8_t th_off:4;





 uint8_t th_flags;






 uint16_t th_win;
 uint16_t th_sum;
 uint16_t th_urp;
      };
      struct
      {
 uint16_t source;
 uint16_t dest;
 uint32_t seq;
 uint32_t ack_seq;

 uint16_t res1:4;
 uint16_t doff:4;
 uint16_t fin:1;
 uint16_t syn:1;
 uint16_t rst:1;
 uint16_t psh:1;
 uint16_t ack:1;
 uint16_t urg:1;
 uint16_t res2:2;
# 156 "/usr/include/netinet/tcp.h" 3 4
 uint16_t window;
 uint16_t check;
 uint16_t urg_ptr;
      };
    };
};

enum
{
  TCP_ESTABLISHED = 1,
  TCP_SYN_SENT,
  TCP_SYN_RECV,
  TCP_FIN_WAIT1,
  TCP_FIN_WAIT2,
  TCP_TIME_WAIT,
  TCP_CLOSE,
  TCP_CLOSE_WAIT,
  TCP_LAST_ACK,
  TCP_LISTEN,
  TCP_CLOSING
};
# 217 "/usr/include/netinet/tcp.h" 3 4
enum tcp_ca_state
{
  TCP_CA_Open = 0,
  TCP_CA_Disorder = 1,
  TCP_CA_CWR = 2,
  TCP_CA_Recovery = 3,
  TCP_CA_Loss = 4
};

struct tcp_info
{
  uint8_t tcpi_state;
  uint8_t tcpi_ca_state;
  uint8_t tcpi_retransmits;
  uint8_t tcpi_probes;
  uint8_t tcpi_backoff;
  uint8_t tcpi_options;
  uint8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;

  uint32_t tcpi_rto;
  uint32_t tcpi_ato;
  uint32_t tcpi_snd_mss;
  uint32_t tcpi_rcv_mss;

  uint32_t tcpi_unacked;
  uint32_t tcpi_sacked;
  uint32_t tcpi_lost;
  uint32_t tcpi_retrans;
  uint32_t tcpi_fackets;


  uint32_t tcpi_last_data_sent;
  uint32_t tcpi_last_ack_sent;
  uint32_t tcpi_last_data_recv;
  uint32_t tcpi_last_ack_recv;


  uint32_t tcpi_pmtu;
  uint32_t tcpi_rcv_ssthresh;
  uint32_t tcpi_rtt;
  uint32_t tcpi_rttvar;
  uint32_t tcpi_snd_ssthresh;
  uint32_t tcpi_snd_cwnd;
  uint32_t tcpi_advmss;
  uint32_t tcpi_reordering;

  uint32_t tcpi_rcv_rtt;
  uint32_t tcpi_rcv_space;

  uint32_t tcpi_total_retrans;
};
# 276 "/usr/include/netinet/tcp.h" 3 4
struct tcp_md5sig
{
  struct sockaddr_storage tcpm_addr;
  uint8_t tcpm_flags;
  uint8_t tcpm_prefixlen;
  uint16_t tcpm_keylen;
  uint32_t __tcpm_pad;
  uint8_t tcpm_key[80];
};


struct tcp_repair_opt
{
  uint32_t opt_code;
  uint32_t opt_val;
};


enum
{
  TCP_NO_QUEUE,
  TCP_RECV_QUEUE,
  TCP_SEND_QUEUE,
  TCP_QUEUES_NR,
};
# 319 "/usr/include/netinet/tcp.h" 3 4
struct tcp_cookie_transactions
{
  uint16_t tcpct_flags;
  uint8_t __tcpct_pad1;
  uint8_t tcpct_cookie_desired;
  uint16_t tcpct_s_data_desired;
  uint16_t tcpct_used;
  uint8_t tcpct_value[536U];
};


struct tcp_repair_window
{
  uint32_t snd_wl1;
  uint32_t snd_wnd;
  uint32_t max_window;
  uint32_t rcv_wnd;
  uint32_t rcv_wup;
};


struct tcp_zerocopy_receive
{
  uint64_t address;
  uint32_t length;
  uint32_t recv_skip_hint;
};
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4



# 1 "/usr/include/net/if.h" 1 3 4
# 33 "/usr/include/net/if.h" 3 4
struct if_nameindex
  {
    unsigned int if_index;
    char *if_name;
  };




enum
  {
    IFF_UP = 0x1,

    IFF_BROADCAST = 0x2,

    IFF_DEBUG = 0x4,

    IFF_LOOPBACK = 0x8,

    IFF_POINTOPOINT = 0x10,

    IFF_NOTRAILERS = 0x20,

    IFF_RUNNING = 0x40,

    IFF_NOARP = 0x80,

    IFF_PROMISC = 0x100,



    IFF_ALLMULTI = 0x200,


    IFF_MASTER = 0x400,

    IFF_SLAVE = 0x800,


    IFF_MULTICAST = 0x1000,


    IFF_PORTSEL = 0x2000,

    IFF_AUTOMEDIA = 0x4000,

    IFF_DYNAMIC = 0x8000

  };






struct ifaddr
  {
    struct sockaddr ifa_addr;
    union
      {
 struct sockaddr ifu_broadaddr;
 struct sockaddr ifu_dstaddr;
      } ifa_ifu;
    struct iface *ifa_ifp;
    struct ifaddr *ifa_next;
  };
# 111 "/usr/include/net/if.h" 3 4
struct ifmap
  {
    unsigned long int mem_start;
    unsigned long int mem_end;
    unsigned short int base_addr;
    unsigned char irq;
    unsigned char dma;
    unsigned char port;

  };





struct ifreq
  {


    union
      {
 char ifrn_name[16];
      } ifr_ifrn;

    union
      {
 struct sockaddr ifru_addr;
 struct sockaddr ifru_dstaddr;
 struct sockaddr ifru_broadaddr;
 struct sockaddr ifru_netmask;
 struct sockaddr ifru_hwaddr;
 short int ifru_flags;
 int ifru_ivalue;
 int ifru_mtu;
 struct ifmap ifru_map;
 char ifru_slave[16];
 char ifru_newname[16];
 __caddr_t ifru_data;
      } ifr_ifru;
  };
# 176 "/usr/include/net/if.h" 3 4
struct ifconf
  {
    int ifc_len;
    union
      {
 __caddr_t ifcu_buf;
 struct ifreq *ifcu_req;
      } ifc_ifcu;
  };





extern "C" {


extern unsigned int if_nametoindex (const char *__ifname) throw ();
extern char *if_indextoname (unsigned int __ifindex, char *__ifname) throw ();


extern struct if_nameindex *if_nameindex (void) throw ();


extern void if_freenameindex (struct if_nameindex *__ptr) throw ();

}
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
# 289 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 3 4
typedef int socket_type;
const int invalid_socket = -1;
const int socket_error_retval = -1;
const int max_addr_v4_str_len = 16;

const int max_addr_v6_str_len = 46 + 1 + 16;



typedef sockaddr socket_addr_type;
typedef in_addr in4_addr_type;
# 308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 3 4
typedef ip_mreq in4_mreq_type;

typedef sockaddr_in sockaddr_in4_type;
typedef in6_addr in6_addr_type;
typedef ipv6_mreq in6_mreq_type;
typedef sockaddr_in6 sockaddr_in6_type;
typedef sockaddr_storage sockaddr_storage_type;
typedef sockaddr_un sockaddr_un_type;
typedef addrinfo addrinfo_type;
typedef ::linger linger_type;
typedef int ioctl_arg_type;
typedef uint32_t u_long_type;
typedef uint16_t u_short_type;

typedef ssize_t signed_size_type;
# 402 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 3 4
const int max_iov_len = 1024;





const int custom_socket_option_level = 0xA5100000;
const int enable_connection_aborted_option = 1;
const int always_fail_option = 2;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_types.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_base.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_base.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class timer_queue_base
  : private noncopyable
{
public:

  timer_queue_base() : next_(0) {}


  virtual ~timer_queue_base() {}


  virtual bool empty() const = 0;


  virtual long wait_duration_msec(long max_duration) const = 0;


  virtual long wait_duration_usec(long max_duration) const = 0;


  virtual void get_ready_timers(op_queue<operation>& ops) = 0;


  virtual void get_all_timers(op_queue<operation>& ops) = 0;

private:
  friend class timer_queue_set;


  timer_queue_base* next_;
};

template <typename Time_Traits>
class timer_queue;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_base.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_set.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_set.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class timer_queue_set
{
public:

  inline timer_queue_set();


  inline void insert(timer_queue_base* q);


  inline void erase(timer_queue_base* q);


  inline bool all_empty() const;


  inline long wait_duration_msec(long max_duration) const;


  inline long wait_duration_usec(long max_duration) const;


  inline void get_ready_timers(op_queue<operation>& ops);


  inline void get_all_timers(op_queue<operation>& ops);

private:
  timer_queue_base* first_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_set.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_set.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_set.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

timer_queue_set::timer_queue_set()
  : first_(0)
{
}

void timer_queue_set::insert(timer_queue_base* q)
{
  q->next_ = first_;
  first_ = q;
}

void timer_queue_set::erase(timer_queue_base* q)
{
  if (first_)
  {
    if (q == first_)
    {
      first_ = q->next_;
      q->next_ = 0;
      return;
    }

    for (timer_queue_base* p = first_; p->next_; p = p->next_)
    {
      if (p->next_ == q)
      {
        p->next_ = q->next_;
        q->next_ = 0;
        return;
      }
    }
  }
}

bool timer_queue_set::all_empty() const
{
  for (timer_queue_base* p = first_; p; p = p->next_)
    if (!p->empty())
      return false;
  return true;
}

long timer_queue_set::wait_duration_msec(long max_duration) const
{
  long min_duration = max_duration;
  for (timer_queue_base* p = first_; p; p = p->next_)
    min_duration = p->wait_duration_msec(min_duration);
  return min_duration;
}

long timer_queue_set::wait_duration_usec(long max_duration) const
{
  long min_duration = max_duration;
  for (timer_queue_base* p = first_; p; p = p->next_)
    min_duration = p->wait_duration_usec(min_duration);
  return min_duration;
}

void timer_queue_set::get_ready_timers(op_queue<operation>& ops)
{
  for (timer_queue_base* p = first_; p; p = p->next_)
    p->get_ready_timers(ops);
}

void timer_queue_set::get_all_timers(op_queue<operation>& ops)
{
  for (timer_queue_base* p = first_; p; p = p->next_)
    p->get_all_timers(ops);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_op.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class wait_op
  : public operation
{
public:

  boost::system::error_code ec_;

protected:
  wait_op(func_type func)
    : operation(func)
  {
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_op.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4



# 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) throw ();




extern int timerfd_settime (int __ufd, int __flags,
       const struct itimerspec *__utmr,
       struct itimerspec *__otmr) throw ();


extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) throw ();

}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class epoll_reactor
  : public execution_context_service_base<epoll_reactor>
{
private:

  typedef conditionally_enabled_mutex mutex;

public:
  enum op_types { read_op = 0, write_op = 1,
    connect_op = 1, except_op = 2, max_ops = 3 };


  class descriptor_state : operation
  {
    friend class epoll_reactor;
    friend class object_pool_access;

    descriptor_state* next_;
    descriptor_state* prev_;

    mutex mutex_;
    epoll_reactor* reactor_;
    int descriptor_;
    uint32_t registered_events_;
    op_queue<reactor_op> op_queue_[max_ops];
    bool try_speculative_[max_ops];
    bool shutdown_;

    inline descriptor_state(bool locking);
    void set_ready_events(uint32_t events) { task_result_ = events; }
    void add_ready_events(uint32_t events) { task_result_ |= events; }
    inline operation* perform_io(uint32_t events);
    inline static void do_complete(
        void* owner, operation* base,
        const boost::system::error_code& ec, std::size_t bytes_transferred);
  };


  typedef descriptor_state* per_descriptor_data;


  inline epoll_reactor(boost::asio::execution_context& ctx);


  inline ~epoll_reactor();


  inline void shutdown();


  inline void notify_fork(
      boost::asio::execution_context::fork_event fork_ev);


  inline void init_task();



  inline int register_descriptor(socket_type descriptor,
      per_descriptor_data& descriptor_data);



  inline int register_internal_descriptor(
      int op_type, socket_type descriptor,
      per_descriptor_data& descriptor_data, reactor_op* op);


  inline void move_descriptor(socket_type descriptor,
      per_descriptor_data& target_descriptor_data,
      per_descriptor_data& source_descriptor_data);


  void post_immediate_completion(reactor_op* op, bool is_continuation)
  {
    scheduler_.post_immediate_completion(op, is_continuation);
  }



  inline void start_op(int op_type, socket_type descriptor,
      per_descriptor_data& descriptor_data, reactor_op* op,
      bool is_continuation, bool allow_speculative);




  inline void cancel_ops(socket_type descriptor,
      per_descriptor_data& descriptor_data);




  inline void deregister_descriptor(socket_type descriptor,
      per_descriptor_data& descriptor_data, bool closing);




  inline void deregister_internal_descriptor(
      socket_type descriptor, per_descriptor_data& descriptor_data);



  inline void cleanup_descriptor_data(
      per_descriptor_data& descriptor_data);


  template <typename Time_Traits>
  void add_timer_queue(timer_queue<Time_Traits>& timer_queue);


  template <typename Time_Traits>
  void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);



  template <typename Time_Traits>
  void schedule_timer(timer_queue<Time_Traits>& queue,
      const typename Time_Traits::time_type& time,
      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);



  template <typename Time_Traits>
  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
      typename timer_queue<Time_Traits>::per_timer_data& timer,
      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());


  template <typename Time_Traits>
  void move_timer(timer_queue<Time_Traits>& queue,
      typename timer_queue<Time_Traits>::per_timer_data& target,
      typename timer_queue<Time_Traits>::per_timer_data& source);


  inline void run(long usec, op_queue<operation>& ops);


  inline void interrupt();

private:

  enum { epoll_size = 20000 };



  inline static int do_epoll_create();


  inline static int do_timerfd_create();


  inline descriptor_state* allocate_descriptor_state();


  inline void free_descriptor_state(descriptor_state* s);


  inline void do_add_timer_queue(timer_queue_base& queue);


  inline void do_remove_timer_queue(timer_queue_base& queue);


  inline void update_timeout();




  inline int get_timeout(int msec);




  inline int get_timeout(itimerspec& ts);



  scheduler& scheduler_;


  mutex mutex_;


  select_interrupter interrupter_;


  int epoll_fd_;


  int timer_fd_;


  timer_queue_set timer_queues_;


  bool shutdown_;


  mutex registered_descriptors_mutex_;


  object_pool<descriptor_state> registered_descriptors_;


  struct perform_io_cleanup_on_block_exit;
  friend struct perform_io_cleanup_on_block_exit;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 260 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Time_Traits>
void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
{
  do_add_timer_queue(queue);
}

template <typename Time_Traits>
void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
{
  do_remove_timer_queue(queue);
}

template <typename Time_Traits>
void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
    const typename Time_Traits::time_type& time,
    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
{
  mutex::scoped_lock lock(mutex_);

  if (shutdown_)
  {
    scheduler_.post_immediate_completion(op, false);
    return;
  }

  bool earliest = queue.enqueue_timer(time, timer, op);
  scheduler_.work_started();
  if (earliest)
    update_timeout();
}

template <typename Time_Traits>
std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
    typename timer_queue<Time_Traits>::per_timer_data& timer,
    std::size_t max_cancelled)
{
  mutex::scoped_lock lock(mutex_);
  op_queue<operation> ops;
  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
  lock.unlock();
  scheduler_.post_deferred_completions(ops);
  return n;
}

template <typename Time_Traits>
void epoll_reactor::move_timer(timer_queue<Time_Traits>& queue,
    typename timer_queue<Time_Traits>::per_timer_data& target,
    typename timer_queue<Time_Traits>::per_timer_data& source)
{
  mutex::scoped_lock lock(mutex_);
  op_queue<operation> ops;
  queue.cancel_timer(target, ops);
  queue.move_timer(target, source);
  lock.unlock();
  scheduler_.post_deferred_completions(ops);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.hpp" 2 3 4
# 262 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.ipp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.ipp" 3 4
# 1 "/usr/include/sys/epoll.h" 1 3 4
# 27 "/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

  };
# 28 "/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

  };
# 75 "/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) throw ();



extern int epoll_create1 (int __flags) throw ();
# 109 "/usr/include/sys/epoll.h" 3 4
extern int epoll_ctl (int __epfd, int __op, int __fd,
        struct epoll_event *__event) throw ();
# 123 "/usr/include/sys/epoll.h" 3 4
extern int epoll_wait (int __epfd, struct epoll_event *__events,
         int __maxevents, int __timeout);







extern int epoll_pwait (int __epfd, struct epoll_event *__events,
   int __maxevents, int __timeout,
   const __sigset_t *__ss);

}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

epoll_reactor::epoll_reactor(boost::asio::execution_context& ctx)
  : execution_context_service_base<epoll_reactor>(ctx),
    scheduler_(use_service<scheduler>(ctx)),
    mutex_((((static_cast<unsigned>(scheduler_.concurrency_hint()) & (0xFFFF0000u | 0x2u)) ^ 0xA5100000u) != 0)
                                                              ),
    interrupter_(),
    epoll_fd_(do_epoll_create()),
    timer_fd_(do_timerfd_create()),
    shutdown_(false),
    registered_descriptors_mutex_(mutex_.enabled())
{

  epoll_event ev = { 0, { 0 } };
  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
  ev.data.ptr = &interrupter_;
  epoll_ctl(epoll_fd_, 1, interrupter_.read_descriptor(), &ev);
  interrupter_.interrupt();


  if (timer_fd_ != -1)
  {
    ev.events = EPOLLIN | EPOLLERR;
    ev.data.ptr = &timer_fd_;
    epoll_ctl(epoll_fd_, 1, timer_fd_, &ev);
  }
}

epoll_reactor::~epoll_reactor()
{
  if (epoll_fd_ != -1)
    close(epoll_fd_);
  if (timer_fd_ != -1)
    close(timer_fd_);
}

void epoll_reactor::shutdown()
{
  mutex::scoped_lock lock(mutex_);
  shutdown_ = true;
  lock.unlock();

  op_queue<operation> ops;

  while (descriptor_state* state = registered_descriptors_.first())
  {
    for (int i = 0; i < max_ops; ++i)
      ops.push(state->op_queue_[i]);
    state->shutdown_ = true;
    registered_descriptors_.free(state);
  }

  timer_queues_.get_all_timers(ops);

  scheduler_.abandon_operations(ops);
}

void epoll_reactor::notify_fork(
    boost::asio::execution_context::fork_event fork_ev)
{
  if (fork_ev == boost::asio::execution_context::fork_child)
  {
    if (epoll_fd_ != -1)
      ::close(epoll_fd_);
    epoll_fd_ = -1;
    epoll_fd_ = do_epoll_create();

    if (timer_fd_ != -1)
      ::close(timer_fd_);
    timer_fd_ = -1;
    timer_fd_ = do_timerfd_create();

    interrupter_.recreate();


    epoll_event ev = { 0, { 0 } };
    ev.events = EPOLLIN | EPOLLERR | EPOLLET;
    ev.data.ptr = &interrupter_;
    epoll_ctl(epoll_fd_, 1, interrupter_.read_descriptor(), &ev);
    interrupter_.interrupt();


    if (timer_fd_ != -1)
    {
      ev.events = EPOLLIN | EPOLLERR;
      ev.data.ptr = &timer_fd_;
      epoll_ctl(epoll_fd_, 1, timer_fd_, &ev);
    }

    update_timeout();


    mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
    for (descriptor_state* state = registered_descriptors_.first();
        state != 0; state = state->next_)
    {
      ev.events = state->registered_events_;
      ev.data.ptr = state;
      int result = epoll_ctl(epoll_fd_, 1, state->descriptor_, &ev);
      if (result != 0)
      {
        boost::system::error_code ec((*__errno_location ()),
            boost::asio::error::get_system_category());
        boost::asio::detail::throw_error(ec, "epoll re-registration");
      }
    }
  }
}

void epoll_reactor::init_task()
{
  scheduler_.init_task();
}

int epoll_reactor::register_descriptor(socket_type descriptor,
    epoll_reactor::per_descriptor_data& descriptor_data)
{
  descriptor_data = allocate_descriptor_state();

  (void)0

                                                      ;

  {
    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);

    descriptor_data->reactor_ = this;
    descriptor_data->descriptor_ = descriptor;
    descriptor_data->shutdown_ = false;
    for (int i = 0; i < max_ops; ++i)
      descriptor_data->try_speculative_[i] = true;
  }

  epoll_event ev = { 0, { 0 } };
  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
  descriptor_data->registered_events_ = ev.events;
  ev.data.ptr = descriptor_data;
  int result = epoll_ctl(epoll_fd_, 1, descriptor, &ev);
  if (result != 0)
  {
    if ((*__errno_location ()) == 1)
    {




      descriptor_data->registered_events_ = 0;
      return 0;
    }
    return (*__errno_location ());
  }

  return 0;
}

int epoll_reactor::register_internal_descriptor(
    int op_type, socket_type descriptor,
    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
{
  descriptor_data = allocate_descriptor_state();

  (void)0

                                                      ;

  {
    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);

    descriptor_data->reactor_ = this;
    descriptor_data->descriptor_ = descriptor;
    descriptor_data->shutdown_ = false;
    descriptor_data->op_queue_[op_type].push(op);
    for (int i = 0; i < max_ops; ++i)
      descriptor_data->try_speculative_[i] = true;
  }

  epoll_event ev = { 0, { 0 } };
  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
  descriptor_data->registered_events_ = ev.events;
  ev.data.ptr = descriptor_data;
  int result = epoll_ctl(epoll_fd_, 1, descriptor, &ev);
  if (result != 0)
    return (*__errno_location ());

  return 0;
}

void epoll_reactor::move_descriptor(socket_type,
    epoll_reactor::per_descriptor_data& target_descriptor_data,
    epoll_reactor::per_descriptor_data& source_descriptor_data)
{
  target_descriptor_data = source_descriptor_data;
  source_descriptor_data = 0;
}

void epoll_reactor::start_op(int op_type, socket_type descriptor,
    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
    bool is_continuation, bool allow_speculative)
{
  if (!descriptor_data)
  {
    op->ec_ = boost::asio::error::bad_descriptor;
    post_immediate_completion(op, is_continuation);
    return;
  }

  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);

  if (descriptor_data->shutdown_)
  {
    post_immediate_completion(op, is_continuation);
    return;
  }

  if (descriptor_data->op_queue_[op_type].empty())
  {
    if (allow_speculative
        && (op_type != read_op
          || descriptor_data->op_queue_[except_op].empty()))
    {
      if (descriptor_data->try_speculative_[op_type])
      {
        if (reactor_op::status status = op->perform())
        {
          if (status == reactor_op::done_and_exhausted)
            if (descriptor_data->registered_events_ != 0)
              descriptor_data->try_speculative_[op_type] = false;
          descriptor_lock.unlock();
          scheduler_.post_immediate_completion(op, is_continuation);
          return;
        }
      }

      if (descriptor_data->registered_events_ == 0)
      {
        op->ec_ = boost::asio::error::operation_not_supported;
        scheduler_.post_immediate_completion(op, is_continuation);
        return;
      }

      if (op_type == write_op)
      {
        if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
        {
          epoll_event ev = { 0, { 0 } };
          ev.events = descriptor_data->registered_events_ | EPOLLOUT;
          ev.data.ptr = descriptor_data;
          if (epoll_ctl(epoll_fd_, 3, descriptor, &ev) == 0)
          {
            descriptor_data->registered_events_ |= ev.events;
          }
          else
          {
            op->ec_ = boost::system::error_code((*__errno_location ()),
                boost::asio::error::get_system_category());
            scheduler_.post_immediate_completion(op, is_continuation);
            return;
          }
        }
      }
    }
    else if (descriptor_data->registered_events_ == 0)
    {
      op->ec_ = boost::asio::error::operation_not_supported;
      scheduler_.post_immediate_completion(op, is_continuation);
      return;
    }
    else
    {
      if (op_type == write_op)
      {
        descriptor_data->registered_events_ |= EPOLLOUT;
      }

      epoll_event ev = { 0, { 0 } };
      ev.events = descriptor_data->registered_events_;
      ev.data.ptr = descriptor_data;
      epoll_ctl(epoll_fd_, 3, descriptor, &ev);
    }
  }

  descriptor_data->op_queue_[op_type].push(op);
  scheduler_.work_started();
}

void epoll_reactor::cancel_ops(socket_type,
    epoll_reactor::per_descriptor_data& descriptor_data)
{
  if (!descriptor_data)
    return;

  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);

  op_queue<operation> ops;
  for (int i = 0; i < max_ops; ++i)
  {
    while (reactor_op* op = descriptor_data->op_queue_[i].front())
    {
      op->ec_ = boost::asio::error::operation_aborted;
      descriptor_data->op_queue_[i].pop();
      ops.push(op);
    }
  }

  descriptor_lock.unlock();

  scheduler_.post_deferred_completions(ops);
}

void epoll_reactor::deregister_descriptor(socket_type descriptor,
    epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
{
  if (!descriptor_data)
    return;

  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);

  if (!descriptor_data->shutdown_)
  {
    if (closing)
    {


    }
    else if (descriptor_data->registered_events_ != 0)
    {
      epoll_event ev = { 0, { 0 } };
      epoll_ctl(epoll_fd_, 2, descriptor, &ev);
    }

    op_queue<operation> ops;
    for (int i = 0; i < max_ops; ++i)
    {
      while (reactor_op* op = descriptor_data->op_queue_[i].front())
      {
        op->ec_ = boost::asio::error::operation_aborted;
        descriptor_data->op_queue_[i].pop();
        ops.push(op);
      }
    }

    descriptor_data->descriptor_ = -1;
    descriptor_data->shutdown_ = true;

    descriptor_lock.unlock();

    (void)0

                                                        ;

    scheduler_.post_deferred_completions(ops);



  }
  else
  {


    descriptor_data = 0;
  }
}

void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
    epoll_reactor::per_descriptor_data& descriptor_data)
{
  if (!descriptor_data)
    return;

  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);

  if (!descriptor_data->shutdown_)
  {
    epoll_event ev = { 0, { 0 } };
    epoll_ctl(epoll_fd_, 2, descriptor, &ev);

    op_queue<operation> ops;
    for (int i = 0; i < max_ops; ++i)
      ops.push(descriptor_data->op_queue_[i]);

    descriptor_data->descriptor_ = -1;
    descriptor_data->shutdown_ = true;

    descriptor_lock.unlock();

    (void)0

                                                        ;



  }
  else
  {


    descriptor_data = 0;
  }
}

void epoll_reactor::cleanup_descriptor_data(
    per_descriptor_data& descriptor_data)
{
  if (descriptor_data)
  {
    free_descriptor_state(descriptor_data);
    descriptor_data = 0;
  }
}

void epoll_reactor::run(long usec, op_queue<operation>& ops)
{







  int timeout;
  if (usec == 0)
    timeout = 0;
  else
  {
    timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1);
    if (timer_fd_ == -1)
    {
      mutex::scoped_lock lock(mutex_);
      timeout = get_timeout(timeout);
    }
  }


  epoll_event events[128];
  int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
# 504 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.ipp" 3 4
  bool check_timers = (timer_fd_ == -1);





  for (int i = 0; i < num_events; ++i)
  {
    void* ptr = events[i].data.ptr;
    if (ptr == &interrupter_)
    {






      if (timer_fd_ == -1)
        check_timers = true;



    }

    else if (ptr == &timer_fd_)
    {
      check_timers = true;
    }

    else
    {



      descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
      if (!ops.is_enqueued(descriptor_data))
      {
        descriptor_data->set_ready_events(events[i].events);
        ops.push(descriptor_data);
      }
      else
      {
        descriptor_data->add_ready_events(events[i].events);
      }
    }
  }

  if (check_timers)
  {
    mutex::scoped_lock common_lock(mutex_);
    timer_queues_.get_ready_timers(ops);


    if (timer_fd_ != -1)
    {
      itimerspec new_timeout;
      itimerspec old_timeout;
      int flags = get_timeout(new_timeout);
      timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
    }

  }
}

void epoll_reactor::interrupt()
{
  epoll_event ev = { 0, { 0 } };
  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
  ev.data.ptr = &interrupter_;
  epoll_ctl(epoll_fd_, 3, interrupter_.read_descriptor(), &ev);
}

int epoll_reactor::do_epoll_create()
{

  int fd = epoll_create1(EPOLL_CLOEXEC);





  if (fd == -1 && ((*__errno_location ()) == 22 || (*__errno_location ()) == 38))
  {
    fd = epoll_create(epoll_size);
    if (fd != -1)
      ::fcntl(fd, 2, 1);
  }

  if (fd == -1)
  {
    boost::system::error_code ec((*__errno_location ()),
        boost::asio::error::get_system_category());
    boost::asio::detail::throw_error(ec, "epoll");
  }

  return fd;
}

int epoll_reactor::do_timerfd_create()
{


  int fd = timerfd_create(1, TFD_CLOEXEC);





  if (fd == -1 && (*__errno_location ()) == 22)
  {
    fd = timerfd_create(1, 0);
    if (fd != -1)
      ::fcntl(fd, 2, 1);
  }

  return fd;



}

epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
{
  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
  return registered_descriptors_.alloc((((static_cast<unsigned>(scheduler_.concurrency_hint()) & (0xFFFF0000u | 0x4u)) ^ 0xA5100000u) != 0)
                                                  );
}

void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
{
  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
  registered_descriptors_.free(s);
}

void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
{
  mutex::scoped_lock lock(mutex_);
  timer_queues_.insert(&queue);
}

void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
{
  mutex::scoped_lock lock(mutex_);
  timer_queues_.erase(&queue);
}

void epoll_reactor::update_timeout()
{

  if (timer_fd_ != -1)
  {
    itimerspec new_timeout;
    itimerspec old_timeout;
    int flags = get_timeout(new_timeout);
    timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
    return;
  }

  interrupt();
}

int epoll_reactor::get_timeout(int msec)
{


  const int max_msec = 5 * 60 * 1000;
  return timer_queues_.wait_duration_msec(
      (msec < 0 || max_msec < msec) ? max_msec : msec);
}


int epoll_reactor::get_timeout(itimerspec& ts)
{
  ts.it_interval.tv_sec = 0;
  ts.it_interval.tv_nsec = 0;

  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
  ts.it_value.tv_sec = usec / 1000000;
  ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;

  return usec ? 0 : TFD_TIMER_ABSTIME;
}


struct epoll_reactor::perform_io_cleanup_on_block_exit
{
  explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
    : reactor_(r), first_op_(0)
  {
  }

  ~perform_io_cleanup_on_block_exit()
  {
    if (first_op_)
    {

      if (!ops_.empty())
        reactor_->scheduler_.post_deferred_completions(ops_);




    }
    else
    {



      reactor_->scheduler_.compensating_work_started();
    }
  }

  epoll_reactor* reactor_;
  op_queue<operation> ops_;
  operation* first_op_;
};

epoll_reactor::descriptor_state::descriptor_state(bool locking)
  : operation(&epoll_reactor::descriptor_state::do_complete),
    mutex_(locking)
{
}

operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
{
  mutex_.lock();
  perform_io_cleanup_on_block_exit io_cleanup(reactor_);
  mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock);



  static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
  for (int j = max_ops - 1; j >= 0; --j)
  {
    if (events & (flag[j] | EPOLLERR | EPOLLHUP))
    {
      try_speculative_[j] = true;
      while (reactor_op* op = op_queue_[j].front())
      {
        if (reactor_op::status status = op->perform())
        {
          op_queue_[j].pop();
          io_cleanup.ops_.push(op);
          if (status == reactor_op::done_and_exhausted)
          {
            try_speculative_[j] = false;
            break;
          }
        }
        else
          break;
      }
    }
  }



  io_cleanup.first_op_ = io_cleanup.ops_.front();
  io_cleanup.ops_.pop();
  return io_cleanup.first_op_;
}

void epoll_reactor::descriptor_state::do_complete(
    void* owner, operation* base,
    const boost::system::error_code& ec, std::size_t bytes_transferred)
{
  if (owner)
  {
    descriptor_state* descriptor_data = static_cast<descriptor_state*>(base);
    uint32_t events = static_cast<uint32_t>(bytes_transferred);
    if (operation* op = descriptor_data->perform_io(events))
    {
      op->complete(owner, ec, 0);
    }
  }
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 786 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactor.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_thread_info.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_thread_info.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_thread_info.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class scheduler;
class scheduler_operation;

struct scheduler_thread_info : public thread_info_base
{
  op_queue<scheduler_operation> private_op_queue;
  long private_outstanding_work;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler_thread_info.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct scheduler::task_cleanup
{
  ~task_cleanup()
  {
    if (this_thread_->private_outstanding_work > 0)
    {
      boost::asio::detail::increment(
          scheduler_->outstanding_work_,
          this_thread_->private_outstanding_work);
    }
    this_thread_->private_outstanding_work = 0;



    lock_->lock();
    scheduler_->task_interrupted_ = true;
    scheduler_->op_queue_.push(this_thread_->private_op_queue);
    scheduler_->op_queue_.push(&scheduler_->task_operation_);
  }

  scheduler* scheduler_;
  mutex::scoped_lock* lock_;
  thread_info* this_thread_;
};

struct scheduler::work_cleanup
{
  ~work_cleanup()
  {
    if (this_thread_->private_outstanding_work > 1)
    {
      boost::asio::detail::increment(
          scheduler_->outstanding_work_,
          this_thread_->private_outstanding_work - 1);
    }
    else if (this_thread_->private_outstanding_work < 1)
    {
      scheduler_->work_finished();
    }
    this_thread_->private_outstanding_work = 0;


    if (!this_thread_->private_op_queue.empty())
    {
      lock_->lock();
      scheduler_->op_queue_.push(this_thread_->private_op_queue);
    }

  }

  scheduler* scheduler_;
  mutex::scoped_lock* lock_;
  thread_info* this_thread_;
};

scheduler::scheduler(
    boost::asio::execution_context& ctx, int concurrency_hint)
  : boost::asio::detail::execution_context_service_base<scheduler>(ctx),
    one_thread_(concurrency_hint == 1
        || !(((static_cast<unsigned>(concurrency_hint) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)

        || !(((static_cast<unsigned>(concurrency_hint) & (0xFFFF0000u | 0x4u)) ^ 0xA5100000u) != 0)
                                       ),
    mutex_((((static_cast<unsigned>(concurrency_hint) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
                                      ),
    task_(0),
    task_interrupted_(true),
    outstanding_work_(0),
    stopped_(false),
    shutdown_(false),
    concurrency_hint_(concurrency_hint)
{
  (void)0;
}

void scheduler::shutdown()
{
  mutex::scoped_lock lock(mutex_);
  shutdown_ = true;
  lock.unlock();


  while (!op_queue_.empty())
  {
    operation* o = op_queue_.front();
    op_queue_.pop();
    if (o != &task_operation_)
      o->destroy();
  }


  task_ = 0;
}

void scheduler::init_task()
{
  mutex::scoped_lock lock(mutex_);
  if (!shutdown_ && !task_)
  {
    task_ = &use_service<reactor>(this->context());
    op_queue_.push(&task_operation_);
    wake_one_thread_and_unlock(lock);
  }
}

std::size_t scheduler::run(boost::system::error_code& ec)
{
  ec = boost::system::error_code();
  if (outstanding_work_ == 0)
  {
    stop();
    return 0;
  }

  thread_info this_thread;
  this_thread.private_outstanding_work = 0;
  thread_call_stack::context ctx(this, this_thread);

  mutex::scoped_lock lock(mutex_);

  std::size_t n = 0;
  for (; do_run_one(lock, this_thread, ec); lock.lock())
    if (n != (std::numeric_limits<std::size_t>::max)())
      ++n;
  return n;
}

std::size_t scheduler::run_one(boost::system::error_code& ec)
{
  ec = boost::system::error_code();
  if (outstanding_work_ == 0)
  {
    stop();
    return 0;
  }

  thread_info this_thread;
  this_thread.private_outstanding_work = 0;
  thread_call_stack::context ctx(this, this_thread);

  mutex::scoped_lock lock(mutex_);

  return do_run_one(lock, this_thread, ec);
}

std::size_t scheduler::wait_one(long usec, boost::system::error_code& ec)
{
  ec = boost::system::error_code();
  if (outstanding_work_ == 0)
  {
    stop();
    return 0;
  }

  thread_info this_thread;
  this_thread.private_outstanding_work = 0;
  thread_call_stack::context ctx(this, this_thread);

  mutex::scoped_lock lock(mutex_);

  return do_wait_one(lock, this_thread, usec, ec);
}

std::size_t scheduler::poll(boost::system::error_code& ec)
{
  ec = boost::system::error_code();
  if (outstanding_work_ == 0)
  {
    stop();
    return 0;
  }

  thread_info this_thread;
  this_thread.private_outstanding_work = 0;
  thread_call_stack::context ctx(this, this_thread);

  mutex::scoped_lock lock(mutex_);





  if (one_thread_)
    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
      op_queue_.push(outer_info->private_op_queue);


  std::size_t n = 0;
  for (; do_poll_one(lock, this_thread, ec); lock.lock())
    if (n != (std::numeric_limits<std::size_t>::max)())
      ++n;
  return n;
}

std::size_t scheduler::poll_one(boost::system::error_code& ec)
{
  ec = boost::system::error_code();
  if (outstanding_work_ == 0)
  {
    stop();
    return 0;
  }

  thread_info this_thread;
  this_thread.private_outstanding_work = 0;
  thread_call_stack::context ctx(this, this_thread);

  mutex::scoped_lock lock(mutex_);





  if (one_thread_)
    if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
      op_queue_.push(outer_info->private_op_queue);


  return do_poll_one(lock, this_thread, ec);
}

void scheduler::stop()
{
  mutex::scoped_lock lock(mutex_);
  stop_all_threads(lock);
}

bool scheduler::stopped() const
{
  mutex::scoped_lock lock(mutex_);
  return stopped_;
}

void scheduler::restart()
{
  mutex::scoped_lock lock(mutex_);
  stopped_ = false;
}

void scheduler::compensating_work_started()
{
  thread_info_base* this_thread = thread_call_stack::contains(this);
  ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
}

void scheduler::post_immediate_completion(
    scheduler::operation* op, bool is_continuation)
{

  if (one_thread_ || is_continuation)
  {
    if (thread_info_base* this_thread = thread_call_stack::contains(this))
    {
      ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
      return;
    }
  }




  work_started();
  mutex::scoped_lock lock(mutex_);
  op_queue_.push(op);
  wake_one_thread_and_unlock(lock);
}

void scheduler::post_deferred_completion(scheduler::operation* op)
{

  if (one_thread_)
  {
    if (thread_info_base* this_thread = thread_call_stack::contains(this))
    {
      static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
      return;
    }
  }


  mutex::scoped_lock lock(mutex_);
  op_queue_.push(op);
  wake_one_thread_and_unlock(lock);
}

void scheduler::post_deferred_completions(
    op_queue<scheduler::operation>& ops)
{
  if (!ops.empty())
  {

    if (one_thread_)
    {
      if (thread_info_base* this_thread = thread_call_stack::contains(this))
      {
        static_cast<thread_info*>(this_thread)->private_op_queue.push(ops);
        return;
      }
    }


    mutex::scoped_lock lock(mutex_);
    op_queue_.push(ops);
    wake_one_thread_and_unlock(lock);
  }
}

void scheduler::do_dispatch(
    scheduler::operation* op)
{
  work_started();
  mutex::scoped_lock lock(mutex_);
  op_queue_.push(op);
  wake_one_thread_and_unlock(lock);
}

void scheduler::abandon_operations(
    op_queue<scheduler::operation>& ops)
{
  op_queue<scheduler::operation> ops2;
  ops2.push(ops);
}

std::size_t scheduler::do_run_one(mutex::scoped_lock& lock,
    scheduler::thread_info& this_thread,
    const boost::system::error_code& ec)
{
  while (!stopped_)
  {
    if (!op_queue_.empty())
    {

      operation* o = op_queue_.front();
      op_queue_.pop();
      bool more_handlers = (!op_queue_.empty());

      if (o == &task_operation_)
      {
        task_interrupted_ = more_handlers;

        if (more_handlers && !one_thread_)
          wakeup_event_.unlock_and_signal_one(lock);
        else
          lock.unlock();

        task_cleanup on_exit = { this, &lock, &this_thread };
        (void)on_exit;




        task_->run(more_handlers ? 0 : -1, this_thread.private_op_queue);
      }
      else
      {
        std::size_t task_result = o->task_result_;

        if (more_handlers && !one_thread_)
          wake_one_thread_and_unlock(lock);
        else
          lock.unlock();


        work_cleanup on_exit = { this, &lock, &this_thread };
        (void)on_exit;


        o->complete(this, ec, task_result);

        return 1;
      }
    }
    else
    {
      wakeup_event_.clear(lock);
      wakeup_event_.wait(lock);
    }
  }

  return 0;
}

std::size_t scheduler::do_wait_one(mutex::scoped_lock& lock,
    scheduler::thread_info& this_thread, long usec,
    const boost::system::error_code& ec)
{
  if (stopped_)
    return 0;

  operation* o = op_queue_.front();
  if (o == 0)
  {
    wakeup_event_.clear(lock);
    wakeup_event_.wait_for_usec(lock, usec);
    usec = 0;
    o = op_queue_.front();
  }

  if (o == &task_operation_)
  {
    op_queue_.pop();
    bool more_handlers = (!op_queue_.empty());

    task_interrupted_ = more_handlers;

    if (more_handlers && !one_thread_)
      wakeup_event_.unlock_and_signal_one(lock);
    else
      lock.unlock();

    {
      task_cleanup on_exit = { this, &lock, &this_thread };
      (void)on_exit;




      task_->run(more_handlers ? 0 : usec, this_thread.private_op_queue);
    }

    o = op_queue_.front();
    if (o == &task_operation_)
    {
      if (!one_thread_)
        wakeup_event_.maybe_unlock_and_signal_one(lock);
      return 0;
    }
  }

  if (o == 0)
    return 0;

  op_queue_.pop();
  bool more_handlers = (!op_queue_.empty());

  std::size_t task_result = o->task_result_;

  if (more_handlers && !one_thread_)
    wake_one_thread_and_unlock(lock);
  else
    lock.unlock();


  work_cleanup on_exit = { this, &lock, &this_thread };
  (void)on_exit;


  o->complete(this, ec, task_result);

  return 1;
}

std::size_t scheduler::do_poll_one(mutex::scoped_lock& lock,
    scheduler::thread_info& this_thread,
    const boost::system::error_code& ec)
{
  if (stopped_)
    return 0;

  operation* o = op_queue_.front();
  if (o == &task_operation_)
  {
    op_queue_.pop();
    lock.unlock();

    {
      task_cleanup c = { this, &lock, &this_thread };
      (void)c;




      task_->run(0, this_thread.private_op_queue);
    }

    o = op_queue_.front();
    if (o == &task_operation_)
    {
      wakeup_event_.maybe_unlock_and_signal_one(lock);
      return 0;
    }
  }

  if (o == 0)
    return 0;

  op_queue_.pop();
  bool more_handlers = (!op_queue_.empty());

  std::size_t task_result = o->task_result_;

  if (more_handlers && !one_thread_)
    wake_one_thread_and_unlock(lock);
  else
    lock.unlock();


  work_cleanup on_exit = { this, &lock, &this_thread };
  (void)on_exit;


  o->complete(this, ec, task_result);

  return 1;
}

void scheduler::stop_all_threads(
    mutex::scoped_lock& lock)
{
  stopped_ = true;
  wakeup_event_.signal_all(lock);

  if (!task_interrupted_ && task_)
  {
    task_interrupted_ = true;
    task_->interrupt();
  }
}

void scheduler::wake_one_thread_and_unlock(
    mutex::scoped_lock& lock)
{
  if (!wakeup_event_.maybe_unlock_and_signal_one(lock))
  {
    if (!task_interrupted_ && task_)
    {
      task_interrupted_ = true;
      task_->interrupt();
    }
    lock.unlock();
  }
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 572 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
# 213 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/scheduler.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_group.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_group.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_thread.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_thread.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_thread.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

extern "C"
{
  inline void* boost_asio_detail_posix_thread_function(void* arg);
}

class posix_thread
  : private noncopyable
{
public:

  template <typename Function>
  posix_thread(Function f, unsigned int = 0)
    : joined_(false)
  {
    start_thread(new func<Function>(f));
  }


  inline ~posix_thread();


  inline void join();


  inline static std::size_t hardware_concurrency();

private:
  friend void* boost_asio_detail_posix_thread_function(void* arg);

  class func_base
  {
  public:
    virtual ~func_base() {}
    virtual void run() = 0;
  };

  struct auto_func_base_ptr
  {
    func_base* ptr;
    ~auto_func_base_ptr() { delete ptr; }
  };

  template <typename Function>
  class func
    : public func_base
  {
  public:
    func(Function f)
      : f_(f)
    {
    }

    virtual void run()
    {
      f_();
    }

  private:
    Function f_;
  };

  inline void start_thread(func_base* arg);

  ::pthread_t thread_;
  bool joined_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_thread.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_thread.ipp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_thread.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_thread.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

posix_thread::~posix_thread()
{
  if (!joined_)
    ::pthread_detach(thread_);
}

void posix_thread::join()
{
  if (!joined_)
  {
    ::pthread_join(thread_, 0);
    joined_ = true;
  }
}

std::size_t posix_thread::hardware_concurrency()
{

  long result = sysconf(_SC_NPROCESSORS_ONLN);
  if (result > 0)
    return result;

  return 0;
}

void posix_thread::start_thread(func_base* arg)
{
  int error = ::pthread_create(&thread_, 0,
        boost_asio_detail_posix_thread_function, arg);
  if (error != 0)
  {
    delete arg;
    boost::system::error_code ec(error,
        boost::asio::error::get_system_category());
    boost::asio::detail::throw_error(ec, "thread");
  }
}

void* boost_asio_detail_posix_thread_function(void* arg)
{
  posix_thread::auto_func_base_ptr func = {
      static_cast<posix_thread::func_base*>(arg) };
  func.ptr->run();
  return 0;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4
# 107 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_thread.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread.hpp" 2 3 4






namespace boost {
namespace asio {
namespace detail {
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread.hpp" 3 4
typedef posix_thread thread;




}
}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/thread_group.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class thread_group
{
public:

  thread_group()
    : first_(0)
  {
  }


  ~thread_group()
  {
    join();
  }


  template <typename Function>
  void create_thread(Function f)
  {
    first_ = new item(f, first_);
  }


  template <typename Function>
  void create_threads(Function f, std::size_t num_threads)
  {
    for (std::size_t i = 0; i < num_threads; ++i)
      create_thread(f);
  }


  void join()
  {
    while (first_)
    {
      first_->thread_.join();
      item* tmp = first_;
      first_ = first_->next_;
      delete tmp;
    }
  }

private:

  struct item
  {
    template <typename Function>
    explicit item(Function f, item* next)
      : thread_(f),
        next_(next)
    {
    }

    boost::asio::detail::thread thread_;
    item* next_;
  };


  item* first_;
};

}
}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 2 3 4

namespace boost {
namespace asio {

class system_executor;


class system_context : public execution_context
{
public:

  typedef system_executor executor_type;


  inline ~system_context();


  executor_type get_executor() noexcept;


  inline void stop();


  inline bool stopped() const noexcept;


  inline void join();





  inline system_context();

private:
  friend class system_executor;

  struct thread_function;


  detail::scheduler& scheduler_;


  detail::thread_group threads_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.hpp" 2 3 4

namespace boost {
namespace asio {

inline system_context::executor_type
system_context::get_executor() noexcept
{
  return system_executor();
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.hpp" 2 3 4
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.ipp" 2 3 4

namespace boost {
namespace asio {

struct system_context::thread_function
{
  detail::scheduler* scheduler_;

  void operator()()
  {
    boost::system::error_code ec;
    scheduler_->run(ec);
  }
};

system_context::system_context()
  : scheduler_(use_service<detail::scheduler>(*this))
{
  scheduler_.work_started();

  thread_function f = { &scheduler_ };
  std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
  threads_.create_threads(f, num_threads ? num_threads : 2);
}

system_context::~system_context()
{
  scheduler_.work_finished();
  scheduler_.stop();
  threads_.join();
}

void system_context::stop()
{
  scheduler_.stop();
}

bool system_context::stopped() const noexcept
{
  return scheduler_.stopped();
}

void system_context::join()
{
  scheduler_.work_finished();
  threads_.join();
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_context.ipp" 2 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_context.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_executor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_executor.hpp" 2 3 4

namespace boost {
namespace asio {

inline system_context& system_executor::context() const noexcept
{
  return detail::global<system_context>();
}

template <typename Function, typename Allocator>
void system_executor::dispatch(
    Function&& f, const Allocator&) const
{
  typename decay<Function>::type tmp(static_cast<Function&&>(f));
  boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
}

template <typename Function, typename Allocator>
void system_executor::post(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;

  system_context& ctx = detail::global<system_context>();


  typedef detail::executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                        ;

  ctx.scheduler_.post_immediate_completion(p.p, false);
  p.v = p.p = 0;
}

template <typename Function, typename Allocator>
void system_executor::defer(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;

  system_context& ctx = detail::global<system_context>();


  typedef detail::executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                         ;

  ctx.scheduler_.post_immediate_completion(p.p, true);
  p.v = p.p = 0;
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/system_executor.hpp" 2 3 4
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_executor.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_executor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_executor.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename>
struct associated_executor_check
{
  typedef void type;
};

template <typename T, typename E, typename = void>
struct associated_executor_impl
{
  typedef E type;

  static type get(const T&, const E& e) noexcept
  {
    return e;
  }
};

template <typename T, typename E>
struct associated_executor_impl<T, E,
  typename associated_executor_check<typename T::executor_type>::type>
{
  typedef typename T::executor_type type;

  static type get(const T& t, const E&) noexcept
  {
    return t.get_executor();
  }
};

}
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_executor.hpp" 3 4
template <typename T, typename Executor = system_executor>
struct associated_executor
{





  typedef typename detail::associated_executor_impl<T, Executor>::type type;




  static type get(const T& t,
      const Executor& ex = Executor()) noexcept
  {
    return detail::associated_executor_impl<T, Executor>::get(t, ex);
  }
};





template <typename T>
inline typename associated_executor<T>::type
get_associated_executor(const T& t) noexcept
{
  return associated_executor<T>::get(t);
}





template <typename T, typename Executor>
inline typename associated_executor<T, Executor>::type
get_associated_executor(const T& t, const Executor& ex,
    typename enable_if<is_executor<
      Executor>::value>::type* = 0) noexcept
{
  return associated_executor<T, Executor>::get(t, ex);
}






template <typename T, typename ExecutionContext>
inline typename associated_executor<T,
  typename ExecutionContext::executor_type>::type
get_associated_executor(const T& t, ExecutionContext& ctx,
    typename enable_if<is_convertible<ExecutionContext&,
      execution_context&>::value>::type* = 0) noexcept
{
  return associated_executor<T,
    typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
}



template <typename T, typename Executor = system_executor>
using associated_executor_t = typename associated_executor<T, Executor>::type;



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/associated_executor.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/bind_handler.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_cont_helpers.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_cont_helpers.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_continuation_hook.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_continuation_hook.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_continuation_hook.hpp" 2 3 4

namespace boost {
namespace asio {
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_continuation_hook.hpp" 3 4
inline bool asio_handler_is_continuation(...)
{
  return false;
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/handler_continuation_hook.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4




namespace boost_asio_handler_cont_helpers {

template <typename Context>
inline bool is_continuation(Context& context)
{



  using boost::asio::asio_handler_is_continuation;
  return asio_handler_is_continuation(
      boost::asio::detail::addressof(context));

}

}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/bind_handler.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/bind_handler.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler, typename Arg1>
class binder1
{
public:
  template <typename T>
  binder1(int, T&& handler, const Arg1& arg1)
    : handler_(static_cast<T&&>(handler)),
      arg1_(arg1)
  {
  }

  binder1(Handler& handler, const Arg1& arg1)
    : handler_(static_cast<Handler&&>(handler)),
      arg1_(arg1)
  {
  }


  binder1(const binder1& other)
    : handler_(other.handler_),
      arg1_(other.arg1_)
  {
  }

  binder1(binder1&& other)
    : handler_(static_cast<Handler&&>(other.handler_)),
      arg1_(static_cast<Arg1&&>(other.arg1_))
  {
  }


  void operator()()
  {
    handler_(static_cast<const Arg1&>(arg1_));
  }

  void operator()() const
  {
    handler_(arg1_);
  }


  Handler handler_;
  Arg1 arg1_;
};

template <typename Handler, typename Arg1>
inline void* asio_handler_allocate(std::size_t size,
    binder1<Handler, Arg1>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Handler, typename Arg1>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    binder1<Handler, Arg1>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Handler, typename Arg1>
inline bool asio_handler_is_continuation(
    binder1<Handler, Arg1>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(Function& function,
    binder1<Handler, Arg1>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(const Function& function,
    binder1<Handler, Arg1>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Handler, typename Arg1>
inline binder1<typename decay<Handler>::type, Arg1> bind_handler(
    Handler&& handler, const Arg1& arg1)
{
  return binder1<typename decay<Handler>::type, Arg1>(0,
      static_cast<Handler&&>(handler), arg1);
}

template <typename Handler, typename Arg1, typename Arg2>
class binder2
{
public:
  template <typename T>
  binder2(int, T&& handler,
      const Arg1& arg1, const Arg2& arg2)
    : handler_(static_cast<T&&>(handler)),
      arg1_(arg1),
      arg2_(arg2)
  {
  }

  binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
    : handler_(static_cast<Handler&&>(handler)),
      arg1_(arg1),
      arg2_(arg2)
  {
  }


  binder2(const binder2& other)
    : handler_(other.handler_),
      arg1_(other.arg1_),
      arg2_(other.arg2_)
  {
  }

  binder2(binder2&& other)
    : handler_(static_cast<Handler&&>(other.handler_)),
      arg1_(static_cast<Arg1&&>(other.arg1_)),
      arg2_(static_cast<Arg2&&>(other.arg2_))
  {
  }


  void operator()()
  {
    handler_(static_cast<const Arg1&>(arg1_),
        static_cast<const Arg2&>(arg2_));
  }

  void operator()() const
  {
    handler_(arg1_, arg2_);
  }


  Handler handler_;
  Arg1 arg1_;
  Arg2 arg2_;
};

template <typename Handler, typename Arg1, typename Arg2>
inline void* asio_handler_allocate(std::size_t size,
    binder2<Handler, Arg1, Arg2>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    binder2<Handler, Arg1, Arg2>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2>
inline bool asio_handler_is_continuation(
    binder2<Handler, Arg1, Arg2>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1, typename Arg2>
inline void asio_handler_invoke(Function& function,
    binder2<Handler, Arg1, Arg2>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1, typename Arg2>
inline void asio_handler_invoke(const Function& function,
    binder2<Handler, Arg1, Arg2>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2>
inline binder2<typename decay<Handler>::type, Arg1, Arg2> bind_handler(
    Handler&& handler, const Arg1& arg1, const Arg2& arg2)
{
  return binder2<typename decay<Handler>::type, Arg1, Arg2>(0,
      static_cast<Handler&&>(handler), arg1, arg2);
}

template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
class binder3
{
public:
  template <typename T>
  binder3(int, T&& handler, const Arg1& arg1,
      const Arg2& arg2, const Arg3& arg3)
    : handler_(static_cast<T&&>(handler)),
      arg1_(arg1),
      arg2_(arg2),
      arg3_(arg3)
  {
  }

  binder3(Handler& handler, const Arg1& arg1,
      const Arg2& arg2, const Arg3& arg3)
    : handler_(static_cast<Handler&&>(handler)),
      arg1_(arg1),
      arg2_(arg2),
      arg3_(arg3)
  {
  }


  binder3(const binder3& other)
    : handler_(other.handler_),
      arg1_(other.arg1_),
      arg2_(other.arg2_),
      arg3_(other.arg3_)
  {
  }

  binder3(binder3&& other)
    : handler_(static_cast<Handler&&>(other.handler_)),
      arg1_(static_cast<Arg1&&>(other.arg1_)),
      arg2_(static_cast<Arg2&&>(other.arg2_)),
      arg3_(static_cast<Arg3&&>(other.arg3_))
  {
  }


  void operator()()
  {
    handler_(static_cast<const Arg1&>(arg1_),
        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_));
  }

  void operator()() const
  {
    handler_(arg1_, arg2_, arg3_);
  }


  Handler handler_;
  Arg1 arg1_;
  Arg2 arg2_;
  Arg3 arg3_;
};

template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
inline void* asio_handler_allocate(std::size_t size,
    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
inline bool asio_handler_is_continuation(
    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->handler_);
}

template <typename Function, typename Handler,
    typename Arg1, typename Arg2, typename Arg3>
inline void asio_handler_invoke(Function& function,
    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Function, typename Handler,
    typename Arg1, typename Arg2, typename Arg3>
inline void asio_handler_invoke(const Function& function,
    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
inline binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3> bind_handler(
    Handler&& handler, const Arg1& arg1, const Arg2& arg2,
    const Arg3& arg3)
{
  return binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3>(0,
      static_cast<Handler&&>(handler), arg1, arg2, arg3);
}

template <typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4>
class binder4
{
public:
  template <typename T>
  binder4(int, T&& handler, const Arg1& arg1,
      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
    : handler_(static_cast<T&&>(handler)),
      arg1_(arg1),
      arg2_(arg2),
      arg3_(arg3),
      arg4_(arg4)
  {
  }

  binder4(Handler& handler, const Arg1& arg1,
      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
    : handler_(static_cast<Handler&&>(handler)),
      arg1_(arg1),
      arg2_(arg2),
      arg3_(arg3),
      arg4_(arg4)
  {
  }


  binder4(const binder4& other)
    : handler_(other.handler_),
      arg1_(other.arg1_),
      arg2_(other.arg2_),
      arg3_(other.arg3_),
      arg4_(other.arg4_)
  {
  }

  binder4(binder4&& other)
    : handler_(static_cast<Handler&&>(other.handler_)),
      arg1_(static_cast<Arg1&&>(other.arg1_)),
      arg2_(static_cast<Arg2&&>(other.arg2_)),
      arg3_(static_cast<Arg3&&>(other.arg3_)),
      arg4_(static_cast<Arg4&&>(other.arg4_))
  {
  }


  void operator()()
  {
    handler_(static_cast<const Arg1&>(arg1_),
        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
        static_cast<const Arg4&>(arg4_));
  }

  void operator()() const
  {
    handler_(arg1_, arg2_, arg3_, arg4_);
  }


  Handler handler_;
  Arg1 arg1_;
  Arg2 arg2_;
  Arg3 arg3_;
  Arg4 arg4_;
};

template <typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4>
inline void* asio_handler_allocate(std::size_t size,
    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4>
inline bool asio_handler_is_continuation(
    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4>
inline void asio_handler_invoke(Function& function,
    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4>
inline void asio_handler_invoke(const Function& function,
    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4>
inline binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>
bind_handler(Handler&& handler, const Arg1& arg1,
    const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
{
  return binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>(0,
      static_cast<Handler&&>(handler), arg1, arg2, arg3, arg4);
}

template <typename Handler, typename Arg1, typename Arg2,
    typename Arg3, typename Arg4, typename Arg5>
class binder5
{
public:
  template <typename T>
  binder5(int, T&& handler, const Arg1& arg1,
      const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
    : handler_(static_cast<T&&>(handler)),
      arg1_(arg1),
      arg2_(arg2),
      arg3_(arg3),
      arg4_(arg4),
      arg5_(arg5)
  {
  }

  binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
      const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
    : handler_(static_cast<Handler&&>(handler)),
      arg1_(arg1),
      arg2_(arg2),
      arg3_(arg3),
      arg4_(arg4),
      arg5_(arg5)
  {
  }


  binder5(const binder5& other)
    : handler_(other.handler_),
      arg1_(other.arg1_),
      arg2_(other.arg2_),
      arg3_(other.arg3_),
      arg4_(other.arg4_),
      arg5_(other.arg5_)
  {
  }

  binder5(binder5&& other)
    : handler_(static_cast<Handler&&>(other.handler_)),
      arg1_(static_cast<Arg1&&>(other.arg1_)),
      arg2_(static_cast<Arg2&&>(other.arg2_)),
      arg3_(static_cast<Arg3&&>(other.arg3_)),
      arg4_(static_cast<Arg4&&>(other.arg4_)),
      arg5_(static_cast<Arg5&&>(other.arg5_))
  {
  }


  void operator()()
  {
    handler_(static_cast<const Arg1&>(arg1_),
        static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
        static_cast<const Arg4&>(arg4_), static_cast<const Arg5&>(arg5_));
  }

  void operator()() const
  {
    handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
  }


  Handler handler_;
  Arg1 arg1_;
  Arg2 arg2_;
  Arg3 arg3_;
  Arg4 arg4_;
  Arg5 arg5_;
};

template <typename Handler, typename Arg1, typename Arg2,
    typename Arg3, typename Arg4, typename Arg5>
inline void* asio_handler_allocate(std::size_t size,
    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2,
    typename Arg3, typename Arg4, typename Arg5>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2,
    typename Arg3, typename Arg4, typename Arg5>
inline bool asio_handler_is_continuation(
    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4, typename Arg5>
inline void asio_handler_invoke(Function& function,
    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1,
    typename Arg2, typename Arg3, typename Arg4, typename Arg5>
inline void asio_handler_invoke(const Function& function,
    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2,
    typename Arg3, typename Arg4, typename Arg5>
inline binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>
bind_handler(Handler&& handler, const Arg1& arg1,
    const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
{
  return binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>(0,
      static_cast<Handler&&>(handler), arg1, arg2, arg3, arg4, arg5);
}



template <typename Handler, typename Arg1>
class move_binder1
{
public:
  move_binder1(int, Handler&& handler,
      Arg1&& arg1)
    : handler_(static_cast<Handler&&>(handler)),
      arg1_(static_cast<Arg1&&>(arg1))
  {
  }

  move_binder1(move_binder1&& other)
    : handler_(static_cast<Handler&&>(other.handler_)),
      arg1_(static_cast<Arg1&&>(other.arg1_))
  {
  }

  void operator()()
  {
    handler_(static_cast<Arg1&&>(arg1_));
  }


  Handler handler_;
  Arg1 arg1_;
};

template <typename Handler, typename Arg1>
inline void* asio_handler_allocate(std::size_t size,
    move_binder1<Handler, Arg1>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Handler, typename Arg1>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    move_binder1<Handler, Arg1>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Handler, typename Arg1>
inline bool asio_handler_is_continuation(
    move_binder1<Handler, Arg1>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1>
inline void asio_handler_invoke(Function&& function,
    move_binder1<Handler, Arg1>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      static_cast<Function&&>(function), this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2>
class move_binder2
{
public:
  move_binder2(int, Handler&& handler,
      const Arg1& arg1, Arg2&& arg2)
    : handler_(static_cast<Handler&&>(handler)),
      arg1_(arg1),
      arg2_(static_cast<Arg2&&>(arg2))
  {
  }

  move_binder2(move_binder2&& other)
    : handler_(static_cast<Handler&&>(other.handler_)),
      arg1_(static_cast<Arg1&&>(other.arg1_)),
      arg2_(static_cast<Arg2&&>(other.arg2_))
  {
  }

  void operator()()
  {
    handler_(static_cast<const Arg1&>(arg1_),
        static_cast<Arg2&&>(arg2_));
  }


  Handler handler_;
  Arg1 arg1_;
  Arg2 arg2_;
};

template <typename Handler, typename Arg1, typename Arg2>
inline void* asio_handler_allocate(std::size_t size,
    move_binder2<Handler, Arg1, Arg2>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    move_binder2<Handler, Arg1, Arg2>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Handler, typename Arg1, typename Arg2>
inline bool asio_handler_is_continuation(
    move_binder2<Handler, Arg1, Arg2>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->handler_);
}

template <typename Function, typename Handler, typename Arg1, typename Arg2>
inline void asio_handler_invoke(Function&& function,
    move_binder2<Handler, Arg1, Arg2>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      static_cast<Function&&>(function), this_handler->handler_);
}



}

template <typename Handler, typename Arg1, typename Allocator>
struct associated_allocator<detail::binder1<Handler, Arg1>, Allocator>
{
  typedef typename associated_allocator<Handler, Allocator>::type type;

  static type get(const detail::binder1<Handler, Arg1>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
  }
};

template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
struct associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allocator>
{
  typedef typename associated_allocator<Handler, Allocator>::type type;

  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
  }
};

template <typename Handler, typename Arg1, typename Executor>
struct associated_executor<detail::binder1<Handler, Arg1>, Executor>
{
  typedef typename associated_executor<Handler, Executor>::type type;

  static type get(const detail::binder1<Handler, Arg1>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<Handler, Executor>::get(h.handler_, ex);
  }
};

template <typename Handler, typename Arg1, typename Arg2, typename Executor>
struct associated_executor<detail::binder2<Handler, Arg1, Arg2>, Executor>
{
  typedef typename associated_executor<Handler, Executor>::type type;

  static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<Handler, Executor>::get(h.handler_, ex);
  }
};



template <typename Handler, typename Arg1, typename Allocator>
struct associated_allocator<detail::move_binder1<Handler, Arg1>, Allocator>
{
  typedef typename associated_allocator<Handler, Allocator>::type type;

  static type get(const detail::move_binder1<Handler, Arg1>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
  }
};

template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
struct associated_allocator<
    detail::move_binder2<Handler, Arg1, Arg2>, Allocator>
{
  typedef typename associated_allocator<Handler, Allocator>::type type;

  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
  }
};

template <typename Handler, typename Arg1, typename Executor>
struct associated_executor<detail::move_binder1<Handler, Arg1>, Executor>
{
  typedef typename associated_executor<Handler, Executor>::type type;

  static type get(const detail::move_binder1<Handler, Arg1>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<Handler, Executor>::get(h.handler_, ex);
  }
};

template <typename Handler, typename Arg1, typename Arg2, typename Executor>
struct associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, Executor>
{
  typedef typename associated_executor<Handler, Executor>::type type;

  static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<Handler, Executor>::get(h.handler_, ex);
  }
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 817 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/bind_handler.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct is_continuation_delegated
{
  template <typename Dispatcher, typename Handler>
  bool operator()(Dispatcher&, Handler& handler) const
  {
    return boost_asio_handler_cont_helpers::is_continuation(handler);
  }
};

struct is_continuation_if_running
{
  template <typename Dispatcher, typename Handler>
  bool operator()(Dispatcher& dispatcher, Handler&) const
  {
    return dispatcher.running_in_this_thread();
  }
};

template <typename Dispatcher, typename Handler,
    typename IsContinuation = is_continuation_delegated>
class wrapped_handler
{
public:
  typedef void result_type;

  wrapped_handler(Dispatcher dispatcher, Handler& handler)
    : dispatcher_(dispatcher),
      handler_(static_cast<Handler&&>(handler))
  {
  }


  wrapped_handler(const wrapped_handler& other)
    : dispatcher_(other.dispatcher_),
      handler_(other.handler_)
  {
  }

  wrapped_handler(wrapped_handler&& other)
    : dispatcher_(other.dispatcher_),
      handler_(static_cast<Handler&&>(other.handler_))
  {
  }


  void operator()()
  {
    dispatcher_.dispatch(static_cast<Handler&&>(handler_));
  }

  void operator()() const
  {
    dispatcher_.dispatch(handler_);
  }

  template <typename Arg1>
  void operator()(const Arg1& arg1)
  {
    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
  }

  template <typename Arg1>
  void operator()(const Arg1& arg1) const
  {
    dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
  }

  template <typename Arg1, typename Arg2>
  void operator()(const Arg1& arg1, const Arg2& arg2)
  {
    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
  }

  template <typename Arg1, typename Arg2>
  void operator()(const Arg1& arg1, const Arg2& arg2) const
  {
    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
  }

  template <typename Arg1, typename Arg2, typename Arg3>
  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
  {
    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
  }

  template <typename Arg1, typename Arg2, typename Arg3>
  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
  {
    dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
  }

  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
      const Arg4& arg4)
  {
    dispatcher_.dispatch(
        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
  }

  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
      const Arg4& arg4) const
  {
    dispatcher_.dispatch(
        detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
  }

  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
      typename Arg5>
  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
      const Arg4& arg4, const Arg5& arg5)
  {
    dispatcher_.dispatch(
        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
  }

  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
      typename Arg5>
  void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
      const Arg4& arg4, const Arg5& arg5) const
  {
    dispatcher_.dispatch(
        detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
  }


  Dispatcher dispatcher_;
  Handler handler_;
};

template <typename Handler, typename Context>
class rewrapped_handler
{
public:
  explicit rewrapped_handler(Handler& handler, const Context& context)
    : context_(context),
      handler_(static_cast<Handler&&>(handler))
  {
  }

  explicit rewrapped_handler(const Handler& handler, const Context& context)
    : context_(context),
      handler_(handler)
  {
  }


  rewrapped_handler(const rewrapped_handler& other)
    : context_(other.context_),
      handler_(other.handler_)
  {
  }

  rewrapped_handler(rewrapped_handler&& other)
    : context_(static_cast<Context&&>(other.context_)),
      handler_(static_cast<Handler&&>(other.handler_))
  {
  }


  void operator()()
  {
    handler_();
  }

  void operator()() const
  {
    handler_();
  }


  Context context_;
  Handler handler_;
};

template <typename Dispatcher, typename Handler, typename IsContinuation>
inline void* asio_handler_allocate(std::size_t size,
    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->handler_);
}

template <typename Dispatcher, typename Handler, typename IsContinuation>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->handler_);
}

template <typename Dispatcher, typename Handler, typename IsContinuation>
inline bool asio_handler_is_continuation(
    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
{
  return IsContinuation()(this_handler->dispatcher_, this_handler->handler_);
}

template <typename Function, typename Dispatcher,
    typename Handler, typename IsContinuation>
inline void asio_handler_invoke(Function& function,
    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
{
  this_handler->dispatcher_.dispatch(
      rewrapped_handler<Function, Handler>(
        function, this_handler->handler_));
}

template <typename Function, typename Dispatcher,
    typename Handler, typename IsContinuation>
inline void asio_handler_invoke(const Function& function,
    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
{
  this_handler->dispatcher_.dispatch(
      rewrapped_handler<Function, Handler>(
        function, this_handler->handler_));
}

template <typename Handler, typename Context>
inline void* asio_handler_allocate(std::size_t size,
    rewrapped_handler<Handler, Context>* this_handler)
{
  return boost_asio_handler_alloc_helpers::allocate(
      size, this_handler->context_);
}

template <typename Handler, typename Context>
inline void asio_handler_deallocate(void* pointer, std::size_t size,
    rewrapped_handler<Handler, Context>* this_handler)
{
  boost_asio_handler_alloc_helpers::deallocate(
      pointer, size, this_handler->context_);
}

template <typename Dispatcher, typename Context>
inline bool asio_handler_is_continuation(
    rewrapped_handler<Dispatcher, Context>* this_handler)
{
  return boost_asio_handler_cont_helpers::is_continuation(
      this_handler->context_);
}

template <typename Function, typename Handler, typename Context>
inline void asio_handler_invoke(Function& function,
    rewrapped_handler<Handler, Context>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->context_);
}

template <typename Function, typename Handler, typename Context>
inline void asio_handler_invoke(const Function& function,
    rewrapped_handler<Handler, Context>* this_handler)
{
  boost_asio_handler_invoke_helpers::invoke(
      function, this_handler->context_);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 292 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/chrono.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/chrono.hpp" 3 4
namespace boost {
namespace asio {
namespace chrono {


using std::chrono::duration;
using std::chrono::time_point;
using std::chrono::duration_cast;
using std::chrono::nanoseconds;
using std::chrono::microseconds;
using std::chrono::milliseconds;
using std::chrono::seconds;
using std::chrono::minutes;
using std::chrono::hours;
using std::chrono::time_point_cast;



using std::chrono::steady_clock;

using std::chrono::system_clock;
using std::chrono::high_resolution_clock;
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/chrono.hpp" 3 4
}
}
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail {




  typedef class scheduler io_context_impl;

}
# 179 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
class io_context
  : public execution_context
{
private:
  typedef detail::io_context_impl impl_type;




public:
  class executor_type;
  friend class executor_type;


  class work;
  friend class work;


  class service;


  class strand;



  typedef std::size_t count_type;


  inline io_context();
# 216 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline explicit io_context(int concurrency_hint);
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline ~io_context();


  executor_type get_executor() noexcept;
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type run();
# 311 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type run(boost::system::error_code& ec);
# 326 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Rep, typename Period>
  std::size_t run_for(const chrono::duration<Rep, Period>& rel_time);
# 339 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Clock, typename Duration>
  std::size_t run_until(const chrono::time_point<Clock, Duration>& abs_time);
# 360 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type run_one();
# 382 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type run_one(boost::system::error_code& ec);
# 397 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Rep, typename Period>
  std::size_t run_one_for(const chrono::duration<Rep, Period>& rel_time);
# 411 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Clock, typename Duration>
  std::size_t run_one_until(
      const chrono::time_point<Clock, Duration>& abs_time);
# 424 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type poll();
# 437 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type poll(boost::system::error_code& ec);
# 448 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type poll_one();
# 461 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline count_type poll_one(boost::system::error_code& ec);
# 471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline void stop();
# 483 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline bool stopped() const;
# 496 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline void restart();
# 511 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  void reset();
# 535 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename LegacyCompletionHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void ()>::return_type
  dispatch(LegacyCompletionHandler&& handler);
# 562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename LegacyCompletionHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void ()>::return_type
  post(LegacyCompletionHandler&& handler);
# 588 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Handler>



  detail::wrapped_handler<io_context&, Handler>

  wrap(Handler handler);


private:

  inline impl_type& add_impl(impl_type* impl);



  template <typename Service>
  friend Service& use_service(io_context& ioc);
# 614 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  impl_type& impl_;
};


class io_context::executor_type
{
public:

  io_context& context() const noexcept;







  void on_work_started() const noexcept;







  void on_work_finished() const noexcept;
# 654 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Function, typename Allocator>
  void dispatch(Function&& f, const Allocator& a) const;
# 670 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Function, typename Allocator>
  void post(Function&& f, const Allocator& a) const;
# 690 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  template <typename Function, typename Allocator>
  void defer(Function&& f, const Allocator& a) const;






  bool running_in_this_thread() const noexcept;





  friend bool operator==(const executor_type& a,
      const executor_type& b) noexcept
  {
    return &a.io_context_ == &b.io_context_;
  }





  friend bool operator!=(const executor_type& a,
      const executor_type& b) noexcept
  {
    return &a.io_context_ != &b.io_context_;
  }

private:
  friend class io_context;


  explicit executor_type(io_context& i) : io_context_(i) {}


  io_context& io_context_;
};
# 742 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
class io_context::work
{
public:






  explicit work(boost::asio::io_context& io_context);







  work(const work& other);







  ~work();


  boost::asio::io_context& get_io_context();



  boost::asio::io_context& get_io_service();

private:

  void operator=(const work& other);


  detail::io_context_impl& io_context_impl_;
};



class io_context::service
  : public execution_context::service
{
public:

  boost::asio::io_context& get_io_context();



  boost::asio::io_context& get_io_service();


private:

  inline virtual void shutdown();




  inline virtual void shutdown_service();
# 814 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline virtual void notify_fork(
      execution_context::fork_event event);
# 824 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 3 4
  inline virtual void fork_service(
      execution_context::fork_event event);


protected:




  inline service(boost::asio::io_context& owner);


  inline virtual ~service();
};

namespace detail {


template <typename Type>
class service_base
  : public boost::asio::io_context::service
{
public:
  static boost::asio::detail::service_id<Type> id;


  service_base(boost::asio::io_context& io_context)
    : boost::asio::io_context::service(io_context)
  {
  }
};

template <typename Type>
boost::asio::detail::service_id<Type> service_base<Type>::id;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 864 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/completion_handler.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/completion_handler.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_work.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_work.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_work.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {




template <typename Handler, typename Executor
    = typename associated_executor<Handler>::type>
class handler_work
{
public:
  explicit handler_work(Handler& handler) noexcept
    : executor_(associated_executor<Handler>::get(handler))
  {
  }

  static void start(Handler& handler) noexcept
  {
    Executor ex(associated_executor<Handler>::get(handler));
    ex.on_work_started();
  }

  ~handler_work()
  {
    executor_.on_work_finished();
  }

  template <typename Function>
  void complete(Function& function, Handler& handler)
  {
    executor_.dispatch(static_cast<Function&&>(function),
        associated_allocator<Handler>::get(handler));
  }

private:

  handler_work(const handler_work&);
  handler_work& operator=(const handler_work&);

  typename associated_executor<Handler>::type executor_;
};





template <typename Handler>
class handler_work<Handler, system_executor>
{
public:
  explicit handler_work(Handler&) noexcept {}
  static void start(Handler&) noexcept {}
  ~handler_work() {}

  template <typename Function>
  void complete(Function& function, Handler& handler)
  {
    boost_asio_handler_invoke_helpers::invoke(function, handler);
  }

private:

  handler_work(const handler_work&);
  handler_work& operator=(const handler_work&);
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/handler_work.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/completion_handler.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/completion_handler.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler>
class completion_handler : public operation
{
public:
  struct ptr { Handler* h; completion_handler* v; completion_handler* p; ~ptr() { reset(); } static completion_handler* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<completion_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~completion_handler(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<completion_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<completion_handler*>(v), 1); v = 0; } } };

  completion_handler(Handler& h)
    : operation(&completion_handler::do_complete),
      handler_(static_cast<Handler&&>(h))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    completion_handler* h(static_cast<completion_handler*>(base));
    ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
    handler_work<Handler> w(h->handler_);

    (void)0;







    Handler handler(static_cast<Handler&&>(h->handler_));
    p.h = boost::asio::detail::addressof(handler);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/completion_handler.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename Service>
inline Service& use_service(io_context& ioc)
{

  (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
  (void)static_cast<const execution_context::id*>(&Service::id);

  return ioc.service_registry_->template use_service<Service>(ioc);
}

template <>
inline detail::io_context_impl& use_service<detail::io_context_impl>(
    io_context& ioc)
{
  return ioc.impl_;
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 2 3 4

namespace boost {
namespace asio {

inline io_context::executor_type
io_context::get_executor() noexcept
{
  return executor_type(*this);
}



template <typename Rep, typename Period>
std::size_t io_context::run_for(
    const chrono::duration<Rep, Period>& rel_time)
{
  return this->run_until(chrono::steady_clock::now() + rel_time);
}

template <typename Clock, typename Duration>
std::size_t io_context::run_until(
    const chrono::time_point<Clock, Duration>& abs_time)
{
  std::size_t n = 0;
  while (this->run_one_until(abs_time))
    if (n != (std::numeric_limits<std::size_t>::max)())
      ++n;
  return n;
}

template <typename Rep, typename Period>
std::size_t io_context::run_one_for(
    const chrono::duration<Rep, Period>& rel_time)
{
  return this->run_one_until(chrono::steady_clock::now() + rel_time);
}

template <typename Clock, typename Duration>
std::size_t io_context::run_one_until(
    const chrono::time_point<Clock, Duration>& abs_time)
{
  typename Clock::time_point now = Clock::now();
  while (now < abs_time)
  {
    typename Clock::duration rel_time = abs_time - now;
    if (rel_time > chrono::seconds(1))
      rel_time = chrono::seconds(1);

    boost::system::error_code ec;
    std::size_t s = impl_.wait_one(
        static_cast<long>(chrono::duration_cast<
          chrono::microseconds>(rel_time).count()), ec);
    boost::asio::detail::throw_error(ec);

    if (s || impl_.stopped())
      return s;

    now = Clock::now();
  }

  return 0;
}





inline void io_context::reset()
{
  restart();
}

template <typename LegacyCompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void ()>::return_type
io_context::dispatch(LegacyCompletionHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__))
                                        type_check;

  async_completion<LegacyCompletionHandler, void ()> init(handler);

  if (impl_.can_dispatch())
  {
    detail::fenced_block b(detail::fenced_block::full);
    boost_asio_handler_invoke_helpers::invoke(
        init.completion_handler, init.completion_handler);
  }
  else
  {

    typedef detail::completion_handler<
      typename handler_type<LegacyCompletionHandler, void ()>::type> op;
    typename op::ptr p = { detail::addressof(init.completion_handler),
      op::ptr::allocate(init.completion_handler), 0 };
    p.p = new (p.v) op(init.completion_handler);

    (void)0
                                             ;

    impl_.do_dispatch(p.p);
    p.v = p.p = 0;
  }

  return init.result.get();
}

template <typename LegacyCompletionHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void ()>::return_type
io_context::post(LegacyCompletionHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__))
                                        type_check;

  async_completion<LegacyCompletionHandler, void ()> init(handler);

  bool is_continuation =
    boost_asio_handler_cont_helpers::is_continuation(init.completion_handler);


  typedef detail::completion_handler<
    typename handler_type<LegacyCompletionHandler, void ()>::type> op;
  typename op::ptr p = { detail::addressof(init.completion_handler),
      op::ptr::allocate(init.completion_handler), 0 };
  p.p = new (p.v) op(init.completion_handler);

  (void)0
                                       ;

  impl_.post_immediate_completion(p.p, is_continuation);
  p.v = p.p = 0;

  return init.result.get();
}

template <typename Handler>



inline detail::wrapped_handler<io_context&, Handler>

io_context::wrap(Handler handler)
{
  return detail::wrapped_handler<io_context&, Handler>(*this, handler);
}



inline io_context&
io_context::executor_type::context() const noexcept
{
  return io_context_;
}

inline void
io_context::executor_type::on_work_started() const noexcept
{
  io_context_.impl_.work_started();
}

inline void
io_context::executor_type::on_work_finished() const noexcept
{
  io_context_.impl_.work_finished();
}

template <typename Function, typename Allocator>
void io_context::executor_type::dispatch(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;


  if (io_context_.impl_.can_dispatch())
  {

    function_type tmp(static_cast<Function&&>(f));

    detail::fenced_block b(detail::fenced_block::full);
    boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
    return;
  }


  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                   ;

  io_context_.impl_.post_immediate_completion(p.p, false);
  p.v = p.p = 0;
}

template <typename Function, typename Allocator>
void io_context::executor_type::post(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;


  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                   ;

  io_context_.impl_.post_immediate_completion(p.p, false);
  p.v = p.p = 0;
}

template <typename Function, typename Allocator>
void io_context::executor_type::defer(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;


  typedef detail::executor_op<function_type, Allocator, detail::operation> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                    ;

  io_context_.impl_.post_immediate_completion(p.p, true);
  p.v = p.p = 0;
}

inline bool
io_context::executor_type::running_in_this_thread() const noexcept
{
  return io_context_.impl_.can_dispatch();
}


inline io_context::work::work(boost::asio::io_context& io_context)
  : io_context_impl_(io_context.impl_)
{
  io_context_impl_.work_started();
}

inline io_context::work::work(const work& other)
  : io_context_impl_(other.io_context_impl_)
{
  io_context_impl_.work_started();
}

inline io_context::work::~work()
{
  io_context_impl_.work_finished();
}

inline boost::asio::io_context& io_context::work::get_io_context()
{
  return static_cast<boost::asio::io_context&>(io_context_impl_.context());
}

inline boost::asio::io_context& io_context::work::get_io_service()
{
  return static_cast<boost::asio::io_context&>(io_context_impl_.context());
}


inline boost::asio::io_context& io_context::service::get_io_context()
{
  return static_cast<boost::asio::io_context&>(context());
}


inline boost::asio::io_context& io_context::service::get_io_service()
{
  return static_cast<boost::asio::io_context&>(context());
}


}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 346 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.hpp" 2 3 4
# 866 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.ipp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.ipp" 2 3 4

namespace boost {
namespace asio {

io_context::io_context()
  : impl_(add_impl(new impl_type(*this, -1)))
{
}

io_context::io_context(int concurrency_hint)
  : impl_(add_impl(new impl_type(*this, concurrency_hint == 1
          ? 1 : concurrency_hint)))
{
}

io_context::impl_type& io_context::add_impl(io_context::impl_type* impl)
{
  boost::asio::detail::scoped_ptr<impl_type> scoped_impl(impl);
  boost::asio::add_service<impl_type>(*this, scoped_impl.get());
  return *scoped_impl.release();
}

io_context::~io_context()
{
}

io_context::count_type io_context::run()
{
  boost::system::error_code ec;
  count_type s = impl_.run(ec);
  boost::asio::detail::throw_error(ec);
  return s;
}


io_context::count_type io_context::run(boost::system::error_code& ec)
{
  return impl_.run(ec);
}


io_context::count_type io_context::run_one()
{
  boost::system::error_code ec;
  count_type s = impl_.run_one(ec);
  boost::asio::detail::throw_error(ec);
  return s;
}


io_context::count_type io_context::run_one(boost::system::error_code& ec)
{
  return impl_.run_one(ec);
}


io_context::count_type io_context::poll()
{
  boost::system::error_code ec;
  count_type s = impl_.poll(ec);
  boost::asio::detail::throw_error(ec);
  return s;
}


io_context::count_type io_context::poll(boost::system::error_code& ec)
{
  return impl_.poll(ec);
}


io_context::count_type io_context::poll_one()
{
  boost::system::error_code ec;
  count_type s = impl_.poll_one(ec);
  boost::asio::detail::throw_error(ec);
  return s;
}


io_context::count_type io_context::poll_one(boost::system::error_code& ec)
{
  return impl_.poll_one(ec);
}


void io_context::stop()
{
  impl_.stop();
}

bool io_context::stopped() const
{
  return impl_.stopped();
}

void io_context::restart()
{
  impl_.restart();
}

io_context::service::service(boost::asio::io_context& owner)
  : execution_context::service(owner)
{
}

io_context::service::~service()
{
}

void io_context::service::shutdown()
{

  shutdown_service();

}


void io_context::service::shutdown_service()
{
}


void io_context::service::notify_fork(io_context::fork_event ev)
{

  fork_service(ev);



}


void io_context::service::fork_service(io_context::fork_event)
{
}


}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/io_context.ipp" 2 3 4
# 868 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/async/yield_context.h" 2
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/async/yield_context.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/all.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/all.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/attributes.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/attributes.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/flags.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/flags.hpp" 3 4
namespace boost {
namespace coroutines {

enum flag_unwind_t
{
    stack_unwind = 0,
    no_stack_unwind
};

}}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/attributes.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_allocator.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_allocator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/context/detail/config.hpp" 1 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/context/detail/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/auto_link.hpp" 1 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/context/detail/config.hpp" 2 3 4
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/context/detail/config.hpp" 3 4
static constexpr std::size_t cache_alignment{ 64 };
static constexpr std::size_t cacheline_length{ 64 };

static constexpr std::size_t prefetch_stride{ 4 * cacheline_length };
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_allocator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/segmented_stack_allocator.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_allocator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/standard_stack_allocator.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/standard_stack_allocator.hpp" 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/standard_stack_allocator.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/standard_stack_allocator.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/config.hpp" 1 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/auto_link.hpp" 1 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/config.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/standard_stack_allocator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_context.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_context.hpp" 3 4
namespace boost {
namespace coroutines {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_context.hpp" 3 4
struct stack_context
{
    std::size_t size;
    void * sp;




    stack_context() :
        size( 0), sp( 0)



    {}
};


}}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/standard_stack_allocator.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_traits.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_traits.hpp" 3 4
namespace boost {
namespace coroutines {

struct stack_traits
{
    static bool is_unbounded() noexcept;

    static std::size_t page_size() noexcept;

    static std::size_t default_size() noexcept;

    static std::size_t minimum_size() noexcept;

    static std::size_t maximum_size() noexcept;
};

}}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/standard_stack_allocator.hpp" 2 3 4





namespace boost {
namespace coroutines {

template< typename traitsT >
struct basic_standard_stack_allocator
{
    typedef traitsT traits_type;

    void allocate( stack_context & ctx, std::size_t size = traits_type::minimum_size() )
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        void * limit = std::malloc( size);
        if ( ! limit) throw std::bad_alloc();

        ctx.size = size;
        ctx.sp = static_cast< char * >( limit) + ctx.size;



    }

    void deallocate( stack_context & ctx)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));





        void * limit = static_cast< char * >( ctx.sp) - ctx.size;
        std::free( limit);
    }
};

typedef basic_standard_stack_allocator< stack_traits > standard_stack_allocator;

}}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/stack_allocator.hpp" 2 3 4





namespace boost {
namespace coroutines {




typedef standard_stack_allocator stack_allocator;


}}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/attributes.hpp" 2 3 4





namespace boost {
namespace coroutines {

struct attributes
{
    std::size_t size;
    flag_unwind_t do_unwind;

    attributes() noexcept :
        size( stack_allocator::traits_type::default_size() ),
        do_unwind( stack_unwind)
    {}

    explicit attributes( std::size_t size_) noexcept :
        size( size_),
        do_unwind( stack_unwind)
    {}

    explicit attributes( flag_unwind_t do_unwind_) noexcept :
        size( stack_allocator::traits_type::default_size() ),
        do_unwind( do_unwind_)
    {}

    explicit attributes(
            std::size_t size_,
            flag_unwind_t do_unwind_) noexcept :
        size( size_),
        do_unwind( do_unwind_)
    {}
};

}}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/all.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/coroutine.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/coroutine.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/result_iterator.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/result_iterator.hpp" 3 4
namespace boost
{




    template< typename C >
    struct range_result_iterator : range_iterator<C>
    { };

}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/const_reverse_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/const_reverse_iterator.hpp" 3 4
namespace boost
{




    template< typename C >
    struct range_const_reverse_iterator
            : range_reverse_iterator<
                const typename remove_reference<C>::type>
    { };

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/reverse_result_iterator.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/reverse_result_iterator.hpp" 3 4
namespace boost
{




    template< typename C >
    struct range_reverse_result_iterator : range_reverse_iterator<C>
    { };

}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/category.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/category.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_category : iterator_category< typename range_iterator<T>::type >
    { };
}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/reference.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/reference.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_reference : iterator_reference< typename range_iterator<T>::type >
    { };
}
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/pointer.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/pointer.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_pointer
            : iterator_pointer< typename range_iterator<T>::type >
    { };
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/metafunctions.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/sub_range.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/sub_range.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/sub_range.hpp" 2 3 4



namespace boost
{
    namespace range_detail
    {

template<class ForwardRange, class TraversalTag>
class sub_range_base
        : public iterator_range<
            typename range_iterator<ForwardRange>::type
        >
{
    typedef iterator_range<
        typename range_iterator<ForwardRange>::type
    > base;

protected:
    typedef typename base::iterator_range_ iterator_range_;

public:
    typedef typename range_value<ForwardRange>::type value_type;
    typedef typename range_iterator<ForwardRange>::type iterator;
    typedef typename range_iterator<const ForwardRange>::type const_iterator;
    typedef typename range_difference<ForwardRange>::type difference_type;
    typedef typename range_size<ForwardRange>::type size_type;
    typedef typename range_reference<ForwardRange>::type reference;
    typedef typename range_reference<const ForwardRange>::type const_reference;

    sub_range_base()
    {
    }

    template<class Iterator>
    sub_range_base(Iterator first, Iterator last)
        : base(first, last)
    {
    }

    reference front()
    {
        return base::front();
    }

    const_reference front() const
    {
        return base::front();
    }
};

template<class ForwardRange>
class sub_range_base<ForwardRange, bidirectional_traversal_tag>
        : public sub_range_base<ForwardRange, forward_traversal_tag>
{
    typedef sub_range_base<ForwardRange, forward_traversal_tag> base;
public:
    sub_range_base()
    {
    }

    template<class Iterator>
    sub_range_base(Iterator first, Iterator last)
        : base(first, last)
    {
    }

    typename base::reference back()
    {
        return base::back();
    }

    typename base::const_reference back() const
    {
        return base::back();
    }
};

template<class ForwardRange>
class sub_range_base<ForwardRange, random_access_traversal_tag>
        : public sub_range_base<ForwardRange, bidirectional_traversal_tag>
{
    typedef sub_range_base<ForwardRange, bidirectional_traversal_tag> base;

public:
    sub_range_base()
    {
    }

    template<class Iterator>
    sub_range_base(Iterator first, Iterator last)
        : base(first, last)
    {
    }

    typename base::reference
    operator[](typename base::difference_type n)
    {
        return this->begin()[n];
    }

    typename base::const_reference
    operator[](typename base::difference_type n) const
    {
        return this->begin()[n];
    }
};

    }

    template<class ForwardRange>
    class sub_range
        : public range_detail::sub_range_base<
                ForwardRange,
                typename iterator_traversal<
                    typename range_iterator<ForwardRange>::type
                >::type
            >
    {
        typedef typename range_iterator<
            ForwardRange
        >::type iterator_t;

        typedef range_detail::sub_range_base<
            ForwardRange,
            typename iterator_traversal<
                typename range_iterator<ForwardRange>::type
            >::type
        > base;

        typedef typename base::impl impl;

    protected:
        typedef typename base::iterator_range_ iterator_range_;

    private:
        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::iterator
            >
        {
        };

    public:
        sub_range()
        { }
# 190 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range/sub_range.hpp" 3 4
        template< class ForwardRange2 >
        sub_range(
            ForwardRange2& r,
            typename ::boost::enable_if<
                is_compatible_range<ForwardRange2>
            >::type* = 0
        )
        : base(impl::adl_begin(r), impl::adl_end(r))
        {
        }

        template< class ForwardRange2 >
        sub_range(
            const ForwardRange2& r,
            typename ::boost::enable_if<
                is_compatible_range<const ForwardRange2>
            >::type* = 0
        )
        : base(impl::adl_begin(r), impl::adl_end(r))
        {
        }

        typename base::const_iterator begin() const
        {
            return base::begin();
        }

        typename base::iterator begin()
        {
            return base::begin();
        }

        typename base::const_iterator end() const
        {
            return base::end();
        }

        typename base::iterator end()
        {
            return base::end();
        }

        template< class Iter >
        sub_range( Iter first, Iter last ) :
            base( first, last )
        { }

        template<class ForwardRange2>
        typename ::boost::enable_if<
            is_compatible_range<ForwardRange2>,
            sub_range&
        >::type
        operator=(ForwardRange2& r)
        {
            iterator_range_::operator=( r );
            return *this;
        }

        template<class ForwardRange2>
        typename ::boost::enable_if<
            is_compatible_range<const ForwardRange2>,
            sub_range&
        >::type
        operator=( const ForwardRange2& r )
        {
            iterator_range_::operator=( r );
            return *this;
        }

        sub_range& operator=( const sub_range& r )
        {
            iterator_range_::operator=( static_cast<const iterator_range_&>(r) );
            return *this;
        }

        sub_range& advance_begin(
            typename base::difference_type n)
        {
            std::advance(this->m_Begin, n);
            return *this;
        }

        sub_range& advance_end(
            typename base::difference_type n)
        {
            std::advance(this->m_End, n);
            return *this;
        }
    };

}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/range.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/utility/explicit_operator_bool.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/coroutine_context.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/coroutine_context.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/coroutine_context.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/context/detail/fcontext.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/context/detail/fcontext.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/context/detail/fcontext.hpp" 2 3 4







namespace boost {
namespace context {
namespace detail {

typedef void* fcontext_t;

struct transfer_t {
    fcontext_t fctx;
    void * data;
};

extern "C"
transfer_t jump_fcontext( fcontext_t const to, void * vp);
extern "C"
fcontext_t make_fcontext( void * sp, std::size_t size, void (* fn)( transfer_t) );


extern "C"
transfer_t ontop_fcontext( fcontext_t const to, void * vp, transfer_t (* fn)( transfer_t) );

}}}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/coroutine_context.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/preallocated.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/preallocated.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

struct preallocated {
    void * sp;
    std::size_t size;
    stack_context sctx;

    preallocated() noexcept :
        sp( 0), size( 0), sctx() {
    }

    preallocated( void * sp_, std::size_t size_, stack_context sctx_) noexcept :
        sp( sp_), size( size_), sctx( sctx_) {
    }
};

}}}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/coroutine_context.hpp" 2 3 4






namespace boost {
namespace coroutines {
namespace detail {


class coroutine_context
{
private:
    template< typename Coro >
    friend void trampoline( context::detail::transfer_t);
    template< typename Coro >
    friend void trampoline_void( context::detail::transfer_t);
    template< typename Coro >
    friend void trampoline_pull( context::detail::transfer_t);
    template< typename Coro >
    friend void trampoline_push( context::detail::transfer_t);
    template< typename Coro >
    friend void trampoline_push_void( context::detail::transfer_t);

    preallocated palloc_;
    context::detail::fcontext_t ctx_;

public:
    typedef void( * ctx_fn)( context::detail::transfer_t);


    coroutine_context();




    coroutine_context( ctx_fn fn, preallocated const& palloc);

    coroutine_context( coroutine_context const&);

    coroutine_context& operator=( coroutine_context const&);

    void * jump( coroutine_context &, void * = 0);

    stack_context & stack_ctx()
    { return palloc_.sctx; }
};

}}}
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/parameters.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/parameters.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/parameters.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/flags.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/flags.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

enum flag_t
{
    flag_started = 1 << 1,
    flag_running = 1 << 2,
    flag_complete = 1 << 3,
    flag_unwind_stack = 1 << 4,
    flag_force_unwind = 1 << 5
};

struct unwind_t
{
    enum flag_t
    { force_unwind = 1 };
};

struct synthesized_t
{
    enum flag_t
    { syntesized = 1 };
};

}}}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/parameters.hpp" 2 3 4





namespace boost {
namespace coroutines {
namespace detail {

template< typename Data >
struct parameters
{
    Data * data;
    bool do_unwind;
    void * coro;

    parameters() :
        data( 0), do_unwind( false), coro( 0)
    {}

    explicit parameters( void * coro_) :
        data( 0), do_unwind( false), coro( coro_)
    { (static_cast<void> (0)); }

    explicit parameters( Data * data_, void * coro_) :
        data( data_), do_unwind( false), coro( coro_)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
    }

    explicit parameters( unwind_t::flag_t) :
        data( 0), do_unwind( true)
    {}
};

template< typename Data >
struct parameters< Data & >
{
    Data * data;
    bool do_unwind;
    void * coro;

    parameters() :
        data( 0), do_unwind( false), coro( 0)
    {}

    explicit parameters( void * coro_) :
        data( 0), do_unwind( false), coro( coro_)
    { (static_cast<void> (0)); }

    explicit parameters( Data * data_, void * coro_) :
        data( data_), do_unwind( false), coro( coro_)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
    }

    explicit parameters( unwind_t::flag_t) :
        data( 0), do_unwind( true), coro( 0)
    {}
};

template<>
struct parameters< void >
{
    bool do_unwind;
    void * coro;

    parameters() :
        do_unwind( false), coro(0)
    {}

    parameters( void * coro_) :
        do_unwind( false), coro( coro_)
    { (static_cast<void> (0)); }

    explicit parameters( unwind_t::flag_t) :
        do_unwind( true), coro( 0)
    {}
};

}}}
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/exceptions.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/exceptions.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/detail/scoped_enum_emulation.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/exceptions.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/exceptions.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

struct forced_unwind {};

}

enum class coroutine_errc
{
  no_data = 1
}
;


system::error_category const& coroutine_category() noexcept;

}

namespace system {

template<>
struct is_error_code_enum< coroutines::coroutine_errc > : public true_type
{};







inline
error_code make_error_code( coroutines::coroutine_errc e)
{
    return error_code( underlying_cast< int >( e), coroutines::coroutine_category() );
}

inline
error_condition make_error_condition( coroutines::coroutine_errc e)
{
    return error_condition( underlying_cast< int >( e), coroutines::coroutine_category() );
}

}

namespace coroutines {

class coroutine_error : public std::logic_error
{
private:
    system::error_code ec_;

public:
    coroutine_error( system::error_code ec) :
        logic_error( ec.message() ),
        ec_( ec)
    {}

    system::error_code const& code() const noexcept
    { return ec_; }
};

class invalid_result : public coroutine_error
{
public:
    invalid_result() :
        coroutine_error(
            system::make_error_code(
                coroutine_errc::no_data) )
    {}
};

}}
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_impl.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_impl.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception_ptr.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/info.hpp" 1 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/info.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string_stub.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string_stub.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/is_output_streamable.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/is_output_streamable.hpp" 3 4
       
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/is_output_streamable.hpp" 3





namespace
boost
    {
    namespace
    to_string_detail
        {
        struct
        partial_ordering_helper1
            {
            template <class CharT,class Traits>
            partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
            };

        struct
        partial_ordering_helper2
            {
            template <class T>
            partial_ordering_helper2( T const & );
            };

        char operator<<( partial_ordering_helper1, partial_ordering_helper2 );

        template <class T,class CharT,class Traits>
        struct
        is_output_streamable_impl
            {
            static std::basic_ostream<CharT,Traits> & f();
            static T const & g();
            enum e { value=1!=(sizeof(f()<<g())) };
            };
        }

    template <class T, class CharT=char, class Traits=std::char_traits<CharT> >
    struct
    is_output_streamable
        {
        enum e { value=to_string_detail::is_output_streamable_impl<T,CharT,Traits>::value };
        };
    }
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string.hpp" 2 3 4



       
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string.hpp" 3





namespace
boost
    {
    template <class T,class U>
    std::string to_string( std::pair<T,U> const & );
    std::string to_string( std::exception const & );

    namespace
    to_string_detail
        {
        template <class T>
        typename disable_if<is_output_streamable<T>,char>::type to_string( T const & );
        using boost::to_string;

        template <class,bool IsOutputStreamable>
        struct has_to_string_impl;

        template <class T>
        struct
        has_to_string_impl<T,true>
            {
            enum e { value=1 };
            };

        template <class T>
        struct
        has_to_string_impl<T,false>
            {
            static T const & f();
            enum e { value=1!=sizeof(to_string(f())) };
            };
        }

    template <class T>
    inline
    typename enable_if<is_output_streamable<T>,std::string>::type
    to_string( T const & x )
        {
        std::ostringstream out;
        out << x;
        return out.str();
        }

    template <class T>
    struct
    has_to_string
        {
        enum e { value=to_string_detail::has_to_string_impl<T,is_output_streamable<T>::value>::value };
        };

    template <class T,class U>
    inline
    std::string
    to_string( std::pair<T,U> const & x )
        {
        return std::string("(") + to_string(x.first) + ',' + to_string(x.second) + ')';
        }

    inline
    std::string
    to_string( std::exception const & x )
        {
        return x.what();
        }
    }
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string_stub.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/object_hex_dump.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/object_hex_dump.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/type_info.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/type_info.hpp" 3 4
       
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/type_info.hpp" 3





namespace
boost
    {
    template <class T>
    inline
    std::string
    tag_type_name()
        {



        return core::demangle(typeid(T*).name());

        }

    template <class T>
    inline
    std::string
    type_name()
        {



        return core::demangle(typeid(T).name());

        }

    namespace
    exception_detail
        {
        struct
        type_info_
            {
            core::typeinfo const * type_;

            explicit
            type_info_( core::typeinfo const & type ):
                type_(&type)
                {
                }

            friend
            bool
            operator<( type_info_ const & a, type_info_ const & b )
                {
                return 0!=(a.type_->before(*b.type_));
                }
            };
        }
    }
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/object_hex_dump.hpp" 2 3 4




# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/object_hex_dump.hpp" 2 3 4


       
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/object_hex_dump.hpp" 3





namespace
boost
    {
    namespace
    exception_detail
        {
        template <class T>
        inline
        std::string
        object_hex_dump( T const & x, std::size_t max_size=16 )
            {
            std::ostringstream s;
            s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: ";
            std::size_t n=sizeof(T)>max_size?max_size:sizeof(T);
            s.fill('0');
            s.width(2);
            unsigned char const * b=reinterpret_cast<unsigned char const *>(&x);
            s << std::setw(2) << std::hex << (unsigned int)*b;
            for( unsigned char const * e=b+n; ++b!=e; )
                s << " " << std::setw(2) << std::hex << (unsigned int)*b;
            return s.str();
            }
        }
    }
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string_stub.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string_stub.hpp" 2 3 4


       
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/to_string_stub.hpp" 3





namespace
boost
    {
    namespace
    exception_detail
        {
        template <bool ToStringAvailable>
        struct
        to_string_dispatcher
            {
            template <class T,class Stub>
            static
            std::string
            convert( T const & x, Stub )
                {
                return to_string(x);
                }
            };

        template <>
        struct
        to_string_dispatcher<false>
            {
            template <class T,class Stub>
            static
            std::string
            convert( T const & x, Stub s )
                {
                return s(x);
                }

            template <class T>
            static
            std::string
            convert( T const & x, std::string s )
                {
                return s;
                }

            template <class T>
            static
            std::string
            convert( T const & x, char const * s )
                {
                (static_cast<void> (0));
                return s;
                }
            };

        namespace
        to_string_dispatch
            {
            template <class T,class Stub>
            inline
            std::string
            dispatch( T const & x, Stub s )
                {
                return to_string_dispatcher<has_to_string<T>::value>::convert(x,s);
                }
            }

        template <class T>
        inline
        std::string
        string_stub_dump( T const & x )
            {
            return "[ " + exception_detail::object_hex_dump(x) + " ]";
            }
        }

    template <class T>
    inline
    std::string
    to_string_stub( T const & x )
        {
        return exception_detail::to_string_dispatch::dispatch(x,&exception_detail::string_stub_dump<T>);
        }

    template <class T,class Stub>
    inline
    std::string
    to_string_stub( T const & x, Stub s )
        {
        return exception_detail::to_string_dispatch::dispatch(x,s);
        }

    template <class T,class U,class Stub>
    inline
    std::string
    to_string_stub( std::pair<T,U> const & x, Stub s )
        {
        return std::string("(") + to_string_stub(x.first,s) + ',' + to_string_stub(x.second,s) + ')';
        }
    }
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/info.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/error_info_impl.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/error_info_impl.hpp" 3 4
       
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/error_info_impl.hpp" 3





namespace
boost
    {
    namespace
    exception_detail
        {
        class
        error_info_base
            {
            public:

            virtual std::string name_value_string() const = 0;
            virtual error_info_base * clone() const = 0;

            virtual
            ~error_info_base() throw()
                {
                }
            };
        }

    template <class Tag,class T>
    class
    error_info:
        public exception_detail::error_info_base
        {
        error_info_base *
        clone() const
            {
            return new error_info<Tag,T>(*this);
            }
        public:
        typedef T value_type;
        error_info( value_type const & v ):
            v_(v)
            {
            }


        error_info( error_info const & x ):
            v_(x.v_)
            {
            }
        error_info( T && v ) noexcept((boost::is_nothrow_move_constructible<T>::value)):
            v_(std::move(v))
            {
            }
        error_info( error_info && x ) noexcept((boost::is_nothrow_move_constructible<T>::value)):
            v_(std::move(x.v_))
            {
            }


        ~error_info() throw()
            {
            }
        value_type const &
        value() const
            {
            return v_;
            }
        value_type &
        value()
            {
            return v_;
            }
        private:
        error_info & operator=( error_info const & );

        error_info & operator=( error_info && x );

        std::string name_value_string() const;
        value_type v_;
        };
    }
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/info.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/shared_ptr.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/shared_ptr.hpp" 3 4
namespace boost { namespace exception_detail { using boost::shared_ptr; } }
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/info.hpp" 2 3 4



       
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/info.hpp" 3





namespace
boost
    {
    template <class Tag,class T>
    inline
    std::string
    error_info_name( error_info<Tag,T> const & x )
        {
        return tag_type_name<Tag>();
        }

    template <class Tag,class T>
    inline
    std::string
    to_string( error_info<Tag,T> const & x )
        {
        return '[' + error_info_name(x) + "] = " + to_string_stub(x.value()) + '\n';
        }

    template <class Tag,class T>
    inline
    std::string
    error_info<Tag,T>::
    name_value_string() const
        {
        return to_string_stub(*this);
        }

    namespace
    exception_detail
        {
        class
        error_info_container_impl:
            public error_info_container
            {
            public:

            error_info_container_impl():
                count_(0)
                {
                }

            ~error_info_container_impl() throw()
                {
                }

            void
            set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ )
                {
                (static_cast<void> (0));
                info_[typeid_] = x;
                diagnostic_info_str_.clear();
                }

            shared_ptr<error_info_base>
            get( type_info_ const & ti ) const
                {
                error_info_map::const_iterator i=info_.find(ti);
                if( info_.end()!=i )
                    {
                    shared_ptr<error_info_base> const & p = i->second;

                    (static_cast<void> (0));

                    return p;
                    }
                return shared_ptr<error_info_base>();
                }

            char const *
            diagnostic_information( char const * header ) const
                {
                if( header )
                    {
                    std::ostringstream tmp;
                    tmp << header;
                    for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
                        {
                        error_info_base const & x = *i->second;
                        tmp << x.name_value_string();
                        }
                    tmp.str().swap(diagnostic_info_str_);
                    }
                return diagnostic_info_str_.c_str();
                }

            private:

            friend class boost::exception;

            typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map;
            error_info_map info_;
            mutable std::string diagnostic_info_str_;
            mutable int count_;

            error_info_container_impl( error_info_container_impl const & );
            error_info_container_impl & operator=( error_info_container const & );

            void
            add_ref() const
                {
                ++count_;
                }

            bool
            release() const
                {
                if( --count_ )
                    return false;
                else
                    {
                    delete this;
                    return true;
                    }
                }

            refcount_ptr<error_info_container>
            clone() const
                {
                refcount_ptr<error_info_container> p;
                error_info_container_impl * c=new error_info_container_impl;
                p.adopt(c);
                for( error_info_map::const_iterator i=info_.begin(),e=info_.end(); i!=e; ++i )
                    {
                    shared_ptr<error_info_base> cp(i->second->clone());
                    c->info_.insert(std::make_pair(i->first,cp));
                    }
                return p;
                }
            };

        template <class E,class Tag,class T>
        inline
        E const &
        set_info( E const & x, error_info<Tag,T> const & v )
            {
            typedef error_info<Tag,T> error_info_tag_t;
            shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
            exception_detail::error_info_container * c=x.data_.get();
            if( !c )
                x.data_.adopt(c=new exception_detail::error_info_container_impl);
            c->set(p,::boost::exception_detail::type_info_(typeid(error_info_tag_t)));
            return x;
            }


        template <class E,class Tag,class T>
        E const & set_info( E const &, error_info<Tag,T> && );
        template <class T>
        struct set_info_rv;
        template <class Tag,class T>
        struct
        set_info_rv<error_info<Tag,T> >
            {
            template <class E,class Tag1,class T1>
            friend E const & set_info( E const &, error_info<Tag1,T1> && );
            template <class E>
            static
            E const &
            set( E const & x, error_info<Tag,T> && v )
                {
                typedef error_info<Tag,T> error_info_tag_t;
                shared_ptr<error_info_tag_t> p( new error_info_tag_t(std::move(v)) );
                exception_detail::error_info_container * c=x.data_.get();
                if( !c )
                    x.data_.adopt(c=new exception_detail::error_info_container_impl);
                c->set(p,::boost::exception_detail::type_info_(typeid(error_info_tag_t)));
                return x;
                }
            };
        template <>
        struct
        set_info_rv<throw_function>
            {
            template <class E,class Tag1,class T1>
            friend E const & set_info( E const &, error_info<Tag1,T1> && );
            template <class E>
            static
            E const &
            set( E const & x, throw_function && y )
                {
                x.throw_function_=y.v_;
                return x;
                }
            };
        template <>
        struct
        set_info_rv<throw_file>
            {
            template <class E,class Tag1,class T1>
            friend E const & set_info( E const &, error_info<Tag1,T1> && );
            template <class E>
            static
            E const &
            set( E const & x, throw_file && y )
                {
                x.throw_file_=y.v_;
                return x;
                }
            };
        template <>
        struct
        set_info_rv<throw_line>
            {
            template <class E,class Tag1,class T1>
            friend E const & set_info( E const &, error_info<Tag1,T1> && );
            template <class E>
            static
            E const &
            set( E const & x, throw_line && y )
                {
                x.throw_line_=y.v_;
                return x;
                }
            };
        template <class E,class Tag,class T>
        inline
        E const &
        set_info( E const & x, error_info<Tag,T> && v )
            {
            return set_info_rv<error_info<Tag,T> >::template set<E>(x,std::move(v));
            }


        template <class T>
        struct
        derives_boost_exception
            {
            enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
            };
        }

    template <class E,class Tag,class T>
    inline
    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
    operator<<( E const & x, error_info<Tag,T> const & v )
        {
        return exception_detail::set_info(x,v);
        }


    template <class E,class Tag,class T>
    inline
    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
    operator<<( E const & x, error_info<Tag,T> && v )
        {
        return exception_detail::set_info(x,std::move(v));
        }

    }
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/diagnostic_information.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/diagnostic_information.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/get_error_info.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/get_error_info.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/get_error_info.hpp" 2 3 4


       
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/get_error_info.hpp" 3





namespace
boost
    {
    namespace
    exception_detail
        {
        template <class ErrorInfo>
        struct
        get_info
            {
            static
            typename ErrorInfo::value_type *
            get( exception const & x )
                {
                if( exception_detail::error_info_container * c=x.data_.get() )
                    if( shared_ptr<exception_detail::error_info_base> eib = c->get(::boost::exception_detail::type_info_(typeid(ErrorInfo))) )
                        {

                        (static_cast<void> (0));

                        ErrorInfo * w = static_cast<ErrorInfo *>(eib.get());
                        return &w->value();
                        }
                return 0;
                }
            };

        template <>
        struct
        get_info<throw_function>
            {
            static
            char const * *
            get( exception const & x )
                {
                return x.throw_function_ ? &x.throw_function_ : 0;
                }
            };

        template <>
        struct
        get_info<throw_file>
            {
            static
            char const * *
            get( exception const & x )
                {
                return x.throw_file_ ? &x.throw_file_ : 0;
                }
            };

        template <>
        struct
        get_info<throw_line>
            {
            static
            int *
            get( exception const & x )
                {
                return x.throw_line_!=-1 ? &x.throw_line_ : 0;
                }
            };

        template <class T,class R>
        struct
        get_error_info_return_type
            {
            typedef R * type;
            };

        template <class T,class R>
        struct
        get_error_info_return_type<T const,R>
            {
            typedef R const * type;
            };
        }
# 117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/get_error_info.hpp" 3
    template <class ErrorInfo,class E>
    inline
    typename exception_detail::get_error_info_return_type<E,typename ErrorInfo::value_type>::type
    get_error_info( E & some_exception )
        {
        if( exception const * x = dynamic_cast<exception const *>(&some_exception) )
            return exception_detail::get_info<ErrorInfo>::get(*x);
        else
            return 0;
        }

    }
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/diagnostic_information.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/diagnostic_information.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/current_exception_cast.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/current_exception_cast.hpp" 3 4
       
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/current_exception_cast.hpp" 3





namespace
boost
    {
    template <class E>
    inline
    E *
    current_exception_cast()
        {
        try
            {
            throw;
            }
        catch(
        E & e )
            {
            return &e;
            }
        catch(
        ...)
            {
            return 0;
            }
        }
    }
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/diagnostic_information.hpp" 2 3 4



       
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/diagnostic_information.hpp" 3






namespace
boost
    {
    namespace
    exception_detail
        {
        std::string diagnostic_information_impl( boost::exception const *, std::exception const *, bool, bool );
        }

    inline
    std::string
    current_exception_diagnostic_information( bool verbose=true)
        {
        boost::exception const * be=current_exception_cast<boost::exception const>();
        std::exception const * se=current_exception_cast<std::exception const>();
        if( be || se )
            return exception_detail::diagnostic_information_impl(be,se,true,verbose);
        else
            return "No diagnostic information available.";
        }
    }


namespace
boost
    {
    namespace
    exception_detail
        {
        inline
        exception const *
        get_boost_exception( exception const * e )
            {
            return e;
            }

        inline
        exception const *
        get_boost_exception( ... )
            {
            return 0;
            }

        inline
        std::exception const *
        get_std_exception( std::exception const * e )
            {
            return e;
            }

        inline
        std::exception const *
        get_std_exception( ... )
            {
            return 0;
            }

        inline
        char const *
        get_diagnostic_information( exception const & x, char const * header )
            {

            try
                {

                error_info_container * c=x.data_.get();
                if( !c )
                    x.data_.adopt(c=new exception_detail::error_info_container_impl);
                char const * di=c->diagnostic_information(header);
                (static_cast<void> (0));
                return di;

                }
            catch(...)
                {
                return 0;
                }

            }

        inline
        std::string
        diagnostic_information_impl( boost::exception const * be, std::exception const * se, bool with_what, bool verbose )
            {
            if( !be && !se )
                return "Unknown exception.";

            if( !be )
                be=dynamic_cast<boost::exception const *>(se);
            if( !se )
                se=dynamic_cast<std::exception const *>(be);

            char const * wh=0;
            if( with_what && se )
                {
                wh=se->what();
                if( be && exception_detail::get_diagnostic_information(*be,0)==wh )
                    return wh;
                }
            std::ostringstream tmp;
            if( be && verbose )
                {
                char const * const * f=get_error_info<throw_file>(*be);
                int const * l=get_error_info<throw_line>(*be);
                char const * const * fn=get_error_info<throw_function>(*be);
                if( !f && !l && !fn )
                    tmp << "Throw location unknown (consider using BOOST_THROW_EXCEPTION)\n";
                else
                    {
                    if( f )
                        {
                        tmp << *f;
                        if( int const * l=get_error_info<throw_line>(*be) )
                            tmp << '(' << *l << "): ";
                        }
                    tmp << "Throw in function ";
                    if( char const * const * fn=get_error_info<throw_function>(*be) )
                        tmp << *fn;
                    else
                        tmp << "(unknown)";
                    tmp << '\n';
                    }
                }

            if ( verbose )
                tmp << std::string("Dynamic exception type: ") <<
                    core::demangle((be?(::boost::exception_detail::type_info_(typeid(*be))):(::boost::exception_detail::type_info_(typeid(*se)))).type_->name()) << '\n';

            if( with_what && se && verbose )
                tmp << "std::exception::what: " << wh << '\n';
            if( be )
                if( char const * s=exception_detail::get_diagnostic_information(*be,tmp.str().c_str()) )
                    if( *s )
                        return std::string(s);
            return tmp.str();
            }
        }

    template <class T>
    std::string
    diagnostic_information( T const & e, bool verbose=true )
        {
        return exception_detail::diagnostic_information_impl(exception_detail::get_boost_exception(&e),exception_detail::get_std_exception(&e),true,verbose);
        }

    inline
    char const *
    diagnostic_information_what( exception const & e, bool verbose=true ) throw()
        {
        char const * w=0;

        try
            {

            (void) exception_detail::diagnostic_information_impl(&e,0,false,verbose);
            if( char const * di=exception_detail::get_diagnostic_information(e,0) )
                return di;
            else
                return "Failed to produce boost::diagnostic_information_what()";

            }
        catch(
        ... )
            {
            }

        return w;
        }
    }
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/clone_current_exception.hpp" 1 3 4
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/clone_current_exception.hpp" 3 4
       
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/clone_current_exception.hpp" 3
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/clone_current_exception.hpp" 3
namespace
boost
    {
    namespace
    exception_detail
        {
        class clone_base;





        namespace
        clone_current_exception_result
            {
            int const success=0;
            int const bad_alloc=1;
            int const bad_exception=2;
            int const not_supported=3;
            }

        inline
        int
        clone_current_exception( clone_base const * & cloned )
            {



            return clone_current_exception_result::not_supported;

            }
        }
    }
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 3 4
# 1 "/usr/include/c++/10/stdlib.h" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 2 3 4


       
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 3





namespace
boost
    {
    class exception_ptr;
    __attribute__ ((__noreturn__)) void rethrow_exception( exception_ptr const & );
    exception_ptr current_exception();

    class
    exception_ptr
        {
        typedef boost::shared_ptr<exception_detail::clone_base const> impl;
        impl ptr_;
        friend void rethrow_exception( exception_ptr const & );
        typedef exception_detail::clone_base const * (impl::*unspecified_bool_type)() const;
        public:
        exception_ptr()
            {
            }
        explicit
        exception_ptr( impl const & ptr ):
            ptr_(ptr)
            {
            }
        bool
        operator==( exception_ptr const & other ) const
            {
            return ptr_==other.ptr_;
            }
        bool
        operator!=( exception_ptr const & other ) const
            {
            return ptr_!=other.ptr_;
            }
        operator unspecified_bool_type() const
            {
            return ptr_?&impl::get:0;
            }
        };

    template <class T>
    inline
    exception_ptr
    copy_exception( T const & e )
        {
        try
            {
            throw enable_current_exception(e);
            }
        catch(
        ... )
            {
            return current_exception();
            }
        }


    typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;

    inline
    std::string
    to_string( original_exception_type const & x )
        {
        return core::demangle(x.value()->name());
        }


    namespace
    exception_detail
        {
        struct
        bad_alloc_:
            boost::exception,
            std::bad_alloc
                {
                ~bad_alloc_() throw() { }
                };

        struct
        bad_exception_:
            boost::exception,
            std::bad_exception
                {
                ~bad_exception_() throw() { }
                };

        template <class Exception>
        exception_ptr
        get_static_exception_object()
            {
            Exception ba;
            exception_detail::clone_impl<Exception> c(ba);

            c <<
                throw_function(__PRETTY_FUNCTION__) <<
                throw_file("/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp") <<
                throw_line(129);

            static exception_ptr ep(shared_ptr<exception_detail::clone_base const>(new exception_detail::clone_impl<Exception>(c)));
            return ep;
            }

        template <class Exception>
        struct
        exception_ptr_static_exception_object
            {
            static exception_ptr const e;
            };

        template <class Exception>
        exception_ptr const
        exception_ptr_static_exception_object<Exception>::
        e = get_static_exception_object<Exception>();
        }



#pragma GCC visibility push (default)


    class
    unknown_exception:
        public boost::exception,
        public std::exception
        {
        public:

        unknown_exception()
            {
            }

        explicit
        unknown_exception( std::exception const & e )
            {
            add_original_type(e);
            }

        explicit
        unknown_exception( boost::exception const & e ):
            boost::exception(e)
            {
            add_original_type(e);
            }

        ~unknown_exception() throw()
            {
            }

        private:

        template <class E>
        void
        add_original_type( E const & e )
            {

            (*this) << original_exception_type(&typeid(e));

            }
        };


#pragma GCC visibility pop



    namespace
    exception_detail
        {
        template <class T>
        class
        current_exception_std_exception_wrapper:
            public T,
            public boost::exception
            {
            public:

            explicit
            current_exception_std_exception_wrapper( T const & e1 ):
                T(e1)
                {
                add_original_type(e1);
                }

            current_exception_std_exception_wrapper( T const & e1, boost::exception const & e2 ):
                T(e1),
                boost::exception(e2)
                {
                add_original_type(e1);
                }

            ~current_exception_std_exception_wrapper() throw()
                {
                }

            private:

            template <class E>
            void
            add_original_type( E const & e )
                {

                (*this) << original_exception_type(&typeid(e));

                }
            };
# 259 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception/detail/exception_ptr.hpp" 3
        template <class T>
        boost::exception const *
        get_boost_exception( T const * x )
            {
            return dynamic_cast<boost::exception const *>(x);
            }


        template <class T>
        inline
        exception_ptr
        current_exception_std_exception( T const & e1 )
            {
            if( boost::exception const * e2 = get_boost_exception(&e1) )
                return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1,*e2));
            else
                return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1));
            }

        inline
        exception_ptr
        current_exception_unknown_exception()
            {
            return boost::copy_exception(unknown_exception());
            }

        inline
        exception_ptr
        current_exception_unknown_boost_exception( boost::exception const & e )
            {
            return boost::copy_exception(unknown_exception(e));
            }

        inline
        exception_ptr
        current_exception_unknown_std_exception( std::exception const & e )
            {
            if( boost::exception const * be = get_boost_exception(&e) )
                return current_exception_unknown_boost_exception(*be);
            else
                return boost::copy_exception(unknown_exception(e));
            }

        inline
        exception_ptr
        current_exception_impl()
            {
            exception_detail::clone_base const * e=0;
            switch(
            exception_detail::clone_current_exception(e) )
                {
                case exception_detail::clone_current_exception_result::
                success:
                    {
                    (static_cast<void> (0));
                    return exception_ptr(shared_ptr<exception_detail::clone_base const>(e));
                    }
                case exception_detail::clone_current_exception_result::
                bad_alloc:
                    {
                    (static_cast<void> (0));
                    return exception_detail::exception_ptr_static_exception_object<bad_alloc_>::e;
                    }
                case exception_detail::clone_current_exception_result::
                bad_exception:
                    {
                    (static_cast<void> (0));
                    return exception_detail::exception_ptr_static_exception_object<bad_exception_>::e;
                    }
                default:
                    (static_cast<void> (0));
                case exception_detail::clone_current_exception_result::
                not_supported:
                    {
                    (static_cast<void> (0));
                    try
                        {
                        throw;
                        }
                    catch(
                    exception_detail::clone_base & e )
                        {
                        return exception_ptr(shared_ptr<exception_detail::clone_base const>(e.clone()));
                        }
                    catch(
                    std::domain_error & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::invalid_argument & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::length_error & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::out_of_range & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::logic_error & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::range_error & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::overflow_error & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::underflow_error & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::ios_base::failure & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::runtime_error & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::bad_alloc & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }

                    catch(
                    std::bad_cast & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::bad_typeid & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }

                    catch(
                    std::bad_exception & e )
                        {
                        return exception_detail::current_exception_std_exception(e);
                        }
                    catch(
                    std::exception & e )
                        {
                        return exception_detail::current_exception_unknown_std_exception(e);
                        }
                    catch(
                    boost::exception & e )
                        {
                        return exception_detail::current_exception_unknown_boost_exception(e);
                        }
                    catch(
                    ... )
                        {
                        return exception_detail::current_exception_unknown_exception();
                        }
                    }
                }
            }
        }

    inline
    exception_ptr
    current_exception()
        {
        exception_ptr ret;
        try
            {
            ret=exception_detail::current_exception_impl();
            }
        catch(
        std::bad_alloc & )
            {
            ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_alloc_>::e;
            }
        catch(
        ... )
            {
            ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_exception_>::e;
            }
        (static_cast<void> (0));
        return ret;
        }

    __attribute__ ((__noreturn__))
    inline
    void
    rethrow_exception( exception_ptr const & p )
        {
        (static_cast<void> (0));
        p.ptr_->rethrow();
        (static_cast<void> (0));




            abort();

        }

    inline
    std::string
    diagnostic_information( exception_ptr const & p, bool verbose=true )
        {
        if( p )
            try
                {
                rethrow_exception(p);
                }
            catch(
            ... )
                {
                return current_exception_diagnostic_information(verbose);
                }
        return "<empty>";
        }

    inline
    std::string
    to_string( exception_ptr const & p )
        {
        std::string s='\n'+diagnostic_information(p);
        std::string padding("  ");
        std::string r;
        bool f=false;
        for( std::string::const_iterator i=s.begin(),e=s.end(); i!=e; ++i )
            {
            if( f )
                r+=padding;
            char c=*i;
            r+=c;
            f=(c=='\n');
            }
        return r;
        }
    }
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/exception_ptr.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_impl.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_pull.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_pull.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_pull.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_pull.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/data.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/data.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

struct data_t
{
    coroutine_context * from;
    void * data;
};

}}}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_pull.hpp" 2 3 4





namespace boost {
namespace coroutines {
namespace detail {

template< typename Coro >
void trampoline_pull( context::detail::transfer_t t)
{
    typedef typename Coro::param_type param_type;

    data_t * data = static_cast< data_t * >( t.data);
    data->from->ctx_ = t.fctx;
    param_type * param(
        static_cast< param_type * >( data->data) );
    (static_cast<void> (0));

    Coro * coro(
        static_cast< Coro * >( param->coro) );
    (static_cast<void> (0));

    coro->run();
}

}}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_impl.hpp" 2 3 4






namespace boost {
namespace coroutines {

struct stack_context;

namespace detail {

template< typename R >
class pull_coroutine_impl : private noncopyable
{
protected:
    int flags_;
    exception_ptr except_;
    coroutine_context * caller_;
    coroutine_context * callee_;
    R * result_;

public:
    typedef parameters< R > param_type;

    pull_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee),
        result_( 0)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    pull_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind,
                         R * result) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee),
        result_( result)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~pull_coroutine_impl() {}

    bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            param_type to( unwind_t::force_unwind);
            caller_->jump(
                * callee_,
                & to);
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    void pull()
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        param_type to( this);
        param_type * from(
            static_cast< param_type * >(
                caller_->jump(
                    * callee_,
                    & to) ) );
        flags_ &= ~flag_running;
        result_ = from->data;
        if ( from->do_unwind) throw forced_unwind();
        if ( except_) rethrow_exception( except_);
    }

    bool has_result() const
    { return 0 != result_; }

    R get() const
    {
        if ( ! has_result() )
            boost::throw_exception(
                invalid_result() );
        return * result_;
    }

    R * get_pointer() const
    {
        if ( ! has_result() )
            boost::throw_exception(
                invalid_result() );
        return result_;
    }

    virtual void destroy() = 0;
};

template< typename R >
class pull_coroutine_impl< R & > : private noncopyable
{
protected:
    int flags_;
    exception_ptr except_;
    coroutine_context * caller_;
    coroutine_context * callee_;
    R * result_;

public:
    typedef parameters< R & > param_type;

    pull_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee),
        result_( 0)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    pull_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind,
                         R * result) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee),
        result_( result)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~pull_coroutine_impl() {}

    bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            param_type to( unwind_t::force_unwind);
            caller_->jump(
                * callee_,
                & to);
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    void pull()
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        param_type to( this);
        param_type * from(
            static_cast< param_type * >(
                caller_->jump(
                    * callee_,
                    & to) ) );
        flags_ &= ~flag_running;
        result_ = from->data;
        if ( from->do_unwind) throw forced_unwind();
        if ( except_) rethrow_exception( except_);
    }

    bool has_result() const
    { return 0 != result_; }

    R & get() const
    {
        if ( ! has_result() )
            boost::throw_exception(
                invalid_result() );
        return * result_;
    }

    R * get_pointer() const
    {
        if ( ! has_result() )
            boost::throw_exception(
                invalid_result() );
        return result_;
    }

    virtual void destroy() = 0;
};

template<>
class pull_coroutine_impl< void > : private noncopyable
{
protected:
    int flags_;
    exception_ptr except_;
    coroutine_context * caller_;
    coroutine_context * callee_;

public:
    typedef parameters< void > param_type;

    pull_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~pull_coroutine_impl() {}

    inline bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    inline bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    inline bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    inline bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    inline bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    inline void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            param_type to( unwind_t::force_unwind);
            caller_->jump(
                * callee_,
                & to);
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    inline void pull()
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        param_type to( this);
        param_type * from(
            static_cast< param_type * >(
                caller_->jump(
                    * callee_,
                    & to) ) );
        flags_ &= ~flag_running;
        if ( from->do_unwind) throw forced_unwind();
        if ( except_) rethrow_exception( except_);
    }

    virtual void destroy() = 0;
};

}}}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

struct pull_coroutine_context
{
    coroutine_context caller;
    coroutine_context callee;

    template< typename Coro >
    pull_coroutine_context( preallocated const& palloc, Coro *) :
        caller(),
        callee( trampoline_pull< Coro >, palloc)
    {}
};

template< typename PushCoro, typename R, typename Fn, typename StackAllocator >
class pull_coroutine_object : private pull_coroutine_context,
                              public pull_coroutine_impl< R >
{
private:
    typedef pull_coroutine_context ctx_t;
    typedef pull_coroutine_impl< R > base_t;
    typedef pull_coroutine_object< PushCoro, R, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 3 4
    pull_coroutine_object( Fn && fn, attributes const& attrs,
                           preallocated const& palloc,
                           StackAllocator const& stack_alloc) noexcept :
        ctx_t( palloc, this),
        base_t( & this->caller,
                & this->callee,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run()
    {
        (static_cast<void> (0));

        base_t::flags_ |= flag_started;
        base_t::flags_ |= flag_running;


        typename PushCoro::synth_type b( & this->callee, & this->caller, false);
        PushCoro push_coro( synthesized_t::syntesized, b);
        try
        { fn_( push_coro); }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { base_t::except_ = current_exception(); }

        base_t::flags_ |= flag_complete;
        base_t::flags_ &= ~flag_running;
        typename base_t::param_type to;
        this->callee.jump(
            this->caller,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

template< typename PushCoro, typename R, typename Fn, typename StackAllocator >
class pull_coroutine_object< PushCoro, R &, Fn, StackAllocator > : private pull_coroutine_context,
                                                                   public pull_coroutine_impl< R & >
{
private:
    typedef pull_coroutine_context ctx_t;
    typedef pull_coroutine_impl< R & > base_t;
    typedef pull_coroutine_object< PushCoro, R &, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 3 4
    pull_coroutine_object( Fn && fn, attributes const& attrs,
                           preallocated const& palloc,
                           StackAllocator const& stack_alloc) noexcept :
        ctx_t( palloc, this),
        base_t( & this->caller,
                & this->callee,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run()
    {
        (static_cast<void> (0));

        base_t::flags_ |= flag_started;
        base_t::flags_ |= flag_running;


        typename PushCoro::synth_type b( & this->callee, & this->caller, false);
        PushCoro push_coro( synthesized_t::syntesized, b);
        try
        { fn_( push_coro); }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { base_t::except_ = current_exception(); }

        base_t::flags_ |= flag_complete;
        base_t::flags_ &= ~flag_running;
        typename base_t::param_type to;
        this->callee.jump(
            this->caller,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

template< typename PushCoro, typename Fn, typename StackAllocator >
class pull_coroutine_object< PushCoro, void, Fn, StackAllocator > : private pull_coroutine_context,
                                                                    public pull_coroutine_impl< void >
{
private:
    typedef pull_coroutine_context ctx_t;
    typedef pull_coroutine_impl< void > base_t;
    typedef pull_coroutine_object< PushCoro, void, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_object.hpp" 3 4
    pull_coroutine_object( Fn && fn, attributes const& attrs,
                           preallocated const& palloc,
                           StackAllocator const& stack_alloc) noexcept :
        ctx_t( palloc, this),
        base_t( & this->caller,
                & this->callee,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run()
    {
        (static_cast<void> (0));

        base_t::flags_ |= flag_started;
        base_t::flags_ |= flag_running;


        typename PushCoro::synth_type b( & this->callee, & this->caller, false);
        PushCoro push_coro( synthesized_t::syntesized, b);
        try
        { fn_( push_coro); }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { base_t::except_ = current_exception(); }

        base_t::flags_ |= flag_complete;
        base_t::flags_ &= ~flag_running;
        typename base_t::param_type to;
        this->callee.jump(
            this->caller,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

}}}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_synthesized.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/pull_coroutine_synthesized.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

template< typename R >
class pull_coroutine_synthesized : public pull_coroutine_impl< R >
{
private:
    typedef pull_coroutine_impl< R > impl_t;

public:
    pull_coroutine_synthesized( coroutine_context * caller,
                                coroutine_context * callee,
                                bool unwind,
                                R * result) :
        impl_t( caller, callee, unwind, result)
    {}

    void destroy() {}
};

template< typename R >
class pull_coroutine_synthesized< R & > : public pull_coroutine_impl< R & >
{
private:
    typedef pull_coroutine_impl< R & > impl_t;

public:
    pull_coroutine_synthesized( coroutine_context * caller,
                                coroutine_context * callee,
                                bool unwind,
                                R * result) :
        impl_t( caller, callee, unwind, result)
    {}

    void destroy() {}
};

template<>
class pull_coroutine_synthesized< void > : public pull_coroutine_impl< void >
{
private:
    typedef pull_coroutine_impl< void > impl_t;

public:
    pull_coroutine_synthesized( coroutine_context * caller,
                                coroutine_context * callee,
                                bool unwind) :
        impl_t( caller, callee, unwind)
    {}

    inline void destroy() {}
};

}}}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_impl.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_impl.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_push.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_push.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_push.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_push.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/setup.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/setup.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/setup.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/setup.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

template< typename Fn >
struct setup
{
    struct dummy {};

    Fn fn;
    coroutine_context * caller;
    coroutine_context * callee;
    attributes attr;
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/setup.hpp" 3 4
    setup( Fn && fn_,
           coroutine_context * caller_,
           coroutine_context * callee_,
           attributes const& attr_,
           typename disable_if<
               is_same< typename decay< Fn >::type, setup >,
               dummy*
           >::type = 0) :



        fn( boost::forward< Fn >( fn_) ),

        caller( caller_),
        callee( callee_),
        attr( attr_)
    {}
};

}}}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_push.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline_push.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

template< typename Coro >
void trampoline_push( context::detail::transfer_t t)
{
    typedef typename Coro::param_type param_type;

    data_t * data = static_cast< data_t * >( t.data);
    data->from->ctx_ = t.fctx;
    param_type * param(
        static_cast< param_type * >( data->data) );
    (static_cast<void> (0));
    (static_cast<void> (0));

    Coro * coro(
        static_cast< Coro * >( param->coro) );
    (static_cast<void> (0));

    coro->run( param->data);
}

template< typename Coro >
void trampoline_push_void( context::detail::transfer_t t)
{
    typedef typename Coro::param_type param_type;

    data_t * data = static_cast< data_t * >( t.data);
    data->from->ctx_ = t.fctx;
    param_type * param(
        static_cast< param_type * >( data->data) );
    (static_cast<void> (0));

    Coro * coro(
        static_cast< Coro * >( param->coro) );
    (static_cast<void> (0));

    coro->run();
}

}}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_impl.hpp" 2 3 4






namespace boost {
namespace coroutines {

struct stack_context;

namespace detail {

template< typename Arg >
class push_coroutine_impl : private noncopyable
{
protected:
    int flags_;
    exception_ptr except_;
    coroutine_context * caller_;
    coroutine_context * callee_;

public:
    typedef parameters< Arg > param_type;

    push_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~push_coroutine_impl() {}

    bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            param_type to( unwind_t::force_unwind);
            caller_->jump(
                * callee_,
                & to);
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    void push( Arg const& arg)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        param_type to( const_cast< Arg * >( & arg), this);
        param_type * from(
            static_cast< param_type * >(
                caller_->jump(
                    * callee_,
                    & to) ) );
        flags_ &= ~flag_running;
        if ( from->do_unwind) throw forced_unwind();
        if ( except_) rethrow_exception( except_);
    }

    void push( Arg && arg)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        param_type to( const_cast< Arg * >( & arg), this);
        param_type * from(
            static_cast< param_type * >(
                caller_->jump(
                    * callee_,
                    & to) ) );
        flags_ &= ~flag_running;
        if ( from->do_unwind) throw forced_unwind();
        if ( except_) rethrow_exception( except_);
    }

    virtual void destroy() = 0;
};

template< typename Arg >
class push_coroutine_impl< Arg & > : private noncopyable
{
protected:
    int flags_;
    exception_ptr except_;
    coroutine_context * caller_;
    coroutine_context * callee_;

public:
    typedef parameters< Arg & > param_type;

    push_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~push_coroutine_impl() {}

    bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            param_type to( unwind_t::force_unwind);
            caller_->jump(
                * callee_,
                & to);
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    void push( Arg & arg)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        param_type to( & arg, this);
        param_type * from(
            static_cast< param_type * >(
                caller_->jump(
                    * callee_,
                    & to) ) );
        flags_ &= ~flag_running;
        if ( from->do_unwind) throw forced_unwind();
        if ( except_) rethrow_exception( except_);
    }

    virtual void destroy() = 0;
};

template<>
class push_coroutine_impl< void > : private noncopyable
{
protected:
    int flags_;
    exception_ptr except_;
    coroutine_context * caller_;
    coroutine_context * callee_;

public:
    typedef parameters< void > param_type;

    push_coroutine_impl( coroutine_context * caller,
                         coroutine_context * callee,
                         bool unwind) :
        flags_( 0),
        except_(),
        caller_( caller),
        callee_( callee)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~push_coroutine_impl() {}

    inline bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    inline bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    inline bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    inline bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    inline bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    inline void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            param_type to( unwind_t::force_unwind);
            caller_->jump(
                * callee_,
                & to);
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    inline void push()
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        param_type to( this);
        param_type * from(
            static_cast< param_type * >(
                caller_->jump(
                    * callee_,
                    & to) ) );
        flags_ &= ~flag_running;
        if ( from->do_unwind) throw forced_unwind();
        if ( except_) rethrow_exception( except_);
    }

    virtual void destroy() = 0;
};

}}}
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

struct push_coroutine_context
{
    coroutine_context caller;
    coroutine_context callee;

    template< typename Coro >
    push_coroutine_context( preallocated const& palloc, Coro *) :
        caller(),
        callee( trampoline_push< Coro >, palloc)
    {}
};

struct push_coroutine_context_void
{
    coroutine_context caller;
    coroutine_context callee;

    template< typename Coro >
    push_coroutine_context_void( preallocated const& palloc, Coro *) :
        caller(),
        callee( trampoline_push_void< Coro >, palloc)
    {}
};

template< typename PullCoro, typename R, typename Fn, typename StackAllocator >
class push_coroutine_object : private push_coroutine_context,
                              public push_coroutine_impl< R >
{
private:
    typedef push_coroutine_context ctx_t;
    typedef push_coroutine_impl< R > base_t;
    typedef push_coroutine_object< PullCoro, R, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 3 4
    push_coroutine_object( Fn && fn, attributes const& attrs,
                           preallocated const& palloc,
                           StackAllocator const& stack_alloc) noexcept :
        ctx_t( palloc, this),
        base_t( & this->caller,
                & this->callee,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run( R * result)
    {
        (static_cast<void> (0));

        base_t::flags_ |= flag_started;
        base_t::flags_ |= flag_running;


        typename PullCoro::synth_type b( & this->callee, & this->caller, false, result);
        PullCoro pull_coro( synthesized_t::syntesized, b);
        try
        { fn_( pull_coro); }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { base_t::except_ = current_exception(); }

        base_t::flags_ |= flag_complete;
        base_t::flags_ &= ~flag_running;
        typename base_t::param_type to;
        this->callee.jump(
            this->caller,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

template< typename PullCoro, typename R, typename Fn, typename StackAllocator >
class push_coroutine_object< PullCoro, R &, Fn, StackAllocator > : private push_coroutine_context,
                                                                   public push_coroutine_impl< R & >
{
private:
    typedef push_coroutine_context ctx_t;
    typedef push_coroutine_impl< R & > base_t;
    typedef push_coroutine_object< PullCoro, R &, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 183 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 3 4
    push_coroutine_object( Fn && fn, attributes const& attrs,
                           preallocated const& palloc,
                           StackAllocator const& stack_alloc) noexcept :
        ctx_t( palloc, this),
        base_t( & this->caller,
                & this->callee,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run( R * result)
    {
        (static_cast<void> (0));

        base_t::flags_ |= flag_started;
        base_t::flags_ |= flag_running;


        typename PullCoro::synth_type b( & this->callee, & this->caller, false, result);
        PullCoro push_coro( synthesized_t::syntesized, b);
        try
        { fn_( push_coro); }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { base_t::except_ = current_exception(); }

        base_t::flags_ |= flag_complete;
        base_t::flags_ &= ~flag_running;
        typename base_t::param_type to;
        this->callee.jump(
            this->caller,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

template< typename PullCoro, typename Fn, typename StackAllocator >
class push_coroutine_object< PullCoro, void, Fn, StackAllocator > : private push_coroutine_context_void,
                                                                    public push_coroutine_impl< void >
{
private:
    typedef push_coroutine_context_void ctx_t;
    typedef push_coroutine_impl< void > base_t;
    typedef push_coroutine_object< PullCoro, void, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 266 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_object.hpp" 3 4
    push_coroutine_object( Fn && fn, attributes const& attrs,
                           preallocated const& palloc,
                           StackAllocator const& stack_alloc) noexcept :
        ctx_t( palloc, this),
        base_t( & this->caller,
                & this->callee,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run()
    {
        (static_cast<void> (0));

        base_t::flags_ |= flag_started;
        base_t::flags_ |= flag_running;


        typename PullCoro::synth_type b( & this->callee, & this->caller, false);
        PullCoro push_coro( synthesized_t::syntesized, b);
        try
        { fn_( push_coro); }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { base_t::except_ = current_exception(); }

        base_t::flags_ |= flag_complete;
        base_t::flags_ &= ~flag_running;
        typename base_t::param_type to;
        this->callee.jump(
            this->caller,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

}}}
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_synthesized.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/push_coroutine_synthesized.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

template< typename R >
class push_coroutine_synthesized : public push_coroutine_impl< R >
{
private:
    typedef push_coroutine_impl< R > impl_t;

public:
    push_coroutine_synthesized( coroutine_context * caller,
                                coroutine_context * callee,
                                bool unwind) :
        impl_t( caller, callee, unwind)
    {}

    void destroy() {}
};

template< typename R >
class push_coroutine_synthesized< R & > : public push_coroutine_impl< R & >
{
private:
    typedef push_coroutine_impl< R & > impl_t;

public:
    push_coroutine_synthesized( coroutine_context * caller,
                                coroutine_context * callee,
                                bool unwind) :
        impl_t( caller, callee, unwind)
    {}

    void destroy() {}
};

template<>
class push_coroutine_synthesized< void > : public push_coroutine_impl< void >
{
private:
    typedef push_coroutine_impl< void > impl_t;

public:
    push_coroutine_synthesized( coroutine_context * caller,
                                coroutine_context * callee,
                                bool unwind) :
        impl_t( caller, callee, unwind)
    {}

    inline void destroy() {}
};

}}}
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 2 3 4






namespace boost {
namespace coroutines {

template< typename R >
class pull_coroutine;

template< typename Arg >
class push_coroutine
{
private:
    template< typename V, typename X, typename Y, typename Z >
    friend class detail::pull_coroutine_object;

    typedef detail::push_coroutine_impl< Arg > impl_type;
    typedef detail::push_coroutine_synthesized< Arg > synth_type;
    typedef detail::parameters< Arg > param_type;

    struct dummy {};

    impl_type * impl_;

    public: push_coroutine(push_coroutine const &) = delete; push_coroutine& operator=(push_coroutine const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    explicit push_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
        impl_( & impl)
    { (static_cast<void> (0)); }

public:
    push_coroutine() noexcept :
        impl_( 0)
    {}
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    template< typename Fn >
    explicit push_coroutine( Fn &&,
                             attributes const& = attributes() );

    template< typename Fn, typename StackAllocator >
    explicit push_coroutine( Fn &&,
                             attributes const&,
                             StackAllocator);
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    ~push_coroutine()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    push_coroutine( push_coroutine && other) noexcept :
        impl_( 0)
    { swap( other); }

    push_coroutine & operator=( push_coroutine && other) noexcept
    {
        push_coroutine tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete(); }

    void swap( push_coroutine & other) noexcept
    { std::swap( impl_, other.impl_); }

    push_coroutine & operator()( Arg arg)
    {
        (static_cast<void> (0));

        impl_->push( arg);
        return * this;
    }

    class iterator
    {
    private:
       push_coroutine< Arg > * c_;

    public:
        typedef std::output_iterator_tag iterator_category;
        typedef void value_type;
        typedef void difference_type;
        typedef void pointer;
        typedef void reference;

        iterator() :
           c_( 0)
        {}

        explicit iterator( push_coroutine< Arg > * c) :
            c_( c)
        {}

        iterator & operator=( Arg a)
        {
            (static_cast<void> (0));
            if ( ! ( * c_)( a) ) c_ = 0;
            return * this;
        }

        bool operator==( iterator const& other) const
        { return other.c_ == c_; }

        bool operator!=( iterator const& other) const
        { return other.c_ != c_; }

        iterator & operator*()
        { return * this; }

        iterator & operator++()
        { return * this; }
    };

    struct const_iterator;
};

template< typename Arg >
class push_coroutine< Arg & >
{
private:
    template< typename V, typename X, typename Y, typename Z >
    friend class detail::pull_coroutine_object;

    typedef detail::push_coroutine_impl< Arg & > impl_type;
    typedef detail::push_coroutine_synthesized< Arg & > synth_type;
    typedef detail::parameters< Arg & > param_type;

    struct dummy {};

    impl_type * impl_;

    public: push_coroutine(push_coroutine const &) = delete; push_coroutine& operator=(push_coroutine const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    explicit push_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
        impl_( & impl)
    { (static_cast<void> (0)); }

public:
    push_coroutine() noexcept :
        impl_( 0)
    {}
# 236 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    template< typename Fn >
    explicit push_coroutine( Fn &&,
                             attributes const& = attributes() );

    template< typename Fn, typename StackAllocator >
    explicit push_coroutine( Fn &&,
                             attributes const&,
                             StackAllocator);
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    ~push_coroutine()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    push_coroutine( push_coroutine && other) noexcept :
        impl_( 0)
    { swap( other); }

    push_coroutine & operator=( push_coroutine && other) noexcept
    {
        push_coroutine tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete(); }

    void swap( push_coroutine & other) noexcept
    { std::swap( impl_, other.impl_); }

    push_coroutine & operator()( Arg & arg)
    {
        (static_cast<void> (0));

        impl_->push( arg);
        return * this;
    }

    class iterator
    {
    private:
       push_coroutine< Arg & > * c_;

    public:
        typedef std::output_iterator_tag iterator_category;
        typedef void value_type;
        typedef void difference_type;
        typedef void pointer;
        typedef void reference;

        iterator() :
           c_( 0)
        {}

        explicit iterator( push_coroutine< Arg & > * c) :
            c_( c)
        {}

        iterator & operator=( Arg & a)
        {
            (static_cast<void> (0));
            if ( ! ( * c_)( a) ) c_ = 0;
            return * this;
        }

        bool operator==( iterator const& other) const
        { return other.c_ == c_; }

        bool operator!=( iterator const& other) const
        { return other.c_ != c_; }

        iterator & operator*()
        { return * this; }

        iterator & operator++()
        { return * this; }
    };

    struct const_iterator;
};

template<>
class push_coroutine< void >
{
private:
    template< typename V, typename X, typename Y, typename Z >
    friend class detail::pull_coroutine_object;

    typedef detail::push_coroutine_impl< void > impl_type;
    typedef detail::push_coroutine_synthesized< void > synth_type;
    typedef detail::parameters< void > param_type;

    struct dummy {};

    impl_type * impl_;

    public: push_coroutine(push_coroutine const &) = delete; push_coroutine& operator=(push_coroutine const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    explicit push_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
        impl_( & impl)
    { (static_cast<void> (0)); }

public:
    push_coroutine() noexcept :
        impl_( 0)
    {}
# 381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    template< typename Fn >
    explicit push_coroutine( Fn &&,
                             attributes const& = attributes() );

    template< typename Fn, typename StackAllocator >
    explicit push_coroutine( Fn &&,
                             attributes const&,
                             StackAllocator);
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    ~push_coroutine()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    inline push_coroutine( push_coroutine && other) noexcept :
        impl_( 0)
    { swap( other); }

    inline push_coroutine & operator=( push_coroutine && other) noexcept
    {
        push_coroutine tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    inline bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete(); }

    inline void swap( push_coroutine & other) noexcept
    { std::swap( impl_, other.impl_); }

    inline push_coroutine & operator()()
    {
        (static_cast<void> (0));

        impl_->push();
        return * this;
    }

    struct iterator;
    struct const_iterator;
};



template< typename R >
class pull_coroutine
{
private:
    template< typename V, typename X, typename Y, typename Z >
    friend class detail::push_coroutine_object;

    typedef detail::pull_coroutine_impl< R > impl_type;
    typedef detail::pull_coroutine_synthesized< R > synth_type;
    typedef detail::parameters< R > param_type;

    struct dummy {};

    impl_type * impl_;

    public: pull_coroutine(pull_coroutine const &) = delete; pull_coroutine& operator=(pull_coroutine const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    explicit pull_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
        impl_( & impl)
    { (static_cast<void> (0)); }

public:
    pull_coroutine() noexcept :
        impl_( 0)
    {}
# 534 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    template< typename Fn >
    explicit pull_coroutine( Fn && fn,
                             attributes const& attrs = attributes() ) :
        impl_( 0)
    {

        stack_context stack_ctx;
        stack_allocator stack_alloc;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef detail::pull_coroutine_object<
            push_coroutine< R >, R, Fn, stack_allocator
        > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
        impl_->pull();
    }

    template< typename Fn, typename StackAllocator >
    explicit pull_coroutine( Fn && fn,
                             attributes const& attrs,
                             StackAllocator stack_alloc) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef detail::pull_coroutine_object<
            push_coroutine< R >, R, Fn, StackAllocator
        > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
        impl_->pull();
    }
# 697 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    ~pull_coroutine()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    pull_coroutine( pull_coroutine && other) noexcept :
        impl_( 0)
    { swap( other); }

    pull_coroutine & operator=( pull_coroutine && other) noexcept
    {
        pull_coroutine tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete(); }

    void swap( pull_coroutine & other) noexcept
    { std::swap( impl_, other.impl_); }

    pull_coroutine & operator()()
    {
        (static_cast<void> (0));

        impl_->pull();
        return * this;
    }

    R get() const
    {
        (static_cast<void> (0));

        return impl_->get();
    }

    class iterator
    {
    private:
        pull_coroutine< R > * c_;
        R * val_;

        void fetch_()
        {
            (static_cast<void> (0));

            if ( ! ( * c_) )
            {
                c_ = 0;
                val_ = 0;
                return;
            }
            val_ = c_->impl_->get_pointer();
        }

        void increment_()
        {
            (static_cast<void> (0));
            (static_cast<void> (0));

            ( * c_)();
            fetch_();
        }

    public:
        typedef std::input_iterator_tag iterator_category;
        typedef typename remove_reference< R >::type value_type;
        typedef std::ptrdiff_t difference_type;
        typedef value_type * pointer;
        typedef value_type & reference;

        typedef pointer pointer_t;
        typedef reference reference_t;

        iterator() :
            c_( 0), val_( 0)
        {}

        explicit iterator( pull_coroutine< R > * c) :
            c_( c), val_( 0)
        { fetch_(); }

        iterator( iterator const& other) :
            c_( other.c_), val_( other.val_)
        {}

        iterator & operator=( iterator const& other)
        {
            if ( this == & other) return * this;
            c_ = other.c_;
            val_ = other.val_;
            return * this;
        }

        bool operator==( iterator const& other) const
        { return other.c_ == c_ && other.val_ == val_; }

        bool operator!=( iterator const& other) const
        { return other.c_ != c_ || other.val_ != val_; }

        iterator & operator++()
        {
            increment_();
            return * this;
        }

        iterator operator++( int);

        reference_t operator*() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return * val_;
        }

        pointer_t operator->() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return val_;
        }
    };

    class const_iterator
    {
    private:
        pull_coroutine< R > * c_;
        R * val_;

        void fetch_()
        {
            (static_cast<void> (0));

            if ( ! ( * c_) )
            {
                c_ = 0;
                val_ = 0;
                return;
            }
            val_ = c_->impl_->get_pointer();
        }

        void increment_()
        {
            (static_cast<void> (0));
            (static_cast<void> (0));

            ( * c_)();
            fetch_();
        }

    public:
        typedef std::input_iterator_tag iterator_category;
        typedef const typename remove_reference< R >::type value_type;
        typedef std::ptrdiff_t difference_type;
        typedef value_type * pointer;
        typedef value_type & reference;

        typedef pointer pointer_t;
        typedef reference reference_t;

        const_iterator() :
            c_( 0), val_( 0)
        {}

        explicit const_iterator( pull_coroutine< R > const* c) :
            c_( const_cast< pull_coroutine< R > * >( c) ),
            val_( 0)
        { fetch_(); }

        const_iterator( const_iterator const& other) :
            c_( other.c_), val_( other.val_)
        {}

        const_iterator & operator=( const_iterator const& other)
        {
            if ( this == & other) return * this;
            c_ = other.c_;
            val_ = other.val_;
            return * this;
        }

        bool operator==( const_iterator const& other) const
        { return other.c_ == c_ && other.val_ == val_; }

        bool operator!=( const_iterator const& other) const
        { return other.c_ != c_ || other.val_ != val_; }

        const_iterator & operator++()
        {
            increment_();
            return * this;
        }

        const_iterator operator++( int);

        reference_t operator*() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return * val_;
        }

        pointer_t operator->() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return val_;
        }
    };

    friend class iterator;
    friend class const_iterator;
};

template< typename R >
class pull_coroutine< R & >
{
private:
    template< typename V, typename X, typename Y, typename Z >
    friend class detail::push_coroutine_object;

    typedef detail::pull_coroutine_impl< R & > impl_type;
    typedef detail::pull_coroutine_synthesized< R & > synth_type;
    typedef detail::parameters< R & > param_type;

    struct dummy {};

    impl_type * impl_;

    public: pull_coroutine(pull_coroutine const &) = delete; pull_coroutine& operator=(pull_coroutine const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    explicit pull_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
        impl_( & impl)
    { (static_cast<void> (0)); }

public:
    pull_coroutine() noexcept :
        impl_( 0)
    {}
# 1006 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    template< typename Fn >
    explicit pull_coroutine( Fn && fn,
                             attributes const& attrs = attributes() ) :
        impl_( 0)
    {

        stack_context stack_ctx;
        stack_allocator stack_alloc;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef detail::pull_coroutine_object<
            push_coroutine< R & >, R &, Fn, stack_allocator
        > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
        impl_->pull();
    }

    template< typename Fn, typename StackAllocator >
    explicit pull_coroutine( Fn && fn,
                             attributes const& attrs,
                             StackAllocator stack_alloc) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef detail::pull_coroutine_object<
            push_coroutine< R & >, R &, Fn, StackAllocator
        > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
        impl_->pull();
    }
# 1169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    ~pull_coroutine()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    pull_coroutine( pull_coroutine && other) noexcept :
        impl_( 0)
    { swap( other); }

    pull_coroutine & operator=( pull_coroutine && other) noexcept
    {
        pull_coroutine tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete(); }

    void swap( pull_coroutine & other) noexcept
    { std::swap( impl_, other.impl_); }

    pull_coroutine & operator()()
    {
        (static_cast<void> (0));

        impl_->pull();
        return * this;
    }

    R & get() const
    { return impl_->get(); }

    class iterator
    {
    private:
        pull_coroutine< R & > * c_;
        R * val_;

        void fetch_()
        {
            (static_cast<void> (0));

            if ( ! ( * c_) )
            {
                c_ = 0;
                val_ = 0;
                return;
            }
            val_ = c_->impl_->get_pointer();
        }

        void increment_()
        {
            (static_cast<void> (0));
            (static_cast<void> (0));

            ( * c_)();
            fetch_();
        }

    public:
        typedef std::input_iterator_tag iterator_category;
        typedef typename remove_reference< R >::type value_type;
        typedef std::ptrdiff_t difference_type;
        typedef value_type * pointer;
        typedef value_type & reference;

        typedef pointer pointer_t;
        typedef reference reference_t;

        iterator() :
            c_( 0), val_( 0)
        {}

        explicit iterator( pull_coroutine< R & > * c) :
            c_( c), val_( 0)
        { fetch_(); }

        iterator( iterator const& other) :
            c_( other.c_), val_( other.val_)
        {}

        iterator & operator=( iterator const& other)
        {
            if ( this == & other) return * this;
            c_ = other.c_;
            val_ = other.val_;
            return * this;
        }

        bool operator==( iterator const& other) const
        { return other.c_ == c_ && other.val_ == val_; }

        bool operator!=( iterator const& other) const
        { return other.c_ != c_ || other.val_ != val_; }

        iterator & operator++()
        {
            increment_();
            return * this;
        }

        iterator operator++( int);

        reference_t operator*() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return * val_;
        }

        pointer_t operator->() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return val_;
        }
    };

    class const_iterator
    {
    private:
        pull_coroutine< R & > * c_;
        R * val_;

        void fetch_()
        {
            (static_cast<void> (0));

            if ( ! ( * c_) )
            {
                c_ = 0;
                val_ = 0;
                return;
            }
            val_ = c_->impl_->get_pointer();
        }

        void increment_()
        {
            (static_cast<void> (0));
            (static_cast<void> (0));

            ( * c_)();
            fetch_();
        }

    public:
        typedef std::input_iterator_tag iterator_category;
        typedef const typename remove_reference< R >::type value_type;
        typedef std::ptrdiff_t difference_type;
        typedef value_type * pointer;
        typedef value_type & reference;

        typedef pointer pointer_t;
        typedef reference reference_t;

        const_iterator() :
            c_( 0), val_( 0)
        {}

        explicit const_iterator( pull_coroutine< R & > const* c) :
            c_( const_cast< pull_coroutine< R & > * >( c) ),
            val_( 0)
        { fetch_(); }

        const_iterator( const_iterator const& other) :
            c_( other.c_), val_( other.val_)
        {}

        const_iterator & operator=( const_iterator const& other)
        {
            if ( this == & other) return * this;
            c_ = other.c_;
            val_ = other.val_;
            return * this;
        }

        bool operator==( const_iterator const& other) const
        { return other.c_ == c_ && other.val_ == val_; }

        bool operator!=( const_iterator const& other) const
        { return other.c_ != c_ || other.val_ != val_; }

        const_iterator & operator++()
        {
            increment_();
            return * this;
        }

        const_iterator operator++( int);

        reference_t operator*() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return * val_;
        }

        pointer_t operator->() const
        {
            if ( ! val_)
                boost::throw_exception(
                    invalid_result() );
            return val_;
        }
    };

    friend class iterator;
    friend class const_iterator;
};

template<>
class pull_coroutine< void >
{
private:
    template< typename V, typename X, typename Y, typename Z >
    friend class detail::push_coroutine_object;

    typedef detail::pull_coroutine_impl< void > impl_type;
    typedef detail::pull_coroutine_synthesized< void > synth_type;
    typedef detail::parameters< void > param_type;

    struct dummy {};

    impl_type * impl_;

    public: pull_coroutine(pull_coroutine const &) = delete; pull_coroutine& operator=(pull_coroutine const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    explicit pull_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
        impl_( & impl)
    { (static_cast<void> (0)); }

public:
    pull_coroutine() noexcept :
        impl_( 0)
    {}
# 1474 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    template< typename Fn >
    explicit pull_coroutine( Fn && fn,
                             attributes const& attrs = attributes() ) :
        impl_( 0)
    {

        stack_context stack_ctx;
        stack_allocator stack_alloc;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef detail::pull_coroutine_object<
            push_coroutine< void >, void, Fn, stack_allocator
        > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
        impl_->pull();
    }

    template< typename Fn, typename StackAllocator >
    explicit pull_coroutine( Fn && fn,
                             attributes const& attrs,
                             StackAllocator stack_alloc) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef detail::pull_coroutine_object<
            push_coroutine< void >, void, Fn, StackAllocator
        > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
        impl_->pull();
    }
# 1637 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
    ~pull_coroutine()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    inline pull_coroutine( pull_coroutine && other) noexcept :
        impl_( 0)
    { swap( other); }

    inline pull_coroutine & operator=( pull_coroutine && other) noexcept
    {
        pull_coroutine tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    inline bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete(); }

    inline void swap( pull_coroutine & other) noexcept
    { std::swap( impl_, other.impl_); }

    inline pull_coroutine & operator()()
    {
        (static_cast<void> (0));

        impl_->pull();
        return * this;
    }

    struct iterator;
    struct const_iterator;
};
# 1836 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
template< typename Arg >
template< typename Fn >
push_coroutine< Arg >::push_coroutine( Fn && fn,
                                       attributes const& attrs) :
    impl_( 0)
{

    stack_context stack_ctx;
    stack_allocator stack_alloc;

    stack_alloc.allocate( stack_ctx, attrs.size);
    (static_cast<void> (0));

    typedef detail::push_coroutine_object<
        pull_coroutine< Arg >, Arg, Fn, stack_allocator
    > object_t;

    std::size_t size = stack_ctx.size - sizeof( object_t);
    (static_cast<void> (0));
    void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
    (static_cast<void> (0));

    impl_ = new ( sp) object_t(
            boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
    (static_cast<void> (0));
}

template< typename Arg >
template< typename Fn, typename StackAllocator >
push_coroutine< Arg >::push_coroutine( Fn && fn,
                                       attributes const& attrs,
                                       StackAllocator stack_alloc) :
    impl_( 0)
{

    stack_context stack_ctx;

    stack_alloc.allocate( stack_ctx, attrs.size);
    (static_cast<void> (0));

    typedef detail::push_coroutine_object<
        pull_coroutine< Arg >, Arg, Fn, StackAllocator
    > object_t;

    std::size_t size = stack_ctx.size - sizeof( object_t);
    (static_cast<void> (0));
    void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
    (static_cast<void> (0));

    impl_ = new ( sp) object_t(
            boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
    (static_cast<void> (0));
}

template< typename Arg >
template< typename Fn >
push_coroutine< Arg & >::push_coroutine( Fn && fn,
                                         attributes const& attrs) :
    impl_( 0)
{

    stack_context stack_ctx;
    stack_allocator stack_alloc;

    stack_alloc.allocate( stack_ctx, attrs.size);
    (static_cast<void> (0));

    typedef detail::push_coroutine_object<
        pull_coroutine< Arg & >, Arg &, Fn, stack_allocator
    > object_t;

    std::size_t size = stack_ctx.size - sizeof( object_t);
    (static_cast<void> (0));
    void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
    (static_cast<void> (0));

    impl_ = new ( sp) object_t(
            boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
    (static_cast<void> (0));
}

template< typename Arg >
template< typename Fn, typename StackAllocator >
push_coroutine< Arg & >::push_coroutine( Fn && fn,
                                         attributes const& attrs,
                                         StackAllocator stack_alloc) :
    impl_( 0)
{

    stack_context stack_ctx;

    stack_alloc.allocate( stack_ctx, attrs.size);
    (static_cast<void> (0));

    typedef detail::push_coroutine_object<
        pull_coroutine< Arg & >, Arg &, Fn, StackAllocator
    > object_t;

    std::size_t size = stack_ctx.size - sizeof( object_t);
    (static_cast<void> (0));
    void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
    (static_cast<void> (0));

    impl_ = new ( sp) object_t(
            boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
    (static_cast<void> (0));
}

template< typename Fn >
push_coroutine< void >::push_coroutine( Fn && fn,
                                        attributes const& attrs) :
    impl_( 0)
{

    stack_context stack_ctx;
    stack_allocator stack_alloc;

    stack_alloc.allocate( stack_ctx, attrs.size);
    (static_cast<void> (0));

    typedef detail::push_coroutine_object<
        pull_coroutine< void >, void, Fn, stack_allocator
    > object_t;

    std::size_t size = stack_ctx.size - sizeof( object_t);
    (static_cast<void> (0));
    void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
    (static_cast<void> (0));

    impl_ = new ( sp) object_t(
            boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
    (static_cast<void> (0));
}

template< typename Fn, typename StackAllocator >
push_coroutine< void >::push_coroutine( Fn && fn,
                                        attributes const& attrs,
                                        StackAllocator stack_alloc) :
    impl_( 0)
{

    stack_context stack_ctx;

    stack_alloc.allocate( stack_ctx, attrs.size);
    (static_cast<void> (0));

    typedef detail::push_coroutine_object<
        pull_coroutine< void >, void, Fn, StackAllocator
    > object_t;

    std::size_t size = stack_ctx.size - sizeof( object_t);
    (static_cast<void> (0));
    void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
    (static_cast<void> (0));

    impl_ = new ( sp) object_t(
            boost::forward< Fn >( fn), attrs, detail::preallocated( sp, size, stack_ctx), stack_alloc);
    (static_cast<void> (0));
}
# 2317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/asymmetric_coroutine.hpp" 3 4
template< typename R >
void swap( pull_coroutine< R > & l, pull_coroutine< R > & r) noexcept
{ l.swap( r); }

template< typename Arg >
void swap( push_coroutine< Arg > & l, push_coroutine< Arg > & r) noexcept
{ l.swap( r); }

template< typename R >
typename pull_coroutine< R >::iterator
range_begin( pull_coroutine< R > & c)
{ return typename pull_coroutine< R >::iterator( & c); }

template< typename R >
typename pull_coroutine< R >::const_iterator
range_begin( pull_coroutine< R > const& c)
{ return typename pull_coroutine< R >::const_iterator( & c); }

template< typename R >
typename pull_coroutine< R >::iterator
range_end( pull_coroutine< R > &)
{ return typename pull_coroutine< R >::iterator(); }

template< typename R >
typename pull_coroutine< R >::const_iterator
range_end( pull_coroutine< R > const&)
{ return typename pull_coroutine< R >::const_iterator(); }

template< typename Arg >
typename push_coroutine< Arg >::iterator
range_begin( push_coroutine< Arg > & c)
{ return typename push_coroutine< Arg >::iterator( & c); }

template< typename Arg >
typename push_coroutine< Arg >::iterator
range_end( push_coroutine< Arg > &)
{ return typename push_coroutine< Arg >::iterator(); }

template< typename T >
struct asymmetric_coroutine
{
    typedef push_coroutine< T > push_type;
    typedef pull_coroutine< T > pull_type;
};


template< typename T >
struct coroutine
{
    typedef push_coroutine< T > push_type;
    typedef pull_coroutine< T > pull_type;
};

template< typename R >
typename pull_coroutine< R >::iterator
begin( pull_coroutine< R > & c)
{ return boost::begin( c); }

template< typename R >
typename pull_coroutine< R >::const_iterator
begin( pull_coroutine< R > const& c)
{ return boost::begin( c); }

template< typename R >
typename pull_coroutine< R >::iterator
end( pull_coroutine< R > & c)
{ return boost::end( c); }

template< typename R >
typename pull_coroutine< R >::const_iterator
end( pull_coroutine< R > const& c)
{ return boost::end( c); }

template< typename R >
typename push_coroutine< R >::iterator
begin( push_coroutine< R > & c)
{ return boost::begin( c); }

template< typename R >
typename push_coroutine< R >::iterator
end( push_coroutine< R > & c)
{ return boost::end( c); }

}

template< typename Arg >
struct range_mutable_iterator< coroutines::push_coroutine< Arg > >
{ typedef typename coroutines::push_coroutine< Arg >::iterator type; };

template< typename R >
struct range_mutable_iterator< coroutines::pull_coroutine< R > >
{ typedef typename coroutines::pull_coroutine< R >::iterator type; };

}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/coroutine.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/symmetric_coroutine.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/symmetric_coroutine.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_impl.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_impl.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_impl.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_impl.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/trampoline.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

template< typename Coro >
void trampoline( context::detail::transfer_t t)
{
    typedef typename Coro::param_type param_type;

    data_t * data = static_cast< data_t * >( t.data);
    data->from->ctx_ = t.fctx;
    param_type * param(
        static_cast< param_type * >( data->data) );
    (static_cast<void> (0));
    (static_cast<void> (0));

    Coro * coro(
        static_cast< Coro * >( param->coro) );
    (static_cast<void> (0));

    coro->run( param->data);
}

template< typename Coro >
void trampoline_void( context::detail::transfer_t t)
{
    typedef typename Coro::param_type param_type;

    data_t * data = static_cast< data_t * >( t.data);
    data->from->ctx_ = t.fctx;
    param_type * param(
        static_cast< param_type * >( data->data) );
    (static_cast<void> (0));

    Coro * coro(
        static_cast< Coro * >( param->coro) );
    (static_cast<void> (0));

    coro->run();
}

}}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_impl.hpp" 2 3 4







namespace boost {
namespace coroutines {
namespace detail {

template< typename R >
class symmetric_coroutine_impl : private noncopyable
{
public:
    typedef parameters< R > param_type;

    symmetric_coroutine_impl( preallocated const& palloc,
                              bool unwind) noexcept :
        flags_( 0),
        caller_(),
        callee_( trampoline< symmetric_coroutine_impl< R > >, palloc)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~symmetric_coroutine_impl() {}

    bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            flags_ |= flag_running;
            param_type to( unwind_t::force_unwind);
            caller_.jump(
                callee_,
                & to);
            flags_ &= ~flag_running;
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    void resume( R r) noexcept
    {
        param_type to( const_cast< R * >( & r), this);
        resume_( & to);
    }

    R * yield()
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ &= ~flag_running;
        param_type to;
        param_type * from(
            static_cast< param_type * >(
                callee_.jump(
                    caller_,
                    & to) ) );
        flags_ |= flag_running;
        if ( from->do_unwind) throw forced_unwind();
        (static_cast<void> (0));
        return from->data;
    }

    template< typename X >
    R * yield_to( symmetric_coroutine_impl< X > * other, X x)
    {
        typename symmetric_coroutine_impl< X >::param_type to( & x, other);
        return yield_to_( other, & to);
    }

    template< typename X >
    R * yield_to( symmetric_coroutine_impl< X & > * other, X & x)
    {
        typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
        return yield_to_( other, & to);
    }

    template< typename X >
    R * yield_to( symmetric_coroutine_impl< X > * other)
    {
        typename symmetric_coroutine_impl< X >::param_type to( other);
        return yield_to_( other, & to);
    }

    virtual void run( R *) noexcept = 0;

    virtual void destroy() = 0;

protected:
    template< typename X >
    friend class symmetric_coroutine_impl;

    int flags_;
    coroutine_context caller_;
    coroutine_context callee_;

    void resume_( param_type * to) noexcept
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        caller_.jump(
            callee_,
            to);
        flags_ &= ~flag_running;
    }

    template< typename Other >
    R * yield_to_( Other * other, typename Other::param_type * to)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));

        other->caller_ = caller_;
        flags_ &= ~flag_running;
        param_type * from(
            static_cast< param_type * >(
                callee_.jump(
                    other->callee_,
                    to) ) );
        flags_ |= flag_running;
        if ( from->do_unwind) throw forced_unwind();
        (static_cast<void> (0));
        return from->data;
    }
};

template< typename R >
class symmetric_coroutine_impl< R & > : private noncopyable
{
public:
    typedef parameters< R & > param_type;

    symmetric_coroutine_impl( preallocated const& palloc,
                              bool unwind) noexcept :
        flags_( 0),
        caller_(),
        callee_( trampoline< symmetric_coroutine_impl< R > >, palloc)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~symmetric_coroutine_impl() {}

    bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            flags_ |= flag_running;
            param_type to( unwind_t::force_unwind);
            caller_.jump(
                callee_,
                & to);
            flags_ &= ~flag_running;
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    void resume( R & arg) noexcept
    {
        param_type to( & arg, this);
        resume_( & to);
    }

    R * yield()
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ &= ~flag_running;
        param_type to;
        param_type * from(
            static_cast< param_type * >(
                callee_.jump(
                    caller_,
                    & to) ) );
        flags_ |= flag_running;
        if ( from->do_unwind) throw forced_unwind();
        (static_cast<void> (0));
        return from->data;
    }

    template< typename X >
    R * yield_to( symmetric_coroutine_impl< X > * other, X x)
    {
        typename symmetric_coroutine_impl< X >::param_type to( & x, other);
        return yield_to_( other, & to);
    }

    template< typename X >
    R * yield_to( symmetric_coroutine_impl< X & > * other, X & x)
    {
        typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
        return yield_to_( other, & to);
    }

    template< typename X >
    R * yield_to( symmetric_coroutine_impl< X > * other)
    {
        typename symmetric_coroutine_impl< X >::param_type to( other);
        return yield_to_( other, & to);
    }

    virtual void run( R *) noexcept = 0;

    virtual void destroy() = 0;

protected:
    template< typename X >
    friend class symmetric_coroutine_impl;

    int flags_;
    coroutine_context caller_;
    coroutine_context callee_;

    void resume_( param_type * to) noexcept
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ |= flag_running;
        caller_.jump(
            callee_,
            to);
        flags_ &= ~flag_running;
    }

    template< typename Other >
    R * yield_to_( Other * other, typename Other::param_type * to)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));

        other->caller_ = caller_;
        flags_ &= ~flag_running;
        param_type * from(
            static_cast< param_type * >(
                callee_.jump(
                    other->callee_,
                    to) ) );
        flags_ |= flag_running;
        if ( from->do_unwind) throw forced_unwind();
        (static_cast<void> (0));
        return from->data;
    }
};

template<>
class symmetric_coroutine_impl< void > : private noncopyable
{
public:
    typedef parameters< void > param_type;

    symmetric_coroutine_impl( preallocated const& palloc,
                              bool unwind) noexcept :
        flags_( 0),
        caller_(),
        callee_( trampoline_void< symmetric_coroutine_impl< void > >, palloc)
    {
        if ( unwind) flags_ |= flag_force_unwind;
    }

    virtual ~symmetric_coroutine_impl() {}

    inline bool force_unwind() const noexcept
    { return 0 != ( flags_ & flag_force_unwind); }

    inline bool unwind_requested() const noexcept
    { return 0 != ( flags_ & flag_unwind_stack); }

    inline bool is_started() const noexcept
    { return 0 != ( flags_ & flag_started); }

    inline bool is_running() const noexcept
    { return 0 != ( flags_ & flag_running); }

    inline bool is_complete() const noexcept
    { return 0 != ( flags_ & flag_complete); }

    inline void unwind_stack() noexcept
    {
        if ( is_started() && ! is_complete() && force_unwind() )
        {
            flags_ |= flag_unwind_stack;
            flags_ |= flag_running;
            param_type to( unwind_t::force_unwind);
            caller_.jump(
                callee_,
                & to);
            flags_ &= ~flag_running;
            flags_ &= ~flag_unwind_stack;

            (static_cast<void> (0));
        }
    }

    inline void resume() noexcept
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        param_type to( this);
        flags_ |= flag_running;
        caller_.jump(
            callee_,
            & to);
        flags_ &= ~flag_running;
    }

    inline void yield()
    {
        (static_cast<void> (0));
        (static_cast<void> (0));

        flags_ &= ~flag_running;
        param_type to;
        param_type * from(
            static_cast< param_type * >(
                callee_.jump(
                     caller_,
                    & to) ) );
        flags_ |= flag_running;
        if ( from->do_unwind) throw forced_unwind();
    }

    template< typename X >
    void yield_to( symmetric_coroutine_impl< X > * other, X x)
    {
        typename symmetric_coroutine_impl< X >::param_type to( & x, other);
        yield_to_( other, & to);
    }

    template< typename X >
    void yield_to( symmetric_coroutine_impl< X & > * other, X & x)
    {
        typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
        yield_to_( other, & to);
    }

    template< typename X >
    void yield_to( symmetric_coroutine_impl< X > * other)
    {
        typename symmetric_coroutine_impl< X >::param_type to( other);
        yield_to_( other, & to);
    }

    virtual void run() noexcept = 0;

    virtual void destroy() = 0;

protected:
    template< typename X >
    friend class symmetric_coroutine_impl;

    int flags_;
    coroutine_context caller_;
    coroutine_context callee_;

    template< typename Other >
    void yield_to_( Other * other, typename Other::param_type * to)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));

        other->caller_ = caller_;
        flags_ &= ~flag_running;
        param_type * from(
            static_cast< param_type * >(
                callee_.jump(
                    other->callee_,
                    to) ) );
        flags_ |= flag_running;
        if ( from->do_unwind) throw forced_unwind();
    }
};

}}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_object.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_object.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_object.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_yield.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_yield.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_yield.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_yield.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

template< typename R >
class symmetric_coroutine_yield
{
private:
    template< typename X, typename Y, typename Z >
    friend class symmetric_coroutine_object;

    typedef symmetric_coroutine_impl< R > impl_type;

    struct dummy {};

    public: symmetric_coroutine_yield(symmetric_coroutine_yield const &) = delete; symmetric_coroutine_yield& operator=(symmetric_coroutine_yield const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    impl_type * impl_;
    R * result_;

    symmetric_coroutine_yield( impl_type * impl, R * result) noexcept :
        impl_( impl),
        result_( result)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
    }

public:
    symmetric_coroutine_yield() noexcept :
        impl_( 0),
        result_( 0)
    {}

    symmetric_coroutine_yield( symmetric_coroutine_yield && other) noexcept :
        impl_( 0),
        result_( 0)
    { swap( other); }

    symmetric_coroutine_yield & operator=( symmetric_coroutine_yield && other) noexcept
    {
        symmetric_coroutine_yield tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_; }

    void swap( symmetric_coroutine_yield & other) noexcept
    {
        std::swap( impl_, other.impl_);
        std::swap( result_, other.result_);
    }

    symmetric_coroutine_yield & operator()()
    {
        result_ = impl_->yield();
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type x,
                                            typename disable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        (static_cast<void> (0));

        result_ = impl_->yield_to( other.impl_, x);
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other,
                                            typename enable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        (static_cast<void> (0));

        result_ = impl_->yield_to( other.impl_);
        return * this;
    }

    R get() const
    {
        if ( 0 == result_)
            boost::throw_exception(
                invalid_result() );

        return * result_;
    }
};

template< typename R >
class symmetric_coroutine_yield< R & >
{
private:
    template< typename X, typename Y, typename Z >
    friend class symmetric_coroutine_object;

    typedef symmetric_coroutine_impl< R & > impl_type;

    struct dummy {};

    public: symmetric_coroutine_yield(symmetric_coroutine_yield const &) = delete; symmetric_coroutine_yield& operator=(symmetric_coroutine_yield const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    impl_type * impl_;
    R * result_;

    symmetric_coroutine_yield( impl_type * impl, R * result) noexcept :
        impl_( impl),
        result_( result)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
    }

public:
    symmetric_coroutine_yield() noexcept :
        impl_( 0),
        result_( 0)
    {}

    symmetric_coroutine_yield( symmetric_coroutine_yield && other) noexcept :
        impl_( 0),
        result_( 0)
    { swap( other); }

    symmetric_coroutine_yield & operator=( symmetric_coroutine_yield && other) noexcept
    {
        symmetric_coroutine_yield tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_; }

    void swap( symmetric_coroutine_yield & other) noexcept
    {
        std::swap( impl_, other.impl_);
        std::swap( result_, other.result_);
    }

    symmetric_coroutine_yield & operator()()
    {
        result_ = impl_->yield();
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
                                            typename disable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        (static_cast<void> (0));

        result_ = impl_->yield_to( other.impl_, x);
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other,
                                            typename enable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        (static_cast<void> (0));

        result_ = impl_->yield_to( other.impl_);
        return * this;
    }

    R & get() const
    {
        if ( 0 == result_)
            boost::throw_exception(
                invalid_result() );

        return * result_;
    }
};

template<>
class symmetric_coroutine_yield< void >
{
private:
    template< typename X, typename Y, typename Z >
    friend class symmetric_coroutine_object;

    typedef symmetric_coroutine_impl< void > impl_type;

    struct dummy {};

    public: symmetric_coroutine_yield(symmetric_coroutine_yield const &) = delete; symmetric_coroutine_yield& operator=(symmetric_coroutine_yield const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    impl_type * impl_;

    symmetric_coroutine_yield( impl_type * impl) noexcept :
        impl_( impl)
    { (static_cast<void> (0)); }

public:
    symmetric_coroutine_yield() noexcept :
        impl_( 0)
    {}

    symmetric_coroutine_yield( symmetric_coroutine_yield && other) noexcept :
        impl_( 0)
    { swap( other); }

    symmetric_coroutine_yield & operator=( symmetric_coroutine_yield && other) noexcept
    {
        symmetric_coroutine_yield tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    inline bool operator!() const noexcept
    { return 0 == impl_; }

    inline void swap( symmetric_coroutine_yield & other) noexcept
    { std::swap( impl_, other.impl_); }

    inline symmetric_coroutine_yield & operator()()
    {
        impl_->yield();
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
                                            typename disable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        (static_cast<void> (0));

        impl_->yield_to( other.impl_, x);
        return * this;
    }

    template< typename Coro >
    symmetric_coroutine_yield & operator()( Coro & other,
                                            typename enable_if<
                                                is_same< typename Coro::value_type, void >,
                                                dummy*
                                            >::type = 0)
    {
        (static_cast<void> (0));

        impl_->yield_to( other.impl_);
        return * this;
    }
};

template< typename R >
void swap( symmetric_coroutine_yield< R > & l, symmetric_coroutine_yield< R > & r)
{ l.swap( r); }

}}}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_object.hpp" 2 3 4







namespace boost {
namespace coroutines {

struct stack_context;

namespace detail {

template< typename R, typename Fn, typename StackAllocator >
class symmetric_coroutine_object : public symmetric_coroutine_impl< R >
{
private:
    typedef symmetric_coroutine_impl< R > impl_t;
    typedef symmetric_coroutine_object< R, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_object.hpp" 3 4
    symmetric_coroutine_object( Fn && fn, attributes const& attrs,
                                preallocated const& palloc,
                                StackAllocator const& stack_alloc) noexcept :
        impl_t( palloc,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run( R * r) noexcept
    {
        (static_cast<void> (0));

        impl_t::flags_ |= flag_started;
        impl_t::flags_ |= flag_running;
        try
        {
            symmetric_coroutine_yield< R > yc( this, r);
            fn_( yc);
        }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { std::terminate(); }

        impl_t::flags_ |= flag_complete;
        impl_t::flags_ &= ~flag_running;
        typename impl_t::param_type to;
        impl_t::callee_.jump(
            impl_t::caller_,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

template< typename R, typename Fn, typename StackAllocator >
class symmetric_coroutine_object< R &, Fn, StackAllocator > : public symmetric_coroutine_impl< R & >
{
private:
    typedef symmetric_coroutine_impl< R & > impl_t;
    typedef symmetric_coroutine_object< R &, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 142 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_object.hpp" 3 4
    symmetric_coroutine_object( Fn && fn, attributes const& attrs,
                                preallocated const& palloc,
                                StackAllocator const& stack_alloc) noexcept :
        impl_t( palloc,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run( R * r) noexcept
    {
        (static_cast<void> (0));

        impl_t::flags_ |= flag_started;
        impl_t::flags_ |= flag_running;
        try
        {
            symmetric_coroutine_yield< R & > yc( this, r);
            fn_( yc);
        }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { std::terminate(); }

        impl_t::flags_ |= flag_complete;
        impl_t::flags_ &= ~flag_running;
        typename impl_t::param_type to;
        impl_t::callee_.jump(
            impl_t::caller_,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

template< typename Fn, typename StackAllocator >
class symmetric_coroutine_object< void, Fn, StackAllocator > : public symmetric_coroutine_impl< void >
{
private:
    typedef symmetric_coroutine_impl< void > impl_t;
    typedef symmetric_coroutine_object< void, Fn, StackAllocator > obj_t;

    Fn fn_;
    stack_context stack_ctx_;
    StackAllocator stack_alloc_;

    static void deallocate_( obj_t * obj)
    {
        stack_context stack_ctx( obj->stack_ctx_);
        StackAllocator stack_alloc( obj->stack_alloc_);
        obj->unwind_stack();
        obj->~obj_t();
        stack_alloc.deallocate( stack_ctx);
    }

public:
# 218 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_object.hpp" 3 4
    symmetric_coroutine_object( Fn && fn, attributes const& attrs,
                                preallocated const& palloc,
                                StackAllocator const& stack_alloc) noexcept :
        impl_t( palloc,
                stack_unwind == attrs.do_unwind),



        fn_( boost::forward< Fn >( fn) ),

        stack_ctx_( palloc.sctx),
        stack_alloc_( stack_alloc)
    {}

    void run() noexcept
    {
        (static_cast<void> (0));

        impl_t::flags_ |= flag_started;
        impl_t::flags_ |= flag_running;
        try
        {
            symmetric_coroutine_yield< void > yc( this);
            fn_( yc);
        }
        catch ( forced_unwind const&)
        {}
        catch (...)
        { std::terminate(); }

        impl_t::flags_ |= flag_complete;
        impl_t::flags_ &= ~flag_running;
        typename impl_t::param_type to;
        impl_t::callee_.jump(
            impl_t::caller_,
            & to);
        (static_cast<void> (0));
    }

    void destroy()
    { deallocate_( this); }
};

}}}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
namespace boost {
namespace coroutines {
namespace detail {

template< typename Arg >
class symmetric_coroutine_call
{
private:
    template< typename X >
    friend class symmetric_coroutine_yield;

    typedef symmetric_coroutine_impl< Arg > impl_type;

    public: symmetric_coroutine_call(symmetric_coroutine_call const &) = delete; symmetric_coroutine_call& operator=(symmetric_coroutine_call const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    struct dummy {};

    impl_type * impl_;

public:
    typedef Arg value_type;
    typedef symmetric_coroutine_yield< Arg > yield_type;

    symmetric_coroutine_call() noexcept :
        impl_( 0)
    {}
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
    template< typename Fn >
    explicit symmetric_coroutine_call( Fn && fn,
                                       attributes const& attrs = attributes(),
                                       stack_allocator stack_alloc = stack_allocator() ) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef symmetric_coroutine_object< Arg, Fn, stack_allocator > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                    boost::forward< Fn >( fn), attrs, preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
    }

    template< typename Fn, typename StackAllocator >
    explicit symmetric_coroutine_call( Fn && fn,
                                       attributes const& attrs,
                                       StackAllocator stack_alloc) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef symmetric_coroutine_object< Arg, Fn, StackAllocator > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                    boost::forward< Fn >( fn), attrs, preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
    }
# 251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
    ~symmetric_coroutine_call()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    symmetric_coroutine_call( symmetric_coroutine_call && other) noexcept :
        impl_( 0)
    { swap( other); }

    symmetric_coroutine_call & operator=( symmetric_coroutine_call && other) noexcept
    {
        symmetric_coroutine_call tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete() || impl_->is_running(); }

    void swap( symmetric_coroutine_call & other) noexcept
    { std::swap( impl_, other.impl_); }

    symmetric_coroutine_call & operator()( Arg arg) noexcept
    {
        (static_cast<void> (0));

        impl_->resume( arg);
        return * this;
    }
};

template< typename Arg >
class symmetric_coroutine_call< Arg & >
{
private:
    template< typename X >
    friend class symmetric_coroutine_yield;

    typedef symmetric_coroutine_impl< Arg & > impl_type;

    public: symmetric_coroutine_call(symmetric_coroutine_call const &) = delete; symmetric_coroutine_call& operator=(symmetric_coroutine_call const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    struct dummy {};

    impl_type * impl_;

public:
    typedef Arg value_type;
    typedef symmetric_coroutine_yield< Arg & > yield_type;

    symmetric_coroutine_call() noexcept :
        impl_( 0)
    {}
# 362 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
    template< typename Fn >
    explicit symmetric_coroutine_call( Fn && fn,
                                       attributes const& attrs = attributes(),
                                       stack_allocator stack_alloc = stack_allocator() ) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef symmetric_coroutine_object< Arg &, Fn, stack_allocator > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                    boost::forward< Fn >( fn), attrs, preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
    }

    template< typename Fn, typename StackAllocator >
    explicit symmetric_coroutine_call( Fn && fn,
                                       attributes const& attrs,
                                       StackAllocator stack_alloc) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef symmetric_coroutine_object< Arg &, Fn, StackAllocator > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                    boost::forward< Fn >( fn), attrs, preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
    }
# 507 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
    ~symmetric_coroutine_call()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    symmetric_coroutine_call( symmetric_coroutine_call && other) noexcept :
        impl_( 0)
    { swap( other); }

    symmetric_coroutine_call & operator=( symmetric_coroutine_call && other) noexcept
    {
        symmetric_coroutine_call tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete() || impl_->is_running(); }

    void swap( symmetric_coroutine_call & other) noexcept
    { std::swap( impl_, other.impl_); }

    symmetric_coroutine_call & operator()( Arg & arg) noexcept
    {
        (static_cast<void> (0));

        impl_->resume( arg);
        return * this;
    }
};

template<>
class symmetric_coroutine_call< void >
{
private:
    template< typename X >
    friend class symmetric_coroutine_yield;

    typedef symmetric_coroutine_impl< void > impl_type;

    public: symmetric_coroutine_call(symmetric_coroutine_call const &) = delete; symmetric_coroutine_call& operator=(symmetric_coroutine_call const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

    struct dummy {};

    impl_type * impl_;

public:
    typedef void value_type;
    typedef symmetric_coroutine_yield< void > yield_type;

    symmetric_coroutine_call() noexcept :
        impl_( 0)
    {}
# 618 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
    template< typename Fn >
    explicit symmetric_coroutine_call( Fn && fn,
                                       attributes const& attrs = attributes(),
                                       stack_allocator stack_alloc = stack_allocator() ) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef symmetric_coroutine_object< void, Fn, stack_allocator > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                    boost::forward< Fn >( fn), attrs, preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
    }

    template< typename Fn, typename StackAllocator >
    explicit symmetric_coroutine_call( Fn && fn,
                                       attributes const& attrs,
                                       StackAllocator stack_alloc) :
        impl_( 0)
    {

        stack_context stack_ctx;

        stack_alloc.allocate( stack_ctx, attrs.size);
        (static_cast<void> (0));

        typedef symmetric_coroutine_object< void, Fn, StackAllocator > object_t;

        std::size_t size = stack_ctx.size - sizeof( object_t);
        (static_cast<void> (0));
        void * sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
        (static_cast<void> (0));

        impl_ = new ( sp) object_t(
                    boost::forward< Fn >( fn), attrs, preallocated( sp, size, stack_ctx), stack_alloc);
        (static_cast<void> (0));
    }
# 763 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/detail/symmetric_coroutine_call.hpp" 3 4
    ~symmetric_coroutine_call()
    {
        if ( 0 != impl_)
        {
            impl_->destroy();
            impl_ = 0;
        }
    }

    inline symmetric_coroutine_call( symmetric_coroutine_call && other) noexcept :
        impl_( 0)
    { swap( other); }

    inline symmetric_coroutine_call & operator=( symmetric_coroutine_call && other) noexcept
    {
        symmetric_coroutine_call tmp( boost::move( other) );
        swap( tmp);
        return * this;
    }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const { return !this->operator! (); };

    inline bool operator!() const noexcept
    { return 0 == impl_ || impl_->is_complete() || impl_->is_running(); }

    inline void swap( symmetric_coroutine_call & other) noexcept
    { std::swap( impl_, other.impl_); }

    inline symmetric_coroutine_call & operator()() noexcept
    {
        (static_cast<void> (0));

        impl_->resume();
        return * this;
    }
};

template< typename Arg >
void swap( symmetric_coroutine_call< Arg > & l,
           symmetric_coroutine_call< Arg > & r)
{ l.swap( r); }

}}}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/symmetric_coroutine.hpp" 2 3 4






namespace boost {
namespace coroutines {

template< typename T >
struct symmetric_coroutine
{
    typedef detail::symmetric_coroutine_call< T > call_type;
    typedef detail::symmetric_coroutine_yield< T > yield_type;
};

}}
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/coroutine.hpp" 2 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/all.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/protected_stack_allocator.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/protected_stack_allocator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/posix/protected_stack_allocator.hpp" 1 3 4
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/posix/protected_stack_allocator.hpp" 3 4
extern "C" {




}





# 1 "/usr/include/c++/10/cmath" 1 3 4
# 39 "/usr/include/c++/10/cmath" 3 4
       
# 40 "/usr/include/c++/10/cmath" 3
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/posix/protected_stack_allocator.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/posix/protected_stack_allocator.hpp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/posix/protected_stack_allocator.hpp" 3 4
namespace boost {
namespace coroutines {

template< typename traitsT >
struct basic_protected_stack_allocator
{
    typedef traitsT traits_type;

    void allocate( stack_context & ctx, std::size_t size = traits_type::minimum_size() )
    {
        (static_cast<void> (0));
        (static_cast<void> (0));


        const std::size_t pages(
            static_cast< std::size_t >(
                std::floor(
                    static_cast< float >( size) / traits_type::page_size() ) ) );
        (static_cast<void> (0));
        const std::size_t size_( pages * traits_type::page_size() );
        (static_cast<void> (0));
        (static_cast<void> (0));



        void * limit = ::mmap( 0, size_, 0x1 | 0x2, 0x02 | 0x20, -1, 0);



        if ( ((void *) -1) == limit) throw std::bad_alloc();





        const int result( ::mprotect( limit, traits_type::page_size(), 0x0) );
        (static_cast<void> (0));


        ctx.size = size_;
        ctx.sp = static_cast< char * >( limit) + ctx.size;



    }

    void deallocate( stack_context & ctx)
    {
        (static_cast<void> (0));
        (static_cast<void> (0));
        (static_cast<void> (0));




        void * limit = static_cast< char * >( ctx.sp) - ctx.size;

        ::munmap( limit, ctx.size);
    }
};

typedef basic_protected_stack_allocator< stack_traits > protected_stack_allocator;

}}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/protected_stack_allocator.hpp" 2 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/all.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/segmented_stack_allocator.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/coroutine/all.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/uses_executor.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/uses_executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/uses_executor.hpp" 2 3 4

namespace boost {
namespace asio {
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/uses_executor.hpp" 3 4
struct executor_arg_t
{

  constexpr executor_arg_t() noexcept
  {
  }
};
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/uses_executor.hpp" 3 4
constexpr executor_arg_t executor_arg;
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/uses_executor.hpp" 3 4
template <typename T, typename Executor>
struct uses_executor : false_type {};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/uses_executor.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename T>
struct executor_binder_check
{
  typedef void type;
};



template <typename T, typename = void>
struct executor_binder_result_type
{
protected:
  typedef void result_type_or_void;
};

template <typename T>
struct executor_binder_result_type<T,
  typename executor_binder_check<typename T::result_type>::type>
{
  typedef typename T::result_type result_type;
protected:
  typedef result_type result_type_or_void;
};

template <typename R>
struct executor_binder_result_type<R(*)()>
{
  typedef R result_type;
protected:
  typedef result_type result_type_or_void;
};

template <typename R>
struct executor_binder_result_type<R(&)()>
{
  typedef R result_type;
protected:
  typedef result_type result_type_or_void;
};

template <typename R, typename A1>
struct executor_binder_result_type<R(*)(A1)>
{
  typedef R result_type;
protected:
  typedef result_type result_type_or_void;
};

template <typename R, typename A1>
struct executor_binder_result_type<R(&)(A1)>
{
  typedef R result_type;
protected:
  typedef result_type result_type_or_void;
};

template <typename R, typename A1, typename A2>
struct executor_binder_result_type<R(*)(A1, A2)>
{
  typedef R result_type;
protected:
  typedef result_type result_type_or_void;
};

template <typename R, typename A1, typename A2>
struct executor_binder_result_type<R(&)(A1, A2)>
{
  typedef R result_type;
protected:
  typedef result_type result_type_or_void;
};



template <typename T, typename = void>
struct executor_binder_argument_type {};

template <typename T>
struct executor_binder_argument_type<T,
  typename executor_binder_check<typename T::argument_type>::type>
{
  typedef typename T::argument_type argument_type;
};

template <typename R, typename A1>
struct executor_binder_argument_type<R(*)(A1)>
{
  typedef A1 argument_type;
};

template <typename R, typename A1>
struct executor_binder_argument_type<R(&)(A1)>
{
  typedef A1 argument_type;
};




template <typename T, typename = void>
struct executor_binder_argument_types {};

template <typename T>
struct executor_binder_argument_types<T,
  typename executor_binder_check<typename T::first_argument_type>::type>
{
  typedef typename T::first_argument_type first_argument_type;
  typedef typename T::second_argument_type second_argument_type;
};

template <typename R, typename A1, typename A2>
struct executor_binder_argument_type<R(*)(A1, A2)>
{
  typedef A1 first_argument_type;
  typedef A2 second_argument_type;
};

template <typename R, typename A1, typename A2>
struct executor_binder_argument_type<R(&)(A1, A2)>
{
  typedef A1 first_argument_type;
  typedef A2 second_argument_type;
};





template <typename T, typename Executor, bool UsesExecutor>
class executor_binder_base;

template <typename T, typename Executor>
class executor_binder_base<T, Executor, true>
  : protected Executor
{
protected:
  template <typename E, typename U>
  executor_binder_base(E&& e, U&& u)
    : executor_(static_cast<E&&>(e)),
      target_(executor_arg_t(), executor_, static_cast<U&&>(u))
  {
  }

  Executor executor_;
  T target_;
};

template <typename T, typename Executor>
class executor_binder_base<T, Executor, false>
{
protected:
  template <typename E, typename U>
  executor_binder_base(E&& e, U&& u)
    : executor_(static_cast<E&&>(e)),
      target_(static_cast<U&&>(u))
  {
  }

  Executor executor_;
  T target_;
};



template <typename T, typename = void>
struct executor_binder_result_of0
{
  typedef void type;
};

template <typename T>
struct executor_binder_result_of0<T,
  typename executor_binder_check<typename result_of<T()>::type>::type>
{
  typedef typename result_of<T()>::type type;
};

}



template <typename T, typename Executor>
class executor_binder

  : public detail::executor_binder_result_type<T>,
    public detail::executor_binder_argument_type<T>,
    public detail::executor_binder_argument_types<T>,
    private detail::executor_binder_base<
      T, Executor, uses_executor<T, Executor>::value>

{
public:

  typedef T target_type;


  typedef Executor executor_type;
# 299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 3 4
  template <typename U>
  executor_binder(executor_arg_t, const executor_type& e,
      U&& u)
    : base_type(e, static_cast<U&&>(u))
  {
  }


  executor_binder(const executor_binder& other)
    : base_type(other.get_executor(), other.get())
  {
  }


  executor_binder(executor_arg_t, const executor_type& e,
      const executor_binder& other)
    : base_type(e, other.get())
  {
  }







  template <typename U, typename OtherExecutor>
  executor_binder(const executor_binder<U, OtherExecutor>& other)
    : base_type(other.get_executor(), other.get())
  {
  }







  template <typename U, typename OtherExecutor>
  executor_binder(executor_arg_t, const executor_type& e,
      const executor_binder<U, OtherExecutor>& other)
    : base_type(e, other.get())
  {
  }




  executor_binder(executor_binder&& other)
    : base_type(static_cast<executor_type&&>(other.get_executor()),
        static_cast<T&&>(other.get()))
  {
  }


  executor_binder(executor_arg_t, const executor_type& e,
      executor_binder&& other)
    : base_type(e, static_cast<T&&>(other.get()))
  {
  }


  template <typename U, typename OtherExecutor>
  executor_binder(executor_binder<U, OtherExecutor>&& other)
    : base_type(static_cast<OtherExecutor&&>(other.get_executor()),
        static_cast<U&&>(other.get()))
  {
  }



  template <typename U, typename OtherExecutor>
  executor_binder(executor_arg_t, const executor_type& e,
      executor_binder<U, OtherExecutor>&& other)
    : base_type(e, static_cast<U&&>(other.get()))
  {
  }




  ~executor_binder()
  {
  }


  target_type& get() noexcept
  {
    return this->target_;
  }


  const target_type& get() const noexcept
  {
    return this->target_;
  }


  executor_type get_executor() const noexcept
  {
    return this->executor_;
  }
# 410 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 3 4
  template <typename... Args>
  typename result_of<T(Args...)>::type operator()(
      Args&&... args)
  {
    return this->target_(static_cast<Args&&>(args)...);
  }


  template <typename... Args>
  typename result_of<T(Args...)>::type operator()(
      Args&&... args) const
  {
    return this->target_(static_cast<Args&&>(args)...);
  }
# 490 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 3 4
private:
  typedef detail::executor_binder_base<T, Executor,
    uses_executor<T, Executor>::value> base_type;
};


template <typename Executor, typename T>
inline executor_binder<typename decay<T>::type, Executor>
bind_executor(const Executor& ex, T&& t,
    typename enable_if<is_executor<Executor>::value>::type* = 0)
{
  return executor_binder<typename decay<T>::type, Executor>(
      executor_arg_t(), ex, static_cast<T&&>(t));
}


template <typename ExecutionContext, typename T>
inline executor_binder<typename decay<T>::type,
  typename ExecutionContext::executor_type>
bind_executor(ExecutionContext& ctx, T&& t,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type* = 0)
{
  return executor_binder<typename decay<T>::type,
    typename ExecutionContext::executor_type>(
      executor_arg_t(), ctx.get_executor(), static_cast<T&&>(t));
}



template <typename T, typename Executor>
struct uses_executor<executor_binder<T, Executor>, Executor>
  : true_type {};

template <typename T, typename Executor, typename Signature>
class async_result<executor_binder<T, Executor>, Signature>
{
public:
  typedef executor_binder<
    typename async_result<T, Signature>::completion_handler_type, Executor>
      completion_handler_type;

  typedef typename async_result<T, Signature>::return_type return_type;

  explicit async_result(executor_binder<T, Executor>& b)
    : target_(b.get())
  {
  }

  return_type get()
  {
    return target_.get();
  }

private:
  async_result(const async_result&) = delete;
  async_result& operator=(const async_result&) = delete;

  async_result<T, Signature> target_;
};



template <typename T, typename Executor, typename Signature>
struct handler_type<executor_binder<T, Executor>, Signature>
{
  typedef executor_binder<
    typename handler_type<T, Signature>::type, Executor> type;
};

template <typename T, typename Executor>
class async_result<executor_binder<T, Executor> >
{
public:
  typedef typename async_result<T>::type type;

  explicit async_result(executor_binder<T, Executor>& b)
    : target_(b.get())
  {
  }

  type get()
  {
    return target_.get();
  }

private:
  async_result<T> target_;
};



template <typename T, typename Executor, typename Allocator>
struct associated_allocator<executor_binder<T, Executor>, Allocator>
{
  typedef typename associated_allocator<T, Allocator>::type type;

  static type get(const executor_binder<T, Executor>& b,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<T, Allocator>::get(b.get(), a);
  }
};

template <typename T, typename Executor, typename Executor1>
struct associated_executor<executor_binder<T, Executor>, Executor1>
{
  typedef Executor type;

  static type get(const executor_binder<T, Executor>& b,
      const Executor1& = Executor1()) noexcept
  {
    return b.get_executor();
  }
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 612 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/bind_executor.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/cstddef.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/cstddef.hpp" 3 4
namespace boost {
namespace asio {


using std::nullptr_t;




}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 2 3 4

namespace boost {
namespace asio {


class bad_executor
  : public std::exception
{
public:

  inline bad_executor() noexcept;


  inline virtual const char* what() const
    noexcept;
};


class executor
{
public:

  executor() noexcept
    : impl_(0)
  {
  }


  executor(nullptr_t) noexcept
    : impl_(0)
  {
  }


  executor(const executor& other) noexcept
    : impl_(other.clone())
  {
  }



  executor(executor&& other) noexcept
    : impl_(other.impl_)
  {
    other.impl_ = 0;
  }



  template <typename Executor>
  executor(Executor e);



  template <typename Executor, typename Allocator>
  executor(allocator_arg_t, const Allocator& a, Executor e);


  ~executor()
  {
    destroy();
  }


  executor& operator=(const executor& other) noexcept
  {
    destroy();
    impl_ = other.clone();
    return *this;
  }



  executor& operator=(executor&& other) noexcept
  {
    destroy();
    impl_ = other.impl_;
    other.impl_ = 0;
    return *this;
  }



  executor& operator=(nullptr_t) noexcept
  {
    destroy();
    impl_ = 0;
    return *this;
  }



  template <typename Executor>
  executor& operator=(Executor&& e) noexcept
  {
    executor tmp(static_cast<Executor&&>(e));
    destroy();
    impl_ = tmp.impl_;
    tmp.impl_ = 0;
    return *this;
  }


  execution_context& context() const noexcept
  {
    return get_impl()->context();
  }


  void on_work_started() const noexcept
  {
    get_impl()->on_work_started();
  }


  void on_work_finished() const noexcept
  {
    get_impl()->on_work_finished();
  }
# 159 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 3 4
  template <typename Function, typename Allocator>
  void dispatch(Function&& f, const Allocator& a) const;
# 175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 3 4
  template <typename Function, typename Allocator>
  void post(Function&& f, const Allocator& a) const;
# 191 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 3 4
  template <typename Function, typename Allocator>
  void defer(Function&& f, const Allocator& a) const;

  struct unspecified_bool_type_t {};
  typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
  static void unspecified_bool_true(unspecified_bool_type_t) {}


  operator unspecified_bool_type() const noexcept
  {
    return impl_ ? &executor::unspecified_bool_true : 0;
  }







  const std::type_info& target_type() const noexcept
  {
    return impl_ ? impl_->target_type() : typeid(void);
  }
# 226 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 3 4
  template <typename Executor>
  Executor* target() noexcept;






  template <typename Executor>
  const Executor* target() const noexcept;


  friend bool operator==(const executor& a,
      const executor& b) noexcept
  {
    if (a.impl_ == b.impl_)
      return true;
    if (!a.impl_ || !b.impl_)
      return false;
    return a.impl_->equals(b.impl_);
  }


  friend bool operator!=(const executor& a,
      const executor& b) noexcept
  {
    return !(a == b);
  }

private:

  class function;
  template <typename, typename> class impl;


  typedef const std::type_info& type_id_result_type;




  template <typename T>
  static type_id_result_type type_id()
  {

    return typeid(T);




  }


  class impl_base
  {
  public:
    virtual impl_base* clone() const noexcept = 0;
    virtual void destroy() noexcept = 0;
    virtual execution_context& context() noexcept = 0;
    virtual void on_work_started() noexcept = 0;
    virtual void on_work_finished() noexcept = 0;
    virtual void dispatch(function&&) = 0;
    virtual void post(function&&) = 0;
    virtual void defer(function&&) = 0;
    virtual type_id_result_type target_type() const noexcept = 0;
    virtual void* target() noexcept = 0;
    virtual const void* target() const noexcept = 0;
    virtual bool equals(const impl_base* e) const noexcept = 0;

  protected:
    impl_base(bool fast_dispatch) : fast_dispatch_(fast_dispatch) {}
    virtual ~impl_base() {}

  private:
    friend class executor;
    const bool fast_dispatch_;
  };


  impl_base* get_impl() const
  {
    if (!impl_)
    {
      bad_executor ex;
      boost::asio::detail::throw_exception(ex);
    }
    return impl_;
  }


  impl_base* clone() const noexcept
  {
    return impl_ ? impl_->clone() : 0;
  }


  void destroy() noexcept
  {
    if (impl_)
      impl_->destroy();
  }

  impl_base* impl_;

};

}
}

namespace std { template <typename Allocator> struct uses_allocator<boost::asio::executor, Allocator> : true_type {}; }

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 337 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.hpp" 2 3 4

namespace boost {
namespace asio {






class executor::function
{
public:
  template <typename F, typename Alloc>
  explicit function(F f, const Alloc& a)
  {

    typedef detail::executor_op<F, Alloc> op;
    typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
    op_ = new (p.v) op(static_cast<F&&>(f), a);
    p.v = 0;
  }

  function(function&& other)
    : op_(other.op_)
  {
    other.op_ = 0;
  }

  ~function()
  {
    if (op_)
      op_->destroy();
  }

  void operator()()
  {
    if (op_)
    {
      detail::scheduler_operation* op = op_;
      op_ = 0;
      op->complete(this, boost::system::error_code(), 0);
    }
  }

private:
  detail::scheduler_operation* op_;
};
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.hpp" 3 4
template <typename Executor, typename Allocator>
class executor::impl
  : public executor::impl_base
{
public:
  typedef typename std::allocator_traits<Allocator>::template rebind_alloc<impl> allocator_type;

  static impl_base* create(const Executor& e, Allocator a = Allocator())
  {
    raw_mem mem(a);
    impl* p = new (mem.ptr_) impl(e, a);
    mem.ptr_ = 0;
    return p;
  }

  impl(const Executor& e, const Allocator& a) noexcept
    : impl_base(false),
      ref_count_(1),
      executor_(e),
      allocator_(a)
  {
  }

  impl_base* clone() const noexcept
  {
    ++ref_count_;
    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
  }

  void destroy() noexcept
  {
    if (--ref_count_ == 0)
    {
      allocator_type alloc(allocator_);
      impl* p = this;
      p->~impl();
      alloc.deallocate(p, 1);
    }
  }

  void on_work_started() noexcept
  {
    executor_.on_work_started();
  }

  void on_work_finished() noexcept
  {
    executor_.on_work_finished();
  }

  execution_context& context() noexcept
  {
    return executor_.context();
  }

  void dispatch(function&& f)
  {
    executor_.dispatch(static_cast<function&&>(f), allocator_);
  }

  void post(function&& f)
  {
    executor_.post(static_cast<function&&>(f), allocator_);
  }

  void defer(function&& f)
  {
    executor_.defer(static_cast<function&&>(f), allocator_);
  }

  type_id_result_type target_type() const noexcept
  {
    return type_id<Executor>();
  }

  void* target() noexcept
  {
    return &executor_;
  }

  const void* target() const noexcept
  {
    return &executor_;
  }

  bool equals(const impl_base* e) const noexcept
  {
    if (this == e)
      return true;
    if (target_type() != e->target_type())
      return false;
    return executor_ == *static_cast<const Executor*>(e->target());
  }

private:
  mutable detail::atomic_count ref_count_;
  Executor executor_;
  Allocator allocator_;

  struct raw_mem
  {
    allocator_type allocator_;
    impl* ptr_;

    explicit raw_mem(const Allocator& a)
      : allocator_(a),
        ptr_(allocator_.allocate(1))
    {
    }

    ~raw_mem()
    {
      if (ptr_)
        allocator_.deallocate(ptr_, 1);
    }

  private:

    raw_mem(const raw_mem&);
    raw_mem operator=(const raw_mem&);
  };
};


template <typename Allocator>
class executor::impl<system_executor, Allocator>
  : public executor::impl_base
{
public:
  static impl_base* create(const system_executor&,
      const Allocator& = Allocator())
  {
    return &detail::global<impl<system_executor, std::allocator<void> > >();
  }

  impl()
    : impl_base(true)
  {
  }

  impl_base* clone() const noexcept
  {
    return const_cast<impl_base*>(static_cast<const impl_base*>(this));
  }

  void destroy() noexcept
  {
  }

  void on_work_started() noexcept
  {
    executor_.on_work_started();
  }

  void on_work_finished() noexcept
  {
    executor_.on_work_finished();
  }

  execution_context& context() noexcept
  {
    return executor_.context();
  }

  void dispatch(function&& f)
  {
    executor_.dispatch(static_cast<function&&>(f), allocator_);
  }

  void post(function&& f)
  {
    executor_.post(static_cast<function&&>(f), allocator_);
  }

  void defer(function&& f)
  {
    executor_.defer(static_cast<function&&>(f), allocator_);
  }

  type_id_result_type target_type() const noexcept
  {
    return type_id<system_executor>();
  }

  void* target() noexcept
  {
    return &executor_;
  }

  const void* target() const noexcept
  {
    return &executor_;
  }

  bool equals(const impl_base* e) const noexcept
  {
    return this == e;
  }

private:
  system_executor executor_;
  Allocator allocator_;
};

template <typename Executor>
executor::executor(Executor e)
  : impl_(impl<Executor, std::allocator<void> >::create(e))
{
}

template <typename Executor, typename Allocator>
executor::executor(allocator_arg_t, const Allocator& a, Executor e)
  : impl_(impl<Executor, Allocator>::create(e, a))
{
}

template <typename Function, typename Allocator>
void executor::dispatch(Function&& f,
    const Allocator& a) const
{
  impl_base* i = get_impl();
  if (i->fast_dispatch_)
    system_executor().dispatch(static_cast<Function&&>(f), a);
  else
    i->dispatch(function(static_cast<Function&&>(f), a));
}

template <typename Function, typename Allocator>
void executor::post(Function&& f,
    const Allocator& a) const
{
  get_impl()->post(function(static_cast<Function&&>(f), a));
}

template <typename Function, typename Allocator>
void executor::defer(Function&& f,
    const Allocator& a) const
{
  get_impl()->defer(function(static_cast<Function&&>(f), a));
}

template <typename Executor>
Executor* executor::target() noexcept
{
  return impl_ && impl_->target_type() == type_id<Executor>()
    ? static_cast<Executor*>(impl_->target()) : 0;
}

template <typename Executor>
const Executor* executor::target() const noexcept
{
  return impl_ && impl_->target_type() == type_id<Executor>()
    ? static_cast<Executor*>(impl_->target()) : 0;
}



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 387 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.hpp" 2 3 4
# 339 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.ipp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.ipp" 2 3 4

namespace boost {
namespace asio {

bad_executor::bad_executor() noexcept
{
}

const char* bad_executor::what() const noexcept
{
  return "bad executor";
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/executor.ipp" 2 3 4
# 341 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_executor_service.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_executor_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


class strand_executor_service
  : public execution_context_service_base<strand_executor_service>
{
public:

  class strand_impl
  {
  public:
    inline ~strand_impl();

  private:
    friend class strand_executor_service;


    mutex* mutex_;




    bool locked_;



    bool shutdown_;




    op_queue<scheduler_operation> waiting_queue_;




    op_queue<scheduler_operation> ready_queue_;


    strand_impl* next_;
    strand_impl* prev_;


    strand_executor_service* service_;
  };

  typedef shared_ptr<strand_impl> implementation_type;


  inline explicit strand_executor_service(execution_context& context);


  inline void shutdown();


  inline implementation_type create_implementation();


  template <typename Executor, typename Function, typename Allocator>
  static void dispatch(const implementation_type& impl, Executor& ex,
      Function&& function, const Allocator& a);


  template <typename Executor, typename Function, typename Allocator>
  static void post(const implementation_type& impl, Executor& ex,
      Function&& function, const Allocator& a);


  template <typename Executor, typename Function, typename Allocator>
  static void defer(const implementation_type& impl, Executor& ex,
      Function&& function, const Allocator& a);


  inline static bool running_in_this_thread(
      const implementation_type& impl);

private:
  friend class strand_impl;
  template <typename Executor> class invoker;


  inline static bool enqueue(const implementation_type& impl,
      scheduler_operation* op);


  mutex mutex_;


  enum { num_mutexes = 193 };


  scoped_ptr<mutex> mutexes_[num_mutexes];



  std::size_t salt_;


  strand_impl* impl_list_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor_work_guard.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor_work_guard.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor_work_guard.hpp" 2 3 4

namespace boost {
namespace asio {



template <typename Executor>
class executor_work_guard
{
public:

  typedef Executor executor_type;





  explicit executor_work_guard(const executor_type& e) noexcept
    : executor_(e),
      owns_(true)
  {
    executor_.on_work_started();
  }


  executor_work_guard(const executor_work_guard& other) noexcept
    : executor_(other.executor_),
      owns_(other.owns_)
  {
    if (owns_)
      executor_.on_work_started();
  }



  executor_work_guard(executor_work_guard&& other)
    : executor_(static_cast<Executor&&>(other.executor_)),
      owns_(other.owns_)
  {
    other.owns_ = false;
  }







  ~executor_work_guard()
  {
    if (owns_)
      executor_.on_work_finished();
  }


  executor_type get_executor() const noexcept
  {
    return executor_;
  }


  bool owns_work() const noexcept
  {
    return owns_;
  }






  void reset() noexcept
  {
    if (owns_)
    {
      executor_.on_work_finished();
      owns_ = false;
    }
  }

private:

  executor_work_guard& operator=(const executor_work_guard&);

  executor_type executor_;
  bool owns_;
};


template <typename Executor>
inline executor_work_guard<Executor> make_work_guard(const Executor& ex,
    typename enable_if<is_executor<Executor>::value>::type* = 0)
{
  return executor_work_guard<Executor>(ex);
}


template <typename ExecutionContext>
inline executor_work_guard<typename ExecutionContext::executor_type>
make_work_guard(ExecutionContext& ctx,
    typename enable_if<
      is_convertible<ExecutionContext&, execution_context&>::value>::type* = 0)
{
  return executor_work_guard<typename ExecutionContext::executor_type>(
      ctx.get_executor());
}


template <typename T>
inline executor_work_guard<typename associated_executor<T>::type>
make_work_guard(const T& t,
    typename enable_if<!is_executor<T>::value &&
      !is_convertible<T&, execution_context&>::value>::type* = 0)
{
  return executor_work_guard<typename associated_executor<T>::type>(
      associated_executor<T>::get(t));
}


template <typename T, typename Executor>
inline executor_work_guard<typename associated_executor<T, Executor>::type>
make_work_guard(const T& t, const Executor& ex,
    typename enable_if<is_executor<Executor>::value>::type* = 0)
{
  return executor_work_guard<typename associated_executor<T, Executor>::type>(
      associated_executor<T, Executor>::get(t, ex));
}


template <typename T, typename ExecutionContext>
inline executor_work_guard<typename associated_executor<T,
  typename ExecutionContext::executor_type>::type>
make_work_guard(const T& t, ExecutionContext& ctx,
    typename enable_if<!is_executor<T>::value &&
      !is_convertible<T&, execution_context&>::value &&
      is_convertible<ExecutionContext&, execution_context&>::value>::type* = 0)
{
  return executor_work_guard<typename associated_executor<T,
    typename ExecutionContext::executor_type>::type>(
      associated_executor<T, typename ExecutionContext::executor_type>::get(
        t, ctx.get_executor()));
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/executor_work_guard.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Executor>
class strand_executor_service::invoker
{
public:
  invoker(const implementation_type& impl, Executor& ex)
    : impl_(impl),
      work_(ex)
  {
  }

  invoker(const invoker& other)
    : impl_(other.impl_),
      work_(other.work_)
  {
  }


  invoker(invoker&& other)
    : impl_(static_cast<implementation_type&&>(other.impl_)),
      work_(static_cast<executor_work_guard<Executor>&&>(other.work_))
  {
  }


  struct on_invoker_exit
  {
    invoker* this_;

    ~on_invoker_exit()
    {
      this_->impl_->mutex_->lock();
      this_->impl_->ready_queue_.push(this_->impl_->waiting_queue_);
      bool more_handlers = this_->impl_->locked_ =
        !this_->impl_->ready_queue_.empty();
      this_->impl_->mutex_->unlock();

      if (more_handlers)
      {
        Executor ex(this_->work_.get_executor());
        recycling_allocator<void> allocator;
        ex.post(static_cast<invoker&&>(*this_), allocator);
      }
    }
  };

  void operator()()
  {

    call_stack<strand_impl>::context ctx(impl_.get());


    on_invoker_exit on_exit = { this };
    (void)on_exit;



    boost::system::error_code ec;
    while (scheduler_operation* o = impl_->ready_queue_.front())
    {
      impl_->ready_queue_.pop();
      o->complete(impl_.get(), ec, 0);
    }
  }

private:
  implementation_type impl_;
  executor_work_guard<Executor> work_;
};

template <typename Executor, typename Function, typename Allocator>
void strand_executor_service::dispatch(const implementation_type& impl,
    Executor& ex, Function&& function, const Allocator& a)
{
  typedef typename decay<Function>::type function_type;


  if (call_stack<strand_impl>::contains(impl.get()))
  {

    function_type tmp(static_cast<Function&&>(function));

    fenced_block b(fenced_block::full);
    boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
    return;
  }


  typedef executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(function), a);

  (void)0
                                                      ;


  bool first = enqueue(impl, p.p);
  p.v = p.p = 0;
  if (first)
    ex.dispatch(invoker<Executor>(impl, ex), a);
}


template <typename Executor, typename Function, typename Allocator>
void strand_executor_service::post(const implementation_type& impl,
    Executor& ex, Function&& function, const Allocator& a)
{
  typedef typename decay<Function>::type function_type;


  typedef executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(function), a);

  (void)0
                                                  ;


  bool first = enqueue(impl, p.p);
  p.v = p.p = 0;
  if (first)
    ex.post(invoker<Executor>(impl, ex), a);
}


template <typename Executor, typename Function, typename Allocator>
void strand_executor_service::defer(const implementation_type& impl,
    Executor& ex, Function&& function, const Allocator& a)
{
  typedef typename decay<Function>::type function_type;


  typedef executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(function), a);

  (void)0
                                                   ;


  bool first = enqueue(impl, p.p);
  p.v = p.p = 0;
  if (first)
    ex.defer(invoker<Executor>(impl, ex), a);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 180 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.hpp" 2 3 4
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_executor_service.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

strand_executor_service::strand_executor_service(execution_context& ctx)
  : execution_context_service_base<strand_executor_service>(ctx),
    mutex_(),
    salt_(0),
    impl_list_(0)
{
}

void strand_executor_service::shutdown()
{
  op_queue<scheduler_operation> ops;

  boost::asio::detail::mutex::scoped_lock lock(mutex_);

  strand_impl* impl = impl_list_;
  while (impl)
  {
    impl->mutex_->lock();
    impl->shutdown_ = true;
    ops.push(impl->waiting_queue_);
    ops.push(impl->ready_queue_);
    impl->mutex_->unlock();
    impl = impl->next_;
  }
}

strand_executor_service::implementation_type
strand_executor_service::create_implementation()
{
  implementation_type new_impl(new strand_impl);
  new_impl->locked_ = false;
  new_impl->shutdown_ = false;

  boost::asio::detail::mutex::scoped_lock lock(mutex_);


  std::size_t salt = salt_++;
  std::size_t mutex_index = reinterpret_cast<std::size_t>(new_impl.get());
  mutex_index += (reinterpret_cast<std::size_t>(new_impl.get()) >> 3);
  mutex_index ^= salt + 0x9e3779b9 + (mutex_index << 6) + (mutex_index >> 2);
  mutex_index = mutex_index % num_mutexes;
  if (!mutexes_[mutex_index].get())
    mutexes_[mutex_index].reset(new mutex);
  new_impl->mutex_ = mutexes_[mutex_index].get();


  new_impl->next_ = impl_list_;
  new_impl->prev_ = 0;
  if (impl_list_)
    impl_list_->prev_ = new_impl.get();
  impl_list_ = new_impl.get();
  new_impl->service_ = this;

  return new_impl;
}

strand_executor_service::strand_impl::~strand_impl()
{
  boost::asio::detail::mutex::scoped_lock lock(service_->mutex_);


  if (service_->impl_list_ == this)
    service_->impl_list_ = next_;
  if (prev_)
    prev_->next_ = next_;
  if (next_)
    next_->prev_= prev_;
}

bool strand_executor_service::enqueue(const implementation_type& impl,
    scheduler_operation* op)
{
  impl->mutex_->lock();
  if (impl->shutdown_)
  {
    impl->mutex_->unlock();
    op->destroy();
    return false;
  }
  else if (impl->locked_)
  {

    impl->waiting_queue_.push(op);
    impl->mutex_->unlock();
    return false;
  }
  else
  {


    impl->locked_ = true;
    impl->mutex_->unlock();
    impl->ready_queue_.push(op);
    return true;
  }
}

bool strand_executor_service::running_in_this_thread(
    const implementation_type& impl)
{
  return !!call_stack<strand_impl>::contains(impl.get());
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_executor_service.ipp" 2 3 4
# 142 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 2 3 4

namespace boost {
namespace asio {


template <typename Executor>
class strand
{
public:

  typedef Executor inner_executor_type;






  strand()
    : executor_(),
      impl_(use_service<detail::strand_executor_service>(
            executor_.context()).create_implementation())
  {
  }


  explicit strand(const Executor& e)
    : executor_(e),
      impl_(use_service<detail::strand_executor_service>(
            executor_.context()).create_implementation())
  {
  }


  strand(const strand& other) noexcept
    : executor_(other.executor_),
      impl_(other.impl_)
  {
  }






  template <class OtherExecutor>
  strand(
      const strand<OtherExecutor>& other) noexcept
    : executor_(other.executor_),
      impl_(other.impl_)
  {
  }


  strand& operator=(const strand& other) noexcept
  {
    executor_ = other.executor_;
    impl_ = other.impl_;
    return *this;
  }






  template <class OtherExecutor>
  strand& operator=(
      const strand<OtherExecutor>& other) noexcept
  {
    executor_ = other.executor_;
    impl_ = other.impl_;
    return *this;
  }



  strand(strand&& other) noexcept
    : executor_(static_cast<Executor&&>(other.executor_)),
      impl_(static_cast<implementation_type&&>(other.impl_))
  {
  }






  template <class OtherExecutor>
  strand(strand<OtherExecutor>&& other) noexcept
    : executor_(static_cast<OtherExecutor&&>(other)),
      impl_(static_cast<implementation_type&&>(other.impl_))
  {
  }


  strand& operator=(strand&& other) noexcept
  {
    executor_ = static_cast<Executor&&>(other);
    impl_ = static_cast<implementation_type&&>(other.impl_);
    return *this;
  }






  template <class OtherExecutor>
  strand& operator=(
      const strand<OtherExecutor>&& other) noexcept
  {
    executor_ = static_cast<OtherExecutor&&>(other);
    impl_ = static_cast<implementation_type&&>(other.impl_);
    return *this;
  }



  ~strand()
  {
  }


  inner_executor_type get_inner_executor() const noexcept
  {
    return executor_;
  }


  execution_context& context() const noexcept
  {
    return executor_.context();
  }





  void on_work_started() const noexcept
  {
    executor_.on_work_started();
  }





  void on_work_finished() const noexcept
  {
    executor_.on_work_finished();
  }
# 190 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 3 4
  template <typename Function, typename Allocator>
  void dispatch(Function&& f, const Allocator& a) const
  {
    detail::strand_executor_service::dispatch(impl_,
        executor_, static_cast<Function&&>(f), a);
  }
# 210 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 3 4
  template <typename Function, typename Allocator>
  void post(Function&& f, const Allocator& a) const
  {
    detail::strand_executor_service::post(impl_,
        executor_, static_cast<Function&&>(f), a);
  }
# 230 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 3 4
  template <typename Function, typename Allocator>
  void defer(Function&& f, const Allocator& a) const
  {
    detail::strand_executor_service::defer(impl_,
        executor_, static_cast<Function&&>(f), a);
  }







  bool running_in_this_thread() const noexcept
  {
    return detail::strand_executor_service::running_in_this_thread(impl_);
  }






  friend bool operator==(const strand& a, const strand& b) noexcept
  {
    return a.impl_ == b.impl_;
  }






  friend bool operator!=(const strand& a, const strand& b) noexcept
  {
    return a.impl_ != b.impl_;
  }

private:
  Executor executor_;
  typedef detail::strand_executor_service::implementation_type
    implementation_type;
  implementation_type impl_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 279 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_service.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


class strand_service
  : public boost::asio::detail::service_base<strand_service>
{
private:

  struct on_do_complete_exit;


  struct on_dispatch_exit;

public:


  class strand_impl
    : public operation
  {
  public:
    strand_impl();

  private:

    friend class strand_service;
    friend struct on_do_complete_exit;
    friend struct on_dispatch_exit;


    boost::asio::detail::mutex mutex_;




    bool locked_;




    op_queue<operation> waiting_queue_;




    op_queue<operation> ready_queue_;
  };

  typedef strand_impl* implementation_type;


  inline explicit strand_service(boost::asio::io_context& io_context);


  inline void shutdown();


  inline void construct(implementation_type& impl);


  template <typename Handler>
  void dispatch(implementation_type& impl, Handler& handler);


  template <typename Handler>
  void post(implementation_type& impl, Handler& handler);


  inline bool running_in_this_thread(
      const implementation_type& impl) const;

private:


  inline bool do_dispatch(implementation_type& impl, operation* op);


  inline void do_post(implementation_type& impl,
      operation* op, bool is_continuation);

  inline static void do_complete(void* owner,
      operation* base, const boost::system::error_code& ec,
      std::size_t bytes_transferred);


  io_context_impl& io_context_;


  boost::asio::detail::mutex mutex_;





  enum { num_implementations = 193 };



  scoped_ptr<strand_impl> implementations_[num_implementations];



  std::size_t salt_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_service.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

inline strand_service::strand_impl::strand_impl()
  : operation(&strand_service::do_complete),
    locked_(false)
{
}

struct strand_service::on_dispatch_exit
{
  io_context_impl* io_context_;
  strand_impl* impl_;

  ~on_dispatch_exit()
  {
    impl_->mutex_.lock();
    impl_->ready_queue_.push(impl_->waiting_queue_);
    bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
    impl_->mutex_.unlock();

    if (more_handlers)
      io_context_->post_immediate_completion(impl_, false);
  }
};

template <typename Handler>
void strand_service::dispatch(strand_service::implementation_type& impl,
    Handler& handler)
{

  if (call_stack<strand_impl>::contains(impl))
  {
    fenced_block b(fenced_block::full);
    boost_asio_handler_invoke_helpers::invoke(handler, handler);
    return;
  }


  typedef completion_handler<Handler> op;
  typename op::ptr p = { boost::asio::detail::addressof(handler),
    op::ptr::allocate(handler), 0 };
  p.p = new (p.v) op(handler);

  (void)0
                                             ;

  bool dispatch_immediately = do_dispatch(impl, p.p);
  operation* o = p.p;
  p.v = p.p = 0;

  if (dispatch_immediately)
  {

    call_stack<strand_impl>::context ctx(impl);


    on_dispatch_exit on_exit = { &io_context_, impl };
    (void)on_exit;

    completion_handler<Handler>::do_complete(
        &io_context_, o, boost::system::error_code(), 0);
  }
}


template <typename Handler>
void strand_service::post(strand_service::implementation_type& impl,
    Handler& handler)
{
  bool is_continuation =
    boost_asio_handler_cont_helpers::is_continuation(handler);


  typedef completion_handler<Handler> op;
  typename op::ptr p = { boost::asio::detail::addressof(handler),
    op::ptr::allocate(handler), 0 };
  p.p = new (p.v) op(handler);

  (void)0
                                         ;

  do_post(impl, p.p, is_continuation);
  p.v = p.p = 0;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.hpp" 2 3 4
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_service.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.ipp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_service.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct strand_service::on_do_complete_exit
{
  io_context_impl* owner_;
  strand_impl* impl_;

  ~on_do_complete_exit()
  {
    impl_->mutex_.lock();
    impl_->ready_queue_.push(impl_->waiting_queue_);
    bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
    impl_->mutex_.unlock();

    if (more_handlers)
      owner_->post_immediate_completion(impl_, true);
  }
};

strand_service::strand_service(boost::asio::io_context& io_context)
  : boost::asio::detail::service_base<strand_service>(io_context),
    io_context_(boost::asio::use_service<io_context_impl>(io_context)),
    mutex_(),
    salt_(0)
{
}

void strand_service::shutdown()
{
  op_queue<operation> ops;

  boost::asio::detail::mutex::scoped_lock lock(mutex_);

  for (std::size_t i = 0; i < num_implementations; ++i)
  {
    if (strand_impl* impl = implementations_[i].get())
    {
      ops.push(impl->waiting_queue_);
      ops.push(impl->ready_queue_);
    }
  }
}

void strand_service::construct(strand_service::implementation_type& impl)
{
  boost::asio::detail::mutex::scoped_lock lock(mutex_);

  std::size_t salt = salt_++;



  std::size_t index = reinterpret_cast<std::size_t>(&impl);
  index += (reinterpret_cast<std::size_t>(&impl) >> 3);
  index ^= salt + 0x9e3779b9 + (index << 6) + (index >> 2);

  index = index % num_implementations;

  if (!implementations_[index].get())
    implementations_[index].reset(new strand_impl);
  impl = implementations_[index].get();
}

bool strand_service::running_in_this_thread(
    const implementation_type& impl) const
{
  return call_stack<strand_impl>::contains(impl) != 0;
}

bool strand_service::do_dispatch(implementation_type& impl, operation* op)
{


  bool can_dispatch = io_context_.can_dispatch();
  impl->mutex_.lock();
  if (can_dispatch && !impl->locked_)
  {

    impl->locked_ = true;
    impl->mutex_.unlock();
    return true;
  }

  if (impl->locked_)
  {

    impl->waiting_queue_.push(op);
    impl->mutex_.unlock();
  }
  else
  {


    impl->locked_ = true;
    impl->mutex_.unlock();
    impl->ready_queue_.push(op);
    io_context_.post_immediate_completion(impl, false);
  }

  return false;
}

void strand_service::do_post(implementation_type& impl,
    operation* op, bool is_continuation)
{
  impl->mutex_.lock();
  if (impl->locked_)
  {

    impl->waiting_queue_.push(op);
    impl->mutex_.unlock();
  }
  else
  {


    impl->locked_ = true;
    impl->mutex_.unlock();
    impl->ready_queue_.push(op);
    io_context_.post_immediate_completion(impl, is_continuation);
  }
}

void strand_service::do_complete(void* owner, operation* base,
    const boost::system::error_code& ec, std::size_t )
{
  if (owner)
  {
    strand_impl* impl = static_cast<strand_impl*>(base);


    call_stack<strand_impl>::context ctx(impl);


    on_do_complete_exit on_exit;
    on_exit.owner_ = static_cast<io_context_impl*>(owner);
    on_exit.impl_ = impl;



    while (operation* o = impl->ready_queue_.front())
    {
      impl->ready_queue_.pop();
      o->complete(owner, ec, 0);
    }
  }
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 178 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4
# 142 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/strand_service.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 2 3 4

namespace boost {
namespace asio {
# 89 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
class io_context::strand
{
public:







  explicit strand(boost::asio::io_context& io_context)
    : service_(boost::asio::use_service<
        boost::asio::detail::strand_service>(io_context))
  {
    service_.construct(impl_);
  }
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  ~strand()
  {
  }
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return service_.get_io_context();
  }
# 141 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return service_.get_io_context();
  }



  boost::asio::io_context& context() const noexcept
  {
    return service_.get_io_context();
  }





  void on_work_started() const noexcept
  {
    context().get_executor().on_work_started();
  }





  void on_work_finished() const noexcept
  {
    context().get_executor().on_work_finished();
  }
# 186 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  template <typename Function, typename Allocator>
  void dispatch(Function&& f, const Allocator& a) const
  {
    typename decay<Function>::type tmp(static_cast<Function&&>(f));
    service_.dispatch(impl_, tmp);
    (void)a;
  }
# 215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  template <typename LegacyCompletionHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void ()>::return_type
  dispatch(LegacyCompletionHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__))
                                          type_check;

    async_completion<LegacyCompletionHandler, void ()> init(handler);

    service_.dispatch(impl_, init.completion_handler);

    return init.result.get();
  }
# 245 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  template <typename Function, typename Allocator>
  void post(Function&& f, const Allocator& a) const
  {
    typename decay<Function>::type tmp(static_cast<Function&&>(f));
    service_.post(impl_, tmp);
    (void)a;
  }
# 270 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  template <typename LegacyCompletionHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void ()>::return_type
  post(LegacyCompletionHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<LegacyCompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__))
                                          type_check;

    async_completion<LegacyCompletionHandler, void ()> init(handler);

    service_.post(impl_, init.completion_handler);

    return init.result.get();
  }
# 300 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  template <typename Function, typename Allocator>
  void defer(Function&& f, const Allocator& a) const
  {
    typename decay<Function>::type tmp(static_cast<Function&&>(f));
    service_.post(impl_, tmp);
    (void)a;
  }
# 330 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  template <typename Handler>



  detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>

  wrap(Handler handler)
  {
    return detail::wrapped_handler<io_context::strand, Handler,
        detail::is_continuation_if_running>(*this, handler);
  }
# 349 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 3 4
  bool running_in_this_thread() const noexcept
  {
    return service_.running_in_this_thread(impl_);
  }






  friend bool operator==(const strand& a, const strand& b) noexcept
  {
    return a.impl_ == b.impl_;
  }






  friend bool operator!=(const strand& a, const strand& b) noexcept
  {
    return a.impl_ != b.impl_;
  }

private:
  boost::asio::detail::strand_service& service_;
  mutable boost::asio::detail::strand_service::implementation_type impl_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 383 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_context_strand.hpp" 2 3 4
# 285 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/strand.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 2 3 4

namespace boost {
namespace asio {
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Handler>
class basic_yield_context
{
public:
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
  typedef boost::coroutines::push_coroutine<void> callee_type;
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
  typedef boost::coroutines::pull_coroutine<void> caller_type;
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
  basic_yield_context(
      const detail::weak_ptr<callee_type>& coro,
      caller_type& ca, Handler& handler)
    : coro_(coro),
      ca_(ca),
      handler_(handler),
      ec_(0)
  {
  }





  template <typename OtherHandler>
  basic_yield_context(const basic_yield_context<OtherHandler>& other)
    : coro_(other.coro_),
      ca_(other.ca_),
      handler_(other.handler_),
      ec_(other.ec_)
  {
  }
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
  basic_yield_context operator[](boost::system::error_code& ec) const
  {
    basic_yield_context tmp(*this);
    tmp.ec_ = &ec;
    return tmp;
  }




  detail::weak_ptr<callee_type> coro_;
  caller_type& ca_;
  Handler handler_;
  boost::system::error_code* ec_;
};





typedef basic_yield_context<
  executor_binder<void(*)(), executor> > yield_context;
# 204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Function>
void spawn(Function&& function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Handler, typename Function>
void spawn(Handler&& handler,
    Function&& function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes(),
    typename enable_if<!is_executor<typename decay<Handler>::type>::value &&
      !is_convertible<Handler&, execution_context&>::value>::type* = 0);
# 247 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Handler, typename Function>
void spawn(basic_yield_context<Handler> ctx,
    Function&& function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());
# 265 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Function, typename Executor>
void spawn(const Executor& ex,
    Function&& function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes(),
    typename enable_if<is_executor<Executor>::value>::type* = 0);
# 283 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Function, typename Executor>
void spawn(const strand<Executor>& ex,
    Function&& function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());
# 302 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Function>
void spawn(const boost::asio::io_context::strand& s,
    Function&& function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes());
# 321 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 3 4
template <typename Function, typename ExecutionContext>
void spawn(ExecutionContext& ctx,
    Function&& function,
    const boost::coroutines::attributes& attributes
      = boost::coroutines::attributes(),
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type* = 0);



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 335 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/spawn.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/spawn.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/spawn.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

  template <typename Handler, typename T>
  class coro_handler
  {
  public:
    coro_handler(basic_yield_context<Handler> ctx)
      : coro_(ctx.coro_.lock()),
        ca_(ctx.ca_),
        handler_(ctx.handler_),
        ready_(0),
        ec_(ctx.ec_),
        value_(0)
    {
    }

    void operator()(T value)
    {
      *ec_ = boost::system::error_code();
      *value_ = static_cast<T&&>(value);
      if (--*ready_ == 0)
        (*coro_)();
    }

    void operator()(boost::system::error_code ec, T value)
    {
      *ec_ = ec;
      *value_ = static_cast<T&&>(value);
      if (--*ready_ == 0)
        (*coro_)();
    }


    shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
    typename basic_yield_context<Handler>::caller_type& ca_;
    Handler handler_;
    atomic_count* ready_;
    boost::system::error_code* ec_;
    T* value_;
  };

  template <typename Handler>
  class coro_handler<Handler, void>
  {
  public:
    coro_handler(basic_yield_context<Handler> ctx)
      : coro_(ctx.coro_.lock()),
        ca_(ctx.ca_),
        handler_(ctx.handler_),
        ready_(0),
        ec_(ctx.ec_)
    {
    }

    void operator()()
    {
      *ec_ = boost::system::error_code();
      if (--*ready_ == 0)
        (*coro_)();
    }

    void operator()(boost::system::error_code ec)
    {
      *ec_ = ec;
      if (--*ready_ == 0)
        (*coro_)();
    }


    shared_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
    typename basic_yield_context<Handler>::caller_type& ca_;
    Handler handler_;
    atomic_count* ready_;
    boost::system::error_code* ec_;
  };

  template <typename Handler, typename T>
  inline void* asio_handler_allocate(std::size_t size,
      coro_handler<Handler, T>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename Handler, typename T>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      coro_handler<Handler, T>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename Handler, typename T>
  inline bool asio_handler_is_continuation(coro_handler<Handler, T>*)
  {
    return true;
  }

  template <typename Function, typename Handler, typename T>
  inline void asio_handler_invoke(Function& function,
      coro_handler<Handler, T>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename Handler, typename T>
  inline void asio_handler_invoke(const Function& function,
      coro_handler<Handler, T>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Handler, typename T>
  class coro_async_result
  {
  public:
    typedef coro_handler<Handler, T> completion_handler_type;
    typedef T return_type;

    explicit coro_async_result(completion_handler_type& h)
      : handler_(h),
        ca_(h.ca_),
        ready_(2)
    {
      h.ready_ = &ready_;
      out_ec_ = h.ec_;
      if (!out_ec_) h.ec_ = &ec_;
      h.value_ = &value_;
    }

    return_type get()
    {

      handler_.coro_.reset();

      if (--ready_ != 0)
        ca_();
      if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
      return static_cast<return_type&&>(value_);
    }

  private:
    completion_handler_type& handler_;
    typename basic_yield_context<Handler>::caller_type& ca_;
    atomic_count ready_;
    boost::system::error_code* out_ec_;
    boost::system::error_code ec_;
    return_type value_;
  };

  template <typename Handler>
  class coro_async_result<Handler, void>
  {
  public:
    typedef coro_handler<Handler, void> completion_handler_type;
    typedef void return_type;

    explicit coro_async_result(completion_handler_type& h)
      : handler_(h),
        ca_(h.ca_),
        ready_(2)
    {
      h.ready_ = &ready_;
      out_ec_ = h.ec_;
      if (!out_ec_) h.ec_ = &ec_;
    }

    void get()
    {

      handler_.coro_.reset();

      if (--ready_ != 0)
        ca_();
      if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
    }

  private:
    completion_handler_type& handler_;
    typename basic_yield_context<Handler>::caller_type& ca_;
    atomic_count ready_;
    boost::system::error_code* out_ec_;
    boost::system::error_code ec_;
  };

}



template <typename Handler, typename ReturnType>
class async_result<basic_yield_context<Handler>, ReturnType()>
  : public detail::coro_async_result<Handler, void>
{
public:
  explicit async_result(
    typename detail::coro_async_result<Handler,
      void>::completion_handler_type& h)
    : detail::coro_async_result<Handler, void>(h)
  {
  }
};

template <typename Handler, typename ReturnType, typename Arg1>
class async_result<basic_yield_context<Handler>, ReturnType(Arg1)>
  : public detail::coro_async_result<Handler, typename decay<Arg1>::type>
{
public:
  explicit async_result(
    typename detail::coro_async_result<Handler,
      typename decay<Arg1>::type>::completion_handler_type& h)
    : detail::coro_async_result<Handler, typename decay<Arg1>::type>(h)
  {
  }
};

template <typename Handler, typename ReturnType>
class async_result<basic_yield_context<Handler>,
    ReturnType(boost::system::error_code)>
  : public detail::coro_async_result<Handler, void>
{
public:
  explicit async_result(
    typename detail::coro_async_result<Handler,
      void>::completion_handler_type& h)
    : detail::coro_async_result<Handler, void>(h)
  {
  }
};

template <typename Handler, typename ReturnType, typename Arg2>
class async_result<basic_yield_context<Handler>,
    ReturnType(boost::system::error_code, Arg2)>
  : public detail::coro_async_result<Handler, typename decay<Arg2>::type>
{
public:
  explicit async_result(
    typename detail::coro_async_result<Handler,
      typename decay<Arg2>::type>::completion_handler_type& h)
    : detail::coro_async_result<Handler, typename decay<Arg2>::type>(h)
  {
  }
};



template <typename Handler, typename ReturnType>
struct handler_type<basic_yield_context<Handler>, ReturnType()>
{
  typedef detail::coro_handler<Handler, void> type;
};

template <typename Handler, typename ReturnType, typename Arg1>
struct handler_type<basic_yield_context<Handler>, ReturnType(Arg1)>
{
  typedef detail::coro_handler<Handler, typename decay<Arg1>::type> type;
};

template <typename Handler, typename ReturnType>
struct handler_type<basic_yield_context<Handler>,
    ReturnType(boost::system::error_code)>
{
  typedef detail::coro_handler<Handler, void> type;
};

template <typename Handler, typename ReturnType, typename Arg2>
struct handler_type<basic_yield_context<Handler>,
    ReturnType(boost::system::error_code, Arg2)>
{
  typedef detail::coro_handler<Handler, typename decay<Arg2>::type> type;
};

template <typename Handler, typename T>
class async_result<detail::coro_handler<Handler, T> >
  : public detail::coro_async_result<Handler, T>
{
public:
  typedef typename detail::coro_async_result<Handler, T>::return_type type;

  explicit async_result(
    typename detail::coro_async_result<Handler,
      T>::completion_handler_type& h)
    : detail::coro_async_result<Handler, T>(h)
  {
  }
};



template <typename Handler, typename T, typename Allocator>
struct associated_allocator<detail::coro_handler<Handler, T>, Allocator>
{
  typedef typename associated_allocator<Handler, Allocator>::type type;

  static type get(const detail::coro_handler<Handler, T>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<Handler, Allocator>::get(h.handler_, a);
  }
};

template <typename Handler, typename T, typename Executor>
struct associated_executor<detail::coro_handler<Handler, T>, Executor>
{
  typedef typename associated_executor<Handler, Executor>::type type;

  static type get(const detail::coro_handler<Handler, T>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<Handler, Executor>::get(h.handler_, ex);
  }
};

namespace detail {

  template <typename Handler, typename Function>
  struct spawn_data : private noncopyable
  {
    template <typename Hand, typename Func>
    spawn_data(Hand&& handler,
        bool call_handler, Func&& function)
      : handler_(static_cast<Hand&&>(handler)),
        call_handler_(call_handler),
        function_(static_cast<Func&&>(function))
    {
    }

    weak_ptr<typename basic_yield_context<Handler>::callee_type> coro_;
    Handler handler_;
    bool call_handler_;
    Function function_;
  };

  template <typename Handler, typename Function>
  struct coro_entry_point
  {
    void operator()(typename basic_yield_context<Handler>::caller_type& ca)
    {
      shared_ptr<spawn_data<Handler, Function> > data(data_);



      const basic_yield_context<Handler> yield(
          data->coro_, ca, data->handler_);

      (data->function_)(yield);
      if (data->call_handler_)
        (data->handler_)();
    }

    shared_ptr<spawn_data<Handler, Function> > data_;
  };

  template <typename Handler, typename Function>
  struct spawn_helper
  {
    void operator()()
    {
      typedef typename basic_yield_context<Handler>::callee_type callee_type;
      coro_entry_point<Handler, Function> entry_point = { data_ };
      shared_ptr<callee_type> coro(new callee_type(entry_point, attributes_));
      data_->coro_ = coro;
      (*coro)();
    }

    shared_ptr<spawn_data<Handler, Function> > data_;
    boost::coroutines::attributes attributes_;
  };

  template <typename Function, typename Handler, typename Function1>
  inline void asio_handler_invoke(Function& function,
      spawn_helper<Handler, Function1>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->data_->handler_);
  }

  template <typename Function, typename Handler, typename Function1>
  inline void asio_handler_invoke(const Function& function,
      spawn_helper<Handler, Function1>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->data_->handler_);
  }

  inline void default_spawn_handler() {}

}

template <typename Function>
inline void spawn(Function&& function,
    const boost::coroutines::attributes& attributes)
{
  typedef typename decay<Function>::type function_type;

  typename associated_executor<function_type>::type ex(
      (get_associated_executor)(function));

  boost::asio::spawn(ex, static_cast<Function&&>(function), attributes);
}

template <typename Handler, typename Function>
void spawn(Handler&& handler,
    Function&& function,
    const boost::coroutines::attributes& attributes,
    typename enable_if<!is_executor<typename decay<Handler>::type>::value &&
      !is_convertible<Handler&, execution_context&>::value>::type*)
{
  typedef typename decay<Handler>::type handler_type;
  typedef typename decay<Function>::type function_type;

  typename associated_executor<handler_type>::type ex(
      (get_associated_executor)(handler));

  typename associated_allocator<handler_type>::type a(
      (get_associated_allocator)(handler));

  detail::spawn_helper<handler_type, function_type> helper;
  helper.data_.reset(
      new detail::spawn_data<handler_type, function_type>(
        static_cast<Handler&&>(handler), true,
        static_cast<Function&&>(function)));
  helper.attributes_ = attributes;

  ex.dispatch(helper, a);
}

template <typename Handler, typename Function>
void spawn(basic_yield_context<Handler> ctx,
    Function&& function,
    const boost::coroutines::attributes& attributes)
{
  typedef typename decay<Function>::type function_type;

  Handler handler(ctx.handler_);

  typename associated_executor<Handler>::type ex(
      (get_associated_executor)(handler));

  typename associated_allocator<Handler>::type a(
      (get_associated_allocator)(handler));

  detail::spawn_helper<Handler, function_type> helper;
  helper.data_.reset(
      new detail::spawn_data<Handler, function_type>(
        static_cast<Handler&&>(handler), false,
        static_cast<Function&&>(function)));
  helper.attributes_ = attributes;

  ex.dispatch(helper, a);
}

template <typename Function, typename Executor>
inline void spawn(const Executor& ex,
    Function&& function,
    const boost::coroutines::attributes& attributes,
    typename enable_if<is_executor<Executor>::value>::type*)
{
  boost::asio::spawn(boost::asio::strand<Executor>(ex),
      static_cast<Function&&>(function), attributes);
}

template <typename Function, typename Executor>
inline void spawn(const strand<Executor>& ex,
    Function&& function,
    const boost::coroutines::attributes& attributes)
{
  boost::asio::spawn(boost::asio::bind_executor(
        ex, &detail::default_spawn_handler),
      static_cast<Function&&>(function), attributes);
}

template <typename Function>
inline void spawn(const boost::asio::io_context::strand& s,
    Function&& function,
    const boost::coroutines::attributes& attributes)
{
  boost::asio::spawn(boost::asio::bind_executor(
        s, &detail::default_spawn_handler),
      static_cast<Function&&>(function), attributes);
}

template <typename Function, typename ExecutionContext>
inline void spawn(ExecutionContext& ctx,
    Function&& function,
    const boost::coroutines::attributes& attributes,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type*)
{
  boost::asio::spawn(ctx.get_executor(),
      static_cast<Function&&>(function), attributes);
}



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 536 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/spawn.hpp" 2 3 4
# 337 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/spawn.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/async/yield_context.h" 2
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/async/yield_context.h"

# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/async/yield_context.h"
class optional_yield {
  boost::asio::io_context *c = nullptr;
  boost::asio::yield_context *y = nullptr;
 public:

  explicit optional_yield(boost::asio::io_context& c,
                          boost::asio::yield_context& y) noexcept
    : c(&c), y(&y) {}


  struct empty_t {};
  optional_yield(empty_t) noexcept {}


  operator bool() const noexcept { return y; }


  boost::asio::io_context& get_io_context() const noexcept { return *c; }


  boost::asio::yield_context& get_yield_context() const noexcept { return *y; }
};


static constexpr optional_yield::empty_t null_yield{};
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_website.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_website.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_xml.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_xml.h"
class XMLObj;
class RGWXMLParser;

class XMLObjIter {
public:
  typedef map<std::string, XMLObj *>::iterator map_iter_t;
  typedef map<std::string, XMLObj *>::iterator const_map_iter_t;

  XMLObjIter();
  ~XMLObjIter();
  void set(const XMLObjIter::const_map_iter_t &_cur, const XMLObjIter::const_map_iter_t &_end);
  XMLObj *get_next();
  bool get_name(std::string& name) const;

private:
  map_iter_t cur;
  map_iter_t end;
};







class XMLObj
{
private:
  XMLObj *parent;
  std::string obj_type;

protected:
  std::string data;
  std::multimap<std::string, XMLObj *> children;
  std::map<std::string, std::string> attr_map;


  bool xml_start(XMLObj *parent, const char *el, const char **attr);


  virtual bool xml_end(const char *el);


  virtual void xml_handle_data(const char *s, int len);

  XMLObj *get_parent();

  void add_child(const std::string& el, XMLObj *obj);

public:
  XMLObj() : parent(nullptr) {}
  virtual ~XMLObj();


  const std::string& get_data() const;

  const std::string& get_obj_type() const;
  bool get_attr(const std::string& name, std::string& attr) const;

  XMLObjIter find(const std::string& name);

  XMLObjIter find_first();

  XMLObj *find_first(const std::string& name);

  friend ostream& operator<<(ostream &out, const XMLObj &obj);
  friend RGWXMLParser;
};

struct XML_ParserStruct;
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_xml.h"
class RGWXMLParser : public XMLObj
{
private:
  XML_ParserStruct *p;
  char *buf;
  int buf_len;
  XMLObj *cur_obj;
  std::vector<XMLObj *> objs;
  std::list<XMLObj *> allocated_objs;
  std::list<XMLObj> unallocated_objs;
  bool success;
  bool init_called;



  static void call_xml_start(void* user_data, const char *el, const char **attr);


  static void call_xml_end(void* user_data, const char *el);


  static void call_xml_handle_data(void* user_data, const char *s, int len);

protected:







  virtual XMLObj *alloc_obj(const char *el) {
    return nullptr;
  }

public:
  RGWXMLParser();
  ~RGWXMLParser() override;


  bool init();



  bool parse(const char *buf, int len, int done);

  const char *get_xml() const { return buf; }
};

namespace RGWXMLDecoder {
  struct err {
    std::string message;

    explicit err(const std::string& m) : message(m) {}
  };

  typedef RGWXMLParser XMLParser;

  template<class T>
  bool decode_xml(const char *name, T& val, XMLObj* obj, bool mandatory = false);

  template<class T>
  bool decode_xml(const char *name, std::vector<T>& v, XMLObj* obj, bool mandatory = false);

  template<class C>
  bool decode_xml(const char *name, C& container, void (*cb)(C&, XMLObj *obj), XMLObj *obj, bool mandatory = false);

  template<class T>
  void decode_xml(const char *name, T& val, T& default_val, XMLObj* obj);
}

static inline ostream& operator<<(ostream &out, RGWXMLDecoder::err& err)
{
  return out << err.message;
}

template<class T>
void decode_xml_obj(T& val, XMLObj *obj)
{
  val.decode_xml(obj);
}

static inline void decode_xml_obj(string& val, XMLObj *obj)
{
  val = obj->get_data();
}

void decode_xml_obj(unsigned long long& val, XMLObj *obj);
void decode_xml_obj(long long& val, XMLObj *obj);
void decode_xml_obj(unsigned long& val, XMLObj *obj);
void decode_xml_obj(long& val, XMLObj *obj);
void decode_xml_obj(unsigned& val, XMLObj *obj);
void decode_xml_obj(int& val, XMLObj *obj);
void decode_xml_obj(bool& val, XMLObj *obj);
void decode_xml_obj(bufferlist& val, XMLObj *obj);
class utime_t;
void decode_xml_obj(utime_t& val, XMLObj *obj);

template<class T>
void do_decode_xml_obj(list<T>& l, const string& name, XMLObj *obj)
{
  l.clear();

  XMLObjIter iter = obj->find(name);
  XMLObj *o;

  while ((o = iter.get_next())) {
    T val;
    decode_xml_obj(val, o);
    l.push_back(val);
  }
}

template<class T>
bool RGWXMLDecoder::decode_xml(const char *name, T& val, XMLObj *obj, bool mandatory)
{
  XMLObjIter iter = obj->find(name);
  XMLObj *o = iter.get_next();
  if (!o) {
    if (mandatory) {
      string s = "missing mandatory field " + string(name);
      throw err(s);
    }
    val = T();
    return false;
  }

  try {
    decode_xml_obj(val, o);
  } catch (err& e) {
    string s = string(name) + ": ";
    s.append(e.message);
    throw err(s);
  }

  return true;
}

template<class T>
bool RGWXMLDecoder::decode_xml(const char *name, std::vector<T>& v, XMLObj *obj, bool mandatory)
{
  XMLObjIter iter = obj->find(name);
  XMLObj *o = iter.get_next();

  v.clear();

  if (!o) {
    if (mandatory) {
      string s = "missing mandatory field " + string(name);
      throw err(s);
    }
    return false;
  }

  do {
    T val;
    try {
      decode_xml_obj(val, o);
    } catch (err& e) {
      string s = string(name) + ": ";
      s.append(e.message);
      throw err(s);
    }
    v.push_back(val);
  } while ((o = iter.get_next()));
  return true;
}

template<class C>
bool RGWXMLDecoder::decode_xml(const char *name, C& container, void (*cb)(C&, XMLObj *), XMLObj *obj, bool mandatory)
{
  container.clear();

  XMLObjIter iter = obj->find(name);
  XMLObj *o = iter.get_next();
  if (!o) {
    if (mandatory) {
      string s = "missing mandatory field " + string(name);
      throw err(s);
    }
    return false;
  }

  try {
    decode_xml_obj(container, cb, o);
  } catch (err& e) {
    string s = string(name) + ": ";
    s.append(e.message);
    throw err(s);
  }

  return true;
}

template<class T>
void RGWXMLDecoder::decode_xml(const char *name, T& val, T& default_val, XMLObj *obj)
{
  XMLObjIter iter = obj->find(name);
  XMLObj *o = iter.get_next();
  if (!o) {
    val = default_val;
    return;
  }

  try {
    decode_xml_obj(val, o);
  } catch (err& e) {
    val = default_val;
    string s = string(name) + ": ";
    s.append(e.message);
    throw err(s);
  }
}

template<class T>
static void encode_xml(const char *name, const T& val, ceph::Formatter *f)
{
  f->open_object_section(name);
  val.dump_xml(f);
  f->close_section();
}

template<class T>
static void encode_xml(const char *name, const char *ns, const T& val, ceph::Formatter *f)
{
  f->open_object_section_in_ns(name, ns);
  val.dump_xml(f);
  f->close_section();
}

void encode_xml(const char *name, const string& val, ceph::Formatter *f);
void encode_xml(const char *name, const char *val, ceph::Formatter *f);
void encode_xml(const char *name, bool val, ceph::Formatter *f);
void encode_xml(const char *name, int val, ceph::Formatter *f);
void encode_xml(const char *name, unsigned val, ceph::Formatter *f);
void encode_xml(const char *name, long val, ceph::Formatter *f);
void encode_xml(const char *name, unsigned long val, ceph::Formatter *f);
void encode_xml(const char *name, long long val, ceph::Formatter *f);
void encode_xml(const char *name, const utime_t& val, ceph::Formatter *f);
void encode_xml(const char *name, const bufferlist& bl, ceph::Formatter *f);
void encode_xml(const char *name, long long unsigned val, ceph::Formatter *f);

template<class T>
static void do_encode_xml(const char *name, const std::list<T>& l, const char *entry_name, ceph::Formatter *f)
{
  f->open_array_section(name);
  for (typename std::list<T>::const_iterator iter = l.begin(); iter != l.end(); ++iter) {
    encode_xml(entry_name, *iter, f);
  }
  f->close_section();
}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_website.h" 2

struct RGWRedirectInfo
{
  std::string protocol;
  std::string hostname;
  uint16_t http_redirect_code = 0;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(protocol, bl);
    encode(hostname, bl);
    encode(http_redirect_code, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(protocol, bl);
    decode(hostname, bl);
    decode(http_redirect_code, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const RGWRedirectInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWRedirectInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }


struct RGWBWRedirectInfo
{
  RGWRedirectInfo redirect;
  std::string replace_key_prefix_with;
  std::string replace_key_with;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(redirect, bl);
    encode(replace_key_prefix_with, bl);
    encode(replace_key_with, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(redirect, bl);
    decode(replace_key_prefix_with, bl);
    decode(replace_key_with, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void dump_xml(Formatter *f) const;
  void decode_json(JSONObj *obj);
  void decode_xml(XMLObj *obj);
};
inline void encode(const RGWBWRedirectInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBWRedirectInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWBWRoutingRuleCondition
{
  std::string key_prefix_equals;
  uint16_t http_error_code_returned_equals = 0;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key_prefix_equals, bl);
    encode(http_error_code_returned_equals, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(key_prefix_equals, bl);
    decode(http_error_code_returned_equals, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void dump_xml(Formatter *f) const;
  void decode_json(JSONObj *obj);
  void decode_xml(XMLObj *obj);

  bool check_key_condition(const std::string& key);
  bool check_error_code_condition(const int error_code) {
    return (uint16_t)error_code == http_error_code_returned_equals;
  }
};
inline void encode(const RGWBWRoutingRuleCondition &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBWRoutingRuleCondition &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWBWRoutingRule
{
  RGWBWRoutingRuleCondition condition;
  RGWBWRedirectInfo redirect_info;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(condition, bl);
    encode(redirect_info, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(condition, bl);
    decode(redirect_info, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void dump_xml(Formatter *f) const;
  void decode_json(JSONObj *obj);
  void decode_xml(XMLObj *obj);

  bool check_key_condition(const std::string& key) {
    return condition.check_key_condition(key);
  }
  bool check_error_code_condition(int error_code) {
    return condition.check_error_code_condition(error_code);
  }

  void apply_rule(const std::string& default_protocol,
                  const std::string& default_hostname,
                  const std::string& key,
                  std::string *redirect,
                  int *redirect_code);
};
inline void encode(const RGWBWRoutingRule &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBWRoutingRule &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWBWRoutingRules
{
  std::list<RGWBWRoutingRule> rules;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(rules, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(rules, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void dump_xml(Formatter *f) const;
  void decode_json(JSONObj *obj);

  bool check_key_condition(const std::string& key, RGWBWRoutingRule **rule);
  bool check_error_code_condition(int error_code, RGWBWRoutingRule **rule);
  bool check_key_and_error_code_condition(const std::string& key,
                                          const int error_code,
                                          RGWBWRoutingRule **rule);
};
inline void encode(const RGWBWRoutingRules &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBWRoutingRules &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWBucketWebsiteConf
{
  RGWRedirectInfo redirect_all;
  std::string index_doc_suffix;
  std::string error_doc;
  std::string subdir_marker;
  std::string listing_css_doc;
  bool listing_enabled;
  bool is_redirect_all;
  bool is_set_index_doc;
  RGWBWRoutingRules routing_rules;

  RGWBucketWebsiteConf()
    : listing_enabled(false) {
    is_redirect_all = false;
    is_set_index_doc = false;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(index_doc_suffix, bl);
    encode(error_doc, bl);
    encode(routing_rules, bl);
    encode(redirect_all, bl);
    encode(subdir_marker, bl);
    encode(listing_css_doc, bl);
    encode(listing_enabled, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(index_doc_suffix, bl);
    decode(error_doc, bl);
    decode(routing_rules, bl);
    decode(redirect_all, bl);
    if (struct_v >= 2) {
      decode(subdir_marker, bl);
      decode(listing_css_doc, bl);
      decode(listing_enabled, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;

  bool should_redirect(const std::string& key,
                       const int http_error_code,
                       RGWBWRoutingRule *redirect);

  bool get_effective_key(const std::string& key,
                         std::string *effective_key, bool is_file) const;

  const std::string& get_index_doc() const {
    return index_doc_suffix;
  }

  bool is_empty() const {
    return index_doc_suffix.empty() &&
           error_doc.empty() &&
           subdir_marker.empty() &&
           listing_css_doc.empty() &&
           ! listing_enabled;
  }
};
inline void encode(const RGWBucketWebsiteConf &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBucketWebsiteConf &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_object_lock.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_object_lock.h"
class DefaultRetention
{
protected:
  string mode;
  int days;
  int years;

public:
  DefaultRetention(): days(0), years(0) {};

  int get_days() const {
    return days;
  }

  int get_years() const {
    return years;
  }

  string get_mode() const {
    return mode;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(mode, bl);
    encode(days, bl);
    encode(years, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(mode, bl);
    decode(days, bl);
    decode(years, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
};
inline void encode(const DefaultRetention &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(DefaultRetention &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class ObjectLockRule
{
protected:
  DefaultRetention defaultRetention;
public:
  int get_days() const {
    return defaultRetention.get_days();
  }

  int get_years() const {
    return defaultRetention.get_years();
  }

  string get_mode() const {
    return defaultRetention.get_mode();
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(defaultRetention, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(defaultRetention, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
};
inline void encode(const ObjectLockRule &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(ObjectLockRule &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWObjectLock
{
protected:
  bool enabled;
  bool rule_exist;
  ObjectLockRule rule;

public:
  RGWObjectLock():enabled(true), rule_exist(false) {}

  int get_days() const {
    return rule.get_days();
  }

  int get_years() const {
    return rule.get_years();
  }

  string get_mode() const {
    return rule.get_mode();
  }

  bool retention_period_valid() const {



    return (get_years() > 0) != (get_days() > 0);
  }

  bool has_rule() const {
    return rule_exist;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(enabled, bl);
    encode(rule_exist, bl);
    if (rule_exist) {
      encode(rule, bl);
    }
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(enabled, bl);
    decode(rule_exist, bl);
    if (rule_exist) {
      decode(rule, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
  ceph::real_time get_lock_until_date(const ceph::real_time& mtime) const;
};
inline void encode(const RGWObjectLock &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWObjectLock &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWObjectRetention
{
protected:
  string mode;
  ceph::real_time retain_until_date;
public:
  RGWObjectRetention() {}
  RGWObjectRetention(string _mode, ceph::real_time _date): mode(_mode), retain_until_date(_date) {}

  void set_mode(string _mode) {
    mode = _mode;
  }

  string get_mode() const {
    return mode;
  }

  void set_retain_until_date(ceph::real_time _retain_until_date) {
    retain_until_date = _retain_until_date;
  }

  ceph::real_time get_retain_until_date() const {
    return retain_until_date;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(mode, bl);
    encode(retain_until_date, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(mode, bl);
    decode(retain_until_date, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
};
inline void encode(const RGWObjectRetention &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWObjectRetention &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWObjectLegalHold
{
protected:
  string status;
public:
  RGWObjectLegalHold() {}
  RGWObjectLegalHold(string _status): status(_status) {}
  void set_status(string _status) {
    status = _status;
  }

  string get_status() const {
    return status;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(status, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(status, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
  bool is_enabled() const;
};
inline void encode(const RGWObjectLegalHold &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWObjectLegalHold &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/version/cls_version_types.h" 1






class JSONObj;


struct obj_version {
  uint64_t ver;
  string tag;

  obj_version() : ver(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(ver, bl);
    encode(tag, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(ver, bl);
    decode(tag, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void inc() {
    ver++;
  }

  void clear() {
    ver = 0;
    tag.clear();
  }

  bool empty() {
    return tag.empty();
  }

  bool compare(struct obj_version *v) {
    return (ver == v->ver &&
            tag.compare(v->tag) == 0);
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const obj_version &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(obj_version &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

enum VersionCond {
  VER_COND_NONE = 0,
  VER_COND_EQ,
  VER_COND_GT,
  VER_COND_GE,
  VER_COND_LT,
  VER_COND_LE,
  VER_COND_TAG_EQ,
  VER_COND_TAG_NE,
};

struct obj_version_cond {
  struct obj_version ver;
  VersionCond cond;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(ver, bl);
    uint32_t c = (uint32_t)cond;
    encode(c, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(ver, bl);
    uint32_t c;
    decode(c, bl);
    cond = (VersionCond)c;
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

};
inline void encode(const obj_version_cond &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(obj_version_cond &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/user/cls_user_types.h" 1
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/user/cls_user_types.h"
struct cls_user_bucket {
  std::string name;
  std::string marker;
  std::string bucket_id;
  std::string placement_id;
  struct {
    std::string data_pool;
    std::string index_pool;
    std::string data_extra_pool;
  } explicit_placement;

  void encode(bufferlist& bl) const {





    if (!placement_id.empty()) {
      __u8 struct_v = 9; __u8 struct_compat = 8; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
      encode(name, bl);
      encode(marker, bl);
      encode(bucket_id, bl);
      encode(placement_id, bl);
      } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
    } else {
      __u8 struct_v = 7; __u8 struct_compat = 3; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
      encode(name, bl);
      encode(explicit_placement.data_pool, bl);
      encode(marker, bl);
      encode(bucket_id, bl);
      encode(explicit_placement.index_pool, bl);
      encode(explicit_placement.data_extra_pool, bl);
      } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
    }
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (8 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "8" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(name, bl);
    if (struct_v < 8) {
      decode(explicit_placement.data_pool, bl);
    }
    if (struct_v >= 2) {
      decode(marker, bl);
      if (struct_v <= 3) {
        uint64_t id;
        decode(id, bl);
        char buf[16];
        snprintf(buf, sizeof(buf), "%llu", (long long)id);
        bucket_id = buf;
      } else {
        decode(bucket_id, bl);
      }
    }
    if (struct_v < 8) {
      if (struct_v >= 5) {
        decode(explicit_placement.index_pool, bl);
      } else {
        explicit_placement.index_pool = explicit_placement.data_pool;
      }
      if (struct_v >= 7) {
        decode(explicit_placement.data_extra_pool, bl);
      }
    } else {
      decode(placement_id, bl);
      if (struct_v == 8 && placement_id.empty()) {
        decode(explicit_placement.data_pool, bl);
        decode(explicit_placement.index_pool, bl);
        decode(explicit_placement.data_extra_pool, bl);
      }
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  bool operator<(const cls_user_bucket& b) const {
    return name.compare(b.name) < 0;
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_user_bucket*>& ls);
};
inline void encode(const cls_user_bucket &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_user_bucket &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }




struct cls_user_bucket_entry {
  cls_user_bucket bucket;
  size_t size;
  size_t size_rounded;
  ceph::real_time creation_time;
  uint64_t count;
  bool user_stats_sync;

  cls_user_bucket_entry() : size(0), size_rounded(0), count(0), user_stats_sync(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 9; __u8 struct_compat = 5; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    uint64_t s = size;
    __u32 mt = ceph::real_clock::to_time_t(creation_time);
    string empty_str;
    encode(empty_str, bl);
    encode(s, bl);
    encode(mt, bl);
    encode(count, bl);
    encode(bucket, bl);
    s = size_rounded;
    encode(s, bl);
    encode(user_stats_sync, bl);
    encode(creation_time, bl);

    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 5) { __u8 struct_compat; decode(struct_compat, bl); if (9 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "9" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 5) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    __u32 mt;
    uint64_t s;
    string empty_str;
    decode(empty_str, bl);
    decode(s, bl);
    decode(mt, bl);
    size = s;
    if (struct_v < 7) {
      creation_time = ceph::real_clock::from_time_t(mt);
    }
    if (struct_v >= 2)
      decode(count, bl);
    if (struct_v >= 3)
      decode(bucket, bl);
    if (struct_v >= 4)
      decode(s, bl);
    size_rounded = s;
    if (struct_v >= 6)
      decode(user_stats_sync, bl);
    if (struct_v >= 7)
      decode(creation_time, bl);
    if (struct_v == 8) {
      std::string placement_rule;
      decode(placement_rule, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_user_bucket_entry*>& ls);
};
inline void encode(const cls_user_bucket_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_user_bucket_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_user_stats {
  uint64_t total_entries;
  uint64_t total_bytes;
  uint64_t total_bytes_rounded;

  cls_user_stats()
    : total_entries(0),
      total_bytes(0),
      total_bytes_rounded(0) {}

  void encode(bufferlist& bl) const {
     __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(total_entries, bl);
    encode(total_bytes, bl);
    encode(total_bytes_rounded, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(total_entries, bl);
    decode(total_bytes, bl);
    decode(total_bytes_rounded, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_user_stats*>& ls);
};
inline void encode(const cls_user_stats &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_user_stats &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }




struct cls_user_header {
  cls_user_stats stats;
  ceph::real_time last_stats_sync;
  ceph::real_time last_stats_update;

  void encode(bufferlist& bl) const {
     __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(stats, bl);
    encode(last_stats_sync, bl);
    encode(last_stats_update, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(stats, bl);
    decode(last_stats_sync, bl);
    decode(last_stats_update, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_user_header*>& ls);
};
inline void encode(const cls_user_header &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_user_header &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

void cls_user_gen_test_bucket(cls_user_bucket *bucket, int i);
void cls_user_gen_test_bucket_entry(cls_user_bucket_entry *entry, int i);
void cls_user_gen_test_stats(cls_user_stats *stats);
void cls_user_gen_test_header(cls_user_header *h);
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_types.h" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_types.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_basic_types.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_types.h" 2







class JSONObj;

namespace ceph {
  class Formatter;
}
using ceph::operator <<;

using rgw_zone_set = std::set<std::string>;

enum RGWPendingState {
  CLS_RGW_STATE_PENDING_MODIFY = 0,
  CLS_RGW_STATE_COMPLETE = 1,
  CLS_RGW_STATE_UNKNOWN = 2,
};

enum RGWModifyOp {
  CLS_RGW_OP_ADD = 0,
  CLS_RGW_OP_DEL = 1,
  CLS_RGW_OP_CANCEL = 2,
  CLS_RGW_OP_UNKNOWN = 3,
  CLS_RGW_OP_LINK_OLH = 4,
  CLS_RGW_OP_LINK_OLH_DM = 5,
  CLS_RGW_OP_UNLINK_INSTANCE = 6,
  CLS_RGW_OP_SYNCSTOP = 7,
  CLS_RGW_OP_RESYNC = 8,
};

enum RGWBILogFlags {
  RGW_BILOG_FLAG_VERSIONED_OP = 0x1,
};

enum RGWCheckMTimeType {
  CLS_RGW_CHECK_TIME_MTIME_EQ = 0,
  CLS_RGW_CHECK_TIME_MTIME_LT = 1,
  CLS_RGW_CHECK_TIME_MTIME_LE = 2,
  CLS_RGW_CHECK_TIME_MTIME_GT = 3,
  CLS_RGW_CHECK_TIME_MTIME_GE = 4,
};



static inline uint64_t cls_rgw_get_rounded_size(uint64_t size)
{
  return (size + 4096 - 1) & ~(4096 - 1);
}

struct rgw_bucket_pending_info {
  RGWPendingState state;
  ceph::real_time timestamp;
  uint8_t op;

  rgw_bucket_pending_info() : state(CLS_RGW_STATE_PENDING_MODIFY), op(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    uint8_t s = (uint8_t)state;
    encode(s, bl);
    encode(timestamp, bl);
    encode(op, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    uint8_t s;
    decode(s, bl);
    state = (RGWPendingState)s;
    decode(timestamp, bl);
    decode(op, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<rgw_bucket_pending_info*>& o);
};
inline void encode(const rgw_bucket_pending_info &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_pending_info &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }





enum class RGWObjCategory : uint8_t {
  None = 0,



  Main = 1,

  Shadow = 2,


  MultiMeta = 3,
};


struct rgw_bucket_dir_entry_meta {
  RGWObjCategory category;
  uint64_t size;
  ceph::real_time mtime;
  string etag;
  string owner;
  string owner_display_name;
  string content_type;
  uint64_t accounted_size;
  string user_data;
  string storage_class;
  bool appendable;

  rgw_bucket_dir_entry_meta() :
    category(RGWObjCategory::None), size(0), accounted_size(0), appendable(false) { }

  void encode(bufferlist &bl) const {
    __u8 struct_v = 7; __u8 struct_compat = 3; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(category, bl);
    encode(size, bl);
    encode(mtime, bl);
    encode(etag, bl);
    encode(owner, bl);
    encode(owner_display_name, bl);
    encode(content_type, bl);
    encode(accounted_size, bl);
    encode(user_data, bl);
    encode(storage_class, bl);
    encode(appendable, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (6 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "6" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(category, bl);
    decode(size, bl);
    decode(mtime, bl);
    decode(etag, bl);
    decode(owner, bl);
    decode(owner_display_name, bl);
    if (struct_v >= 2)
      decode(content_type, bl);
    if (struct_v >= 4)
      decode(accounted_size, bl);
    else
      accounted_size = size;
    if (struct_v >= 5)
      decode(user_data, bl);
    if (struct_v >= 6)
      decode(storage_class, bl);
    if (struct_v >= 7)
      decode(appendable, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<rgw_bucket_dir_entry_meta*>& o);
};
inline void encode(const rgw_bucket_dir_entry_meta &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_dir_entry_meta &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

template<class T>
void encode_packed_val(T val, bufferlist& bl)
{
  using ceph::encode;
  if ((uint64_t)val < 0x80) {
    encode((uint8_t)val, bl);
  } else {
    unsigned char c = 0x80;

    if ((uint64_t)val < 0x100) {
      c |= 1;
      encode(c, bl);
      encode((uint8_t)val, bl);
    } else if ((uint64_t)val <= 0x10000) {
      c |= 2;
      encode(c, bl);
      encode((uint16_t)val, bl);
    } else if ((uint64_t)val <= 0x1000000) {
      c |= 4;
      encode(c, bl);
      encode((uint32_t)val, bl);
    } else {
      c |= 8;
      encode(c, bl);
      encode((uint64_t)val, bl);
    }
  }
}

template<class T>
void decode_packed_val(T& val, bufferlist::const_iterator& bl)
{
  using ceph::decode;
  unsigned char c;
  decode(c, bl);
  if (c < 0x80) {
    val = c;
    return;
  }

  c &= ~0x80;

  switch (c) {
    case 1:
      {
        uint8_t v;
        decode(v, bl);
        val = v;
      }
      break;
    case 2:
      {
        uint16_t v;
        decode(v, bl);
        val = v;
      }
      break;
    case 4:
      {
        uint32_t v;
        decode(v, bl);
        val = v;
      }
      break;
    case 8:
      {
        uint64_t v;
        decode(v, bl);
        val = v;
      }
      break;
    default:
      throw buffer::error();
  }
}

struct rgw_bucket_entry_ver {
  int64_t pool;
  uint64_t epoch;

  rgw_bucket_entry_ver() : pool(-1), epoch(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode_packed_val(pool, bl);
    encode_packed_val(epoch, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode_packed_val(pool, bl);
    decode_packed_val(epoch, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<rgw_bucket_entry_ver*>& o);
};
inline void encode(const rgw_bucket_entry_ver &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_entry_ver &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_obj_key {
  string name;
  string instance;

  cls_rgw_obj_key() {}
  cls_rgw_obj_key(const string &_name) : name(_name) {}
  cls_rgw_obj_key(const string& n, const string& i) : name(n), instance(i) {}

  void set(const string& _name) {
    name = _name;
  }

  bool operator==(const cls_rgw_obj_key& k) const {
    return (name.compare(k.name) == 0) &&
           (instance.compare(k.instance) == 0);
  }
  bool operator<(const cls_rgw_obj_key& k) const {
    int r = name.compare(k.name);
    if (r == 0) {
      r = instance.compare(k.instance);
    }
    return (r < 0);
  }
  bool operator<=(const cls_rgw_obj_key& k) const {
    return !(k < *this);
  }
  bool empty() const {
    return name.empty();
  }
  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(name, bl);
    encode(instance, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(name, bl);
    decode(instance, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const {
    f->dump_string("name", name);
    f->dump_string("instance", instance);
  }
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<cls_rgw_obj_key*>& ls) {
    ls.push_back(new cls_rgw_obj_key);
    ls.push_back(new cls_rgw_obj_key);
    ls.back()->name = "name";
    ls.back()->instance = "instance";
  }
};
inline void encode(const cls_rgw_obj_key &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_obj_key &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }







struct rgw_bucket_dir_entry {
  cls_rgw_obj_key key;
  rgw_bucket_entry_ver ver;
  std::string locator;
  bool exists;
  rgw_bucket_dir_entry_meta meta;
  multimap<string, rgw_bucket_pending_info> pending_map;
  uint64_t index_ver;
  string tag;
  uint16_t flags;
  uint64_t versioned_epoch;

  rgw_bucket_dir_entry() :
    exists(false), index_ver(0), flags(0), versioned_epoch(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 8; __u8 struct_compat = 3; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key.name, bl);
    encode(ver.epoch, bl);
    encode(exists, bl);
    encode(meta, bl);
    encode(pending_map, bl);
    encode(locator, bl);
    encode(ver, bl);
    encode_packed_val(index_ver, bl);
    encode(tag, bl);
    encode(key.instance, bl);
    encode(flags, bl);
    encode(versioned_epoch, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (8 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "8" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(key.name, bl);
    decode(ver.epoch, bl);
    decode(exists, bl);
    decode(meta, bl);
    decode(pending_map, bl);
    if (struct_v >= 2) {
      decode(locator, bl);
    }
    if (struct_v >= 4) {
      decode(ver, bl);
    } else {
      ver.pool = -1;
    }
    if (struct_v >= 5) {
      decode_packed_val(index_ver, bl);
      decode(tag, bl);
    }
    if (struct_v >= 6) {
      decode(key.instance, bl);
    }
    if (struct_v >= 7) {
      decode(flags, bl);
    }
    if (struct_v >= 8) {
      decode(versioned_epoch, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  bool is_current() {
    int test_flags = 0x1 | 0x2;
    return (flags & 0x1) == 0 ||
           (flags & test_flags) == test_flags;
  }
  bool is_delete_marker() { return (flags & 0x4) != 0; }
  bool is_visible() {
    return is_current() && !is_delete_marker();
  }
  bool is_valid() { return (flags & 0x8) == 0; }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<rgw_bucket_dir_entry*>& o);
};
inline void encode(const rgw_bucket_dir_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_dir_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

enum class BIIndexType : uint8_t {
  Invalid = 0,
  Plain = 1,
  Instance = 2,
  OLH = 3,
};

struct rgw_bucket_category_stats;

struct rgw_cls_bi_entry {
  BIIndexType type;
  string idx;
  bufferlist data;

  rgw_cls_bi_entry() : type(BIIndexType::Invalid) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(type, bl);
    encode(idx, bl);
    encode(data, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    uint8_t c;
    decode(c, bl);
    type = (BIIndexType)c;
    decode(idx, bl);
    decode(data, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj, cls_rgw_obj_key *effective_key = 
# 447 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_types.h" 3 4
                                                                 __null
# 447 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_types.h"
                                                                     );

  bool get_info(cls_rgw_obj_key *key, RGWObjCategory *category,
  rgw_bucket_category_stats *accounted_stats);
};
inline void encode(const rgw_cls_bi_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bi_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

enum OLHLogOp {
  CLS_RGW_OLH_OP_UNKNOWN = 0,
  CLS_RGW_OLH_OP_LINK_OLH = 1,
  CLS_RGW_OLH_OP_UNLINK_OLH = 2,
  CLS_RGW_OLH_OP_REMOVE_INSTANCE = 3,
};

struct rgw_bucket_olh_log_entry {
  uint64_t epoch;
  OLHLogOp op;
  string op_tag;
  cls_rgw_obj_key key;
  bool delete_marker;

  rgw_bucket_olh_log_entry() : epoch(0), op(CLS_RGW_OLH_OP_UNKNOWN), delete_marker(false) {}


  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(epoch, bl);
    encode((__u8)op, bl);
    encode(op_tag, bl);
    encode(key, bl);
    encode(delete_marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(epoch, bl);
    uint8_t c;
    decode(c, bl);
    op = (OLHLogOp)c;
    decode(op_tag, bl);
    decode(key, bl);
    decode(delete_marker, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<rgw_bucket_olh_log_entry*>& o);
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const rgw_bucket_olh_log_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_olh_log_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_bucket_olh_entry {
  cls_rgw_obj_key key;
  bool delete_marker;
  uint64_t epoch;
  map<uint64_t, vector<struct rgw_bucket_olh_log_entry> > pending_log;
  string tag;
  bool exists;
  bool pending_removal;

  rgw_bucket_olh_entry() : delete_marker(false), epoch(0), exists(false), pending_removal(false) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key, bl);
    encode(delete_marker, bl);
    encode(epoch, bl);
    encode(pending_log, bl);
    encode(tag, bl);
    encode(exists, bl);
    encode(pending_removal, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(key, bl);
    decode(delete_marker, bl);
    decode(epoch, bl);
    decode(pending_log, bl);
    decode(tag, bl);
    decode(exists, bl);
    decode(pending_removal, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const rgw_bucket_olh_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_olh_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_bi_log_entry {
  string id;
  string object;
  string instance;
  ceph::real_time timestamp;
  rgw_bucket_entry_ver ver;
  RGWModifyOp op;
  RGWPendingState state;
  uint64_t index_ver;
  string tag;
  uint16_t bilog_flags;
  string owner;
  string owner_display_name;
  rgw_zone_set zones_trace;

  rgw_bi_log_entry() : op(CLS_RGW_OP_UNKNOWN), state(CLS_RGW_STATE_PENDING_MODIFY), index_ver(0), bilog_flags(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 4; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(id, bl);
    encode(object, bl);
    encode(timestamp, bl);
    encode(ver, bl);
    encode(tag, bl);
    uint8_t c = (uint8_t)op;
    encode(c, bl);
    c = (uint8_t)state;
    encode(c, bl);
    encode_packed_val(index_ver, bl);
    encode(instance, bl);
    encode(bilog_flags, bl);
    encode(owner, bl);
    encode(owner_display_name, bl);
    encode(zones_trace, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (4 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "4" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(id, bl);
    decode(object, bl);
    decode(timestamp, bl);
    decode(ver, bl);
    decode(tag, bl);
    uint8_t c;
    decode(c, bl);
    op = (RGWModifyOp)c;
    decode(c, bl);
    state = (RGWPendingState)c;
    decode_packed_val(index_ver, bl);
    if (struct_v >= 2) {
      decode(instance, bl);
      decode(bilog_flags, bl);
    }
    if (struct_v >= 3) {
      decode(owner, bl);
      decode(owner_display_name, bl);
    }
    if (struct_v >= 4) {
      decode(zones_trace, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<rgw_bi_log_entry*>& o);

  bool is_versioned() {
    return ((bilog_flags & RGW_BILOG_FLAG_VERSIONED_OP) != 0);
  }
};
inline void encode(const rgw_bi_log_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bi_log_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_bucket_category_stats {
  uint64_t total_size;
  uint64_t total_size_rounded;
  uint64_t num_entries;
  uint64_t actual_size{0};

  rgw_bucket_category_stats() : total_size(0), total_size_rounded(0), num_entries(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(total_size, bl);
    encode(total_size_rounded, bl);
    encode(num_entries, bl);
    encode(actual_size, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (3 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "3" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(total_size, bl);
    decode(total_size_rounded, bl);
    decode(num_entries, bl);
    if (struct_v >= 3) {
      decode(actual_size, bl);
    } else {
      actual_size = total_size;
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_bucket_category_stats*>& o);
};
inline void encode(const rgw_bucket_category_stats &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_category_stats &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

enum cls_rgw_reshard_status {
  CLS_RGW_RESHARD_NOT_RESHARDING = 0,
  CLS_RGW_RESHARD_IN_PROGRESS = 1,
  CLS_RGW_RESHARD_DONE = 2,
};

static inline std::string to_string(const enum cls_rgw_reshard_status status)
{
  switch (status) {
  case CLS_RGW_RESHARD_NOT_RESHARDING:
    return "not-resharding";
    break;
  case CLS_RGW_RESHARD_IN_PROGRESS:
    return "in-progress";
    break;
  case CLS_RGW_RESHARD_DONE:
    return "done";
    break;
  default:
    break;
  };
  return "Unknown reshard status";
}

struct cls_rgw_bucket_instance_entry {
  cls_rgw_reshard_status reshard_status{CLS_RGW_RESHARD_NOT_RESHARDING};
  string new_bucket_instance_id;
  int32_t num_shards{-1};

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode((uint8_t)reshard_status, bl);
    encode(new_bucket_instance_id, bl);
    encode(num_shards, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    uint8_t s;
    decode(s, bl);
    reshard_status = (cls_rgw_reshard_status)s;
    decode(new_bucket_instance_id, bl);
    decode(num_shards, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_bucket_instance_entry*>& o);

  void clear() {
    reshard_status = CLS_RGW_RESHARD_NOT_RESHARDING;
    new_bucket_instance_id.clear();
  }

  void set_status(const string& new_instance_id, int32_t new_num_shards, cls_rgw_reshard_status s) {
    reshard_status = s;
    new_bucket_instance_id = new_instance_id;
    num_shards = new_num_shards;
  }

  bool resharding() const {
    return reshard_status != CLS_RGW_RESHARD_NOT_RESHARDING;
  }
  bool resharding_in_progress() const {
    return reshard_status == CLS_RGW_RESHARD_IN_PROGRESS;
  }
};
inline void encode(const cls_rgw_bucket_instance_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_bucket_instance_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_bucket_dir_header {
  map<RGWObjCategory, rgw_bucket_category_stats> stats;
  uint64_t tag_timeout;
  uint64_t ver;
  uint64_t master_ver;
  string max_marker;
  cls_rgw_bucket_instance_entry new_instance;
  bool syncstopped;

  rgw_bucket_dir_header() : tag_timeout(0), ver(0), master_ver(0), syncstopped(false) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 7; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(stats, bl);
    encode(tag_timeout, bl);
    encode(ver, bl);
    encode(master_ver, bl);
    encode(max_marker, bl);
    encode(new_instance, bl);
    encode(syncstopped,bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (6 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "6" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(stats, bl);
    if (struct_v > 2) {
      decode(tag_timeout, bl);
    } else {
      tag_timeout = 0;
    }
    if (struct_v >= 4) {
      decode(ver, bl);
      decode(master_ver, bl);
    } else {
      ver = 0;
    }
    if (struct_v >= 5) {
      decode(max_marker, bl);
    }
    if (struct_v >= 6) {
      decode(new_instance, bl);
    } else {
      new_instance = cls_rgw_bucket_instance_entry();
    }
    if (struct_v >= 7) {
      decode(syncstopped,bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_bucket_dir_header*>& o);

  bool resharding() const {
    return new_instance.resharding();
  }
  bool resharding_in_progress() const {
    return new_instance.resharding_in_progress();
  }
};
inline void encode(const rgw_bucket_dir_header &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_dir_header &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_bucket_dir {
  rgw_bucket_dir_header header;
  std::map<string, rgw_bucket_dir_entry> m;

  void encode(bufferlist &bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(header, bl);
    encode(m, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(header, bl);
    decode(m, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_bucket_dir*>& o);
};
inline void encode(const rgw_bucket_dir &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket_dir &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_usage_data {
  uint64_t bytes_sent;
  uint64_t bytes_received;
  uint64_t ops;
  uint64_t successful_ops;

  rgw_usage_data() : bytes_sent(0), bytes_received(0), ops(0), successful_ops(0) {}
  rgw_usage_data(uint64_t sent, uint64_t received) : bytes_sent(sent), bytes_received(received), ops(0), successful_ops(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(bytes_sent, bl);
    encode(bytes_received, bl);
    encode(ops, bl);
    encode(successful_ops, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(bytes_sent, bl);
    decode(bytes_received, bl);
    decode(ops, bl);
    decode(successful_ops, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void aggregate(const rgw_usage_data& usage) {
    bytes_sent += usage.bytes_sent;
    bytes_received += usage.bytes_received;
    ops += usage.ops;
    successful_ops += usage.successful_ops;
  }
};
inline void encode(const rgw_usage_data &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_usage_data &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }


struct rgw_usage_log_entry {
  rgw_user owner;
  rgw_user payer;
  string bucket;
  uint64_t epoch;
  rgw_usage_data total_usage;
  map<string, rgw_usage_data> usage_map;

  rgw_usage_log_entry() : epoch(0) {}
  rgw_usage_log_entry(string& o, string& b) : owner(o), bucket(b), epoch(0) {}
  rgw_usage_log_entry(string& o, string& p, string& b) : owner(o), payer(p), bucket(b), epoch(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(owner.to_str(), bl);
    encode(bucket, bl);
    encode(epoch, bl);
    encode(total_usage.bytes_sent, bl);
    encode(total_usage.bytes_received, bl);
    encode(total_usage.ops, bl);
    encode(total_usage.successful_ops, bl);
    encode(usage_map, bl);
    encode(payer.to_str(), bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }


   void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (3 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "3" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    string s;
    decode(s, bl);
    owner.from_str(s);
    decode(bucket, bl);
    decode(epoch, bl);
    decode(total_usage.bytes_sent, bl);
    decode(total_usage.bytes_received, bl);
    decode(total_usage.ops, bl);
    decode(total_usage.successful_ops, bl);
    if (struct_v < 2) {
      usage_map[""] = total_usage;
    } else {
      decode(usage_map, bl);
    }
    if (struct_v >= 3) {
      string p;
      decode(p, bl);
      payer.from_str(p);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void aggregate(const rgw_usage_log_entry& e, map<string, bool> *categories = 
# 880 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_types.h" 3 4
                                                                              __null
# 880 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_types.h"
                                                                                  ) {
    if (owner.empty()) {
      owner = e.owner;
      bucket = e.bucket;
      epoch = e.epoch;
      payer = e.payer;
    }

    map<string, rgw_usage_data>::const_iterator iter;
    for (iter = e.usage_map.begin(); iter != e.usage_map.end(); ++iter) {
      if (!categories || !categories->size() || categories->count(iter->first)) {
        add(iter->first, iter->second);
      }
    }
  }

  void sum(rgw_usage_data& usage, map<string, bool>& categories) const {
    usage = rgw_usage_data();
    for (map<string, rgw_usage_data>::const_iterator iter = usage_map.begin(); iter != usage_map.end(); ++iter) {
      if (!categories.size() || categories.count(iter->first)) {
        usage.aggregate(iter->second);
      }
    }
  }

  void add(const string& category, const rgw_usage_data& data) {
    usage_map[category].aggregate(data);
    total_usage.aggregate(data);
  }

  void dump(Formatter* f) const;
  static void generate_test_instances(list<rgw_usage_log_entry*>& o);

};
inline void encode(const rgw_usage_log_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_usage_log_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_usage_log_info {
  vector<rgw_usage_log_entry> entries;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entries, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entries, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  rgw_usage_log_info() {}
};
inline void encode(const rgw_usage_log_info &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_usage_log_info &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_user_bucket {
  string user;
  string bucket;

  rgw_user_bucket() {}
  rgw_user_bucket(const string& u, const string& b) : user(u), bucket(b) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(user, bl);
    encode(bucket, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(user, bl);
    decode(bucket, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  bool operator<(const rgw_user_bucket& ub2) const {
    int comp = user.compare(ub2.user);
    if (comp < 0)
      return true;
    else if (!comp)
      return bucket.compare(ub2.bucket) < 0;

    return false;
  }
};
inline void encode(const rgw_user_bucket &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_user_bucket &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

enum cls_rgw_gc_op {
  CLS_RGW_GC_DEL_OBJ,
  CLS_RGW_GC_DEL_BUCKET,
};

struct cls_rgw_obj {
  string pool;
  cls_rgw_obj_key key;
  string loc;

  cls_rgw_obj() {}
  cls_rgw_obj(string& _p, cls_rgw_obj_key& _k) : pool(_p), key(_k) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(pool, bl);
    encode(key.name, bl);
    encode(loc, bl);
    encode(key, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(pool, bl);
    decode(key.name, bl);
    decode(loc, bl);
    if (struct_v >= 2) {
      decode(key, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const {
    f->dump_string("pool", pool);
    f->dump_string("oid", key.name);
    f->dump_string("key", loc);
    f->dump_string("instance", key.instance);
  }
  static void generate_test_instances(list<cls_rgw_obj*>& ls) {
    ls.push_back(new cls_rgw_obj);
    ls.push_back(new cls_rgw_obj);
    ls.back()->pool = "mypool";
    ls.back()->key.name = "myoid";
    ls.back()->loc = "mykey";
  }
};
inline void encode(const cls_rgw_obj &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_obj &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_obj_chain {
  list<cls_rgw_obj> objs;

  cls_rgw_obj_chain() {}

  void push_obj(const string& pool, const cls_rgw_obj_key& key, const string& loc) {
    cls_rgw_obj obj;
    obj.pool = pool;
    obj.key = key;
    obj.loc = loc;
    objs.push_back(obj);
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(objs, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(objs, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const {
    f->open_array_section("objs");
    for (list<cls_rgw_obj>::const_iterator p = objs.begin(); p != objs.end(); ++p) {
      f->open_object_section("obj");
      p->dump(f);
      f->close_section();
    }
    f->close_section();
  }
  static void generate_test_instances(list<cls_rgw_obj_chain*>& ls) {
    ls.push_back(new cls_rgw_obj_chain);
  }

  bool empty() {
    return objs.empty();
  }
};
inline void encode(const cls_rgw_obj_chain &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_obj_chain &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_gc_obj_info
{
  string tag;
  cls_rgw_obj_chain chain;
  ceph::real_time time;

  cls_rgw_gc_obj_info() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(tag, bl);
    encode(chain, bl);
    encode(time, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(tag, bl);
    decode(chain, bl);
    decode(time, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const {
    f->dump_string("tag", tag);
    f->open_object_section("chain");
    chain.dump(f);
    f->close_section();
    f->dump_stream("time") << time;
  }
  static void generate_test_instances(list<cls_rgw_gc_obj_info*>& ls) {
    ls.push_back(new cls_rgw_gc_obj_info);
    ls.push_back(new cls_rgw_gc_obj_info);
    ls.back()->tag = "footag";
    ceph_timespec ts{init_le32(21), init_le32(32)};
    ls.back()->time = ceph::real_clock::from_ceph_timespec(ts);
  }
};
inline void encode(const cls_rgw_gc_obj_info &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_gc_obj_info &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_obj_head
{
  time_t start_date = 0;
  string marker;

  cls_rgw_lc_obj_head() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    uint64_t t = start_date;
    encode(t, bl);
    encode(marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    uint64_t t;
    decode(t, bl);
    start_date = static_cast<time_t>(t);
    decode(marker, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_lc_obj_head*>& ls);
};
inline void encode(const cls_rgw_lc_obj_head &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_obj_head &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_reshard_entry
{
  ceph::real_time time;
  string tenant;
  string bucket_name;
  string bucket_id;
  string new_instance_id;
  uint32_t old_num_shards{0};
  uint32_t new_num_shards{0};

  cls_rgw_reshard_entry() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(time, bl);
    encode(tenant, bl);
    encode(bucket_name, bl);
    encode(bucket_id, bl);
    encode(new_instance_id, bl);
    encode(old_num_shards, bl);
    encode(new_num_shards, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(time, bl);
    decode(tenant, bl);
    decode(bucket_name, bl);
    decode(bucket_id, bl);
    decode(new_instance_id, bl);
    decode(old_num_shards, bl);
    decode(new_num_shards, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_reshard_entry*>& o);

  static void generate_key(const string& tenant, const string& bucket_name, string *key);
  void get_key(string *key) const;
};
inline void encode(const cls_rgw_reshard_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_reshard_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/buffer.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h" 1
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
extern "C" {
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/rados_types.h" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/rados_types.h"
struct obj_watch_t {

  char addr[256];

  int64_t watcher_id;

  uint64_t cookie;

  uint32_t timeout_seconds;
};
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h" 2
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
enum {

  LIBRADOS_OP_FLAG_EXCL = 0x1,

  LIBRADOS_OP_FLAG_FAILOK = 0x2,

  LIBRADOS_OP_FLAG_FADVISE_RANDOM = 0x4,

  LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL = 0x8,

  LIBRADOS_OP_FLAG_FADVISE_WILLNEED = 0x10,

  LIBRADOS_OP_FLAG_FADVISE_DONTNEED = 0x20,

  LIBRADOS_OP_FLAG_FADVISE_NOCACHE = 0x40,

  LIBRADOS_OP_FLAG_FADVISE_FUA = 0x80,
};
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
enum {
 LIBRADOS_CMPXATTR_OP_EQ = 1,
 LIBRADOS_CMPXATTR_OP_NE = 2,
 LIBRADOS_CMPXATTR_OP_GT = 3,
 LIBRADOS_CMPXATTR_OP_GTE = 4,
 LIBRADOS_CMPXATTR_OP_LT = 5,
 LIBRADOS_CMPXATTR_OP_LTE = 6
};
# 115 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
enum {
  LIBRADOS_OPERATION_NOFLAG = 0,
  LIBRADOS_OPERATION_BALANCE_READS = 1,
  LIBRADOS_OPERATION_LOCALIZE_READS = 2,
  LIBRADOS_OPERATION_ORDER_READS_WRITES = 4,
  LIBRADOS_OPERATION_IGNORE_CACHE = 8,
  LIBRADOS_OPERATION_SKIPRWLOCKS = 16,
  LIBRADOS_OPERATION_IGNORE_OVERLAY = 32,



  LIBRADOS_OPERATION_FULL_TRY = 64,



  LIBRADOS_OPERATION_FULL_FORCE = 128,
  LIBRADOS_OPERATION_IGNORE_REDIRECT = 256,
  LIBRADOS_OPERATION_ORDERSNAP = 512,
};
# 142 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
enum {
  LIBRADOS_ALLOC_HINT_FLAG_SEQUENTIAL_WRITE = 1,
  LIBRADOS_ALLOC_HINT_FLAG_RANDOM_WRITE = 2,
  LIBRADOS_ALLOC_HINT_FLAG_SEQUENTIAL_READ = 4,
  LIBRADOS_ALLOC_HINT_FLAG_RANDOM_READ = 8,
  LIBRADOS_ALLOC_HINT_FLAG_APPEND_ONLY = 16,
  LIBRADOS_ALLOC_HINT_FLAG_IMMUTABLE = 32,
  LIBRADOS_ALLOC_HINT_FLAG_SHORTLIVED = 64,
  LIBRADOS_ALLOC_HINT_FLAG_LONGLIVED = 128,
  LIBRADOS_ALLOC_HINT_FLAG_COMPRESSIBLE = 256,
  LIBRADOS_ALLOC_HINT_FLAG_INCOMPRESSIBLE = 512,
};


typedef enum {
 LIBRADOS_CHECKSUM_TYPE_XXHASH32 = 0,
 LIBRADOS_CHECKSUM_TYPE_XXHASH64 = 1,
 LIBRADOS_CHECKSUM_TYPE_CRC32C = 2
} rados_checksum_type_t;
# 179 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void *rados_t;
# 193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void *rados_config_t;
# 215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void *rados_ioctx_t;
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void *rados_list_ctx_t;







typedef void * rados_object_list_cursor;







typedef struct rados_object_list_item {


  size_t oid_length;

  char *oid;

  size_t nspace_length;

  char *nspace;

  size_t locator_length;

  char *locator;
} rados_object_list_item;





typedef uint64_t rados_snap_t;







typedef void *rados_xattrs_iter_t;
# 278 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void *rados_omap_iter_t;





struct rados_pool_stat_t {

  uint64_t num_bytes;

  uint64_t num_kb;

  uint64_t num_objects;

  uint64_t num_object_clones;

  uint64_t num_object_copies;

  uint64_t num_objects_missing_on_primary;

  uint64_t num_objects_unfound;


  uint64_t num_objects_degraded;

  uint64_t num_rd;

  uint64_t num_rd_kb;

  uint64_t num_wr;

  uint64_t num_wr_kb;

  uint64_t num_user_bytes;

  uint64_t compressed_bytes_orig;

  uint64_t compressed_bytes;

  uint64_t compressed_bytes_alloc;
};





struct rados_cluster_stat_t {

  uint64_t kb;

  uint64_t kb_used;

  uint64_t kb_avail;

  uint64_t num_objects;
};
# 356 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void *rados_write_op_t;
# 378 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void *rados_read_op_t;







typedef void *rados_completion_t;





struct blkin_trace_info;
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_version(int *major, int *minor, int *extra);
# 430 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_create(rados_t *cluster, const char * const id);
# 440 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_create2(rados_t *pcluster,
                                 const char *const clustername,
                                 const char * const name, uint64_t flags);
# 453 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_create_with_context(rados_t *cluster,
                                             rados_config_t cct);
# 470 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ping_monitor(rados_t cluster, const char *mon_id,
                                      char **outstr, size_t *outstrlen);
# 488 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_connect(rados_t cluster);
# 508 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_shutdown(rados_t cluster);
# 546 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_conf_read_file(rados_t cluster, const char *path);
# 565 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_conf_parse_argv(rados_t cluster, int argc,
                                         const char **argv);
# 582 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_conf_parse_argv_remainder(rados_t cluster, int argc,
                       const char **argv,
                                                   const char **remargv);
# 600 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_conf_parse_env(rados_t cluster, const char *var);
# 613 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_conf_set(rados_t cluster, const char *option,
                                  const char *value);
# 627 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_conf_get(rados_t cluster, const char *option,
                                  char *buf, size_t len);
# 643 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_cluster_stat(rados_t cluster,
                                      struct rados_cluster_stat_t *result);
# 658 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_cluster_fsid(rados_t cluster, char *buf, size_t len);







 int rados_wait_for_latest_osdmap(rados_t cluster);
# 697 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_list(rados_t cluster, char *buf, size_t len);
# 715 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_inconsistent_pg_list(rados_t cluster, int64_t pool,
           char *buf, size_t len);
# 726 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 rados_config_t rados_cct(rados_t cluster);
# 736 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 uint64_t rados_get_instance_id(rados_t cluster);
# 746 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_get_min_compatible_osd(rados_t cluster,
                                                int8_t* require_osd_release);
# 759 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_get_min_compatible_client(rados_t cluster,
                                                   int8_t* min_compat_client,
                                                   int8_t* require_min_compat_client);
# 774 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_create(rados_t cluster, const char *pool_name,
                                      rados_ioctx_t *ioctx);
 int rados_ioctx_create2(rados_t cluster, int64_t pool_id,
                                       rados_ioctx_t *ioctx);
# 799 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_ioctx_destroy(rados_ioctx_t io);







 rados_config_t rados_ioctx_cct(rados_ioctx_t io);
# 817 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 rados_t rados_ioctx_get_cluster(rados_ioctx_t io);
# 828 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_pool_stat(rados_ioctx_t io,
                                         struct rados_pool_stat_t *stats);
# 839 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int64_t rados_pool_lookup(rados_t cluster,
                                         const char *pool_name);
# 851 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_reverse_lookup(rados_t cluster, int64_t id,
                                             char *buf, size_t maxlen);
# 863 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_create(rados_t cluster, const char *pool_name);
# 876 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_create_with_auid(rados_t cluster,
                                               const char *pool_name,
                                               uint64_t auid)
  __attribute__((deprecated));
# 889 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_create_with_crush_rule(rados_t cluster,
                                                     const char *pool_name,
                         uint8_t crush_rule_num);
# 908 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_create_with_all(rados_t cluster,
                                              const char *pool_name,
                                              uint64_t auid,
                         uint8_t crush_rule_num)
  __attribute__((deprecated));
# 925 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_get_base_tier(rados_t cluster, int64_t pool,
                                            int64_t* base_tier);
# 938 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_pool_delete(rados_t cluster, const char *pool_name);
# 952 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_pool_set_auid(rados_ioctx_t io, uint64_t auid)
  __attribute__((deprecated));
# 966 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_pool_get_auid(rados_ioctx_t io, uint64_t *auid)
  __attribute__((deprecated));


 int rados_ioctx_pool_requires_alignment(rados_ioctx_t io)
  __attribute__((deprecated));
# 980 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_pool_requires_alignment2(rados_ioctx_t io,
  int *req);


 uint64_t rados_ioctx_pool_required_alignment(rados_ioctx_t io)
  __attribute__((deprecated));
# 994 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_pool_required_alignment2(rados_ioctx_t io,
  uint64_t *alignment);







 int64_t rados_ioctx_get_id(rados_ioctx_t io);
# 1013 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_get_pool_name(rados_ioctx_t io, char *buf,
                                             unsigned maxlen);
# 1036 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_ioctx_locator_set_key(rados_ioctx_t io,
                                                const char *key);
# 1050 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_ioctx_set_namespace(rados_ioctx_t io,
                                              const char *nspace);
# 1061 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_get_namespace(rados_ioctx_t io, char *buf,
                                             unsigned maxlen);
# 1077 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_nobjects_list_open(rados_ioctx_t io,
                                            rados_list_ctx_t *ctx);







 uint32_t rados_nobjects_list_get_pg_hash_position(rados_list_ctx_t ctx);
# 1095 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 uint32_t rados_nobjects_list_seek(rados_list_ctx_t ctx,
                                                 uint32_t pos);
# 1105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 uint32_t rados_nobjects_list_seek_cursor(rados_list_ctx_t ctx,
                                                        rados_object_list_cursor cursor);
# 1117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_nobjects_list_get_cursor(rados_list_ctx_t ctx,
                                                  rados_object_list_cursor *cursor);
# 1132 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_nobjects_list_next(rados_list_ctx_t ctx,
                                            const char **entry,
                                     const char **key,
                                            const char **nspace);
# 1145 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_nobjects_list_close(rados_list_ctx_t ctx);
# 1156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 rados_object_list_cursor rados_object_list_begin(
  rados_ioctx_t io);
# 1168 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 rados_object_list_cursor rados_object_list_end(rados_ioctx_t io);
# 1177 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_object_list_is_end(rados_ioctx_t io,
    rados_object_list_cursor cur);
# 1188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_object_list_cursor_free(rados_ioctx_t io,
    rados_object_list_cursor cur);
# 1202 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_object_list_cursor_cmp(rados_ioctx_t io,
    rados_object_list_cursor lhs, rados_object_list_cursor rhs);




 int rados_object_list(rados_ioctx_t io,
    const rados_object_list_cursor start,
    const rados_object_list_cursor finish,
    const size_t result_size,
    const char *filter_buf,
    const size_t filter_buf_len,
    rados_object_list_item *results,
    rados_object_list_cursor *next);

 void rados_object_list_free(
    const size_t result_size,
    rados_object_list_item *results);
# 1235 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_object_list_slice(rados_ioctx_t io,
    const rados_object_list_cursor start,
    const rados_object_list_cursor finish,
    const size_t n,
    const size_t m,
    rados_object_list_cursor *split_start,
    rados_object_list_cursor *split_finish);
# 1282 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_snap_create(rados_ioctx_t io,
                                           const char *snapname);
# 1292 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_snap_remove(rados_ioctx_t io,
                                           const char *snapname);
# 1306 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_snap_rollback(rados_ioctx_t io, const char *oid,
                               const char *snapname);




 int rados_rollback(rados_ioctx_t io, const char *oid,
      const char *snapname)
  __attribute__((deprecated));
# 1326 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_ioctx_snap_set_read(rados_ioctx_t io,
                                              rados_snap_t snap);
# 1340 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_selfmanaged_snap_create(rados_ioctx_t io,
                                                       rados_snap_t *snapid);
 void
rados_aio_ioctx_selfmanaged_snap_create(rados_ioctx_t io,
                                        rados_snap_t *snapid,
                                        rados_completion_t completion);
# 1357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_selfmanaged_snap_remove(rados_ioctx_t io,
                                                       rados_snap_t snapid);
 void
rados_aio_ioctx_selfmanaged_snap_remove(rados_ioctx_t io,
                                        rados_snap_t snapid,
                                        rados_completion_t completion);
# 1375 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_selfmanaged_snap_rollback(rados_ioctx_t io,
                                                         const char *oid,
                                                         rados_snap_t snapid);
# 1391 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_selfmanaged_snap_set_write_ctx(rados_ioctx_t io,
                                                              rados_snap_t seq,
                                                              rados_snap_t *snaps,
                                                              int num_snaps);
# 1409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_snap_list(rados_ioctx_t io, rados_snap_t *snaps,
                                         int maxlen);
# 1420 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_snap_lookup(rados_ioctx_t io, const char *name,
                                           rados_snap_t *id);
# 1433 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_snap_get_name(rados_ioctx_t io, rados_snap_t id,
                                             char *name, int maxlen);
# 1444 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_ioctx_snap_get_stamp(rados_ioctx_t io, rados_snap_t id,
                                              time_t *t);
# 1471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 uint64_t rados_get_last_version(rados_ioctx_t io);
# 1485 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_write(rados_ioctx_t io, const char *oid,
                               const char *buf, size_t len, uint64_t off);
# 1501 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_write_full(rados_ioctx_t io, const char *oid,
                                    const char *buf, size_t len);
# 1518 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_writesame(rados_ioctx_t io, const char *oid,
                                   const char *buf, size_t data_len,
                                   size_t write_len, uint64_t off);
# 1532 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_append(rados_ioctx_t io, const char *oid,
                                const char *buf, size_t len);
# 1549 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_read(rados_ioctx_t io, const char *oid, char *buf,
                              size_t len, uint64_t off);
# 1582 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_checksum(rados_ioctx_t io, const char *oid,
      rados_checksum_type_t type,
      const char *init_value, size_t init_value_len,
      size_t len, uint64_t off, size_t chunk_size,
      char *pchecksum, size_t checksum_len);
# 1597 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_remove(rados_ioctx_t io, const char *oid);
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_trunc(rados_ioctx_t io, const char *oid,
                               uint64_t size);
# 1624 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_cmpext(rados_ioctx_t io, const char *o,
                                const char *cmp_buf, size_t cmp_len,
                                uint64_t off);
# 1648 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_getxattr(rados_ioctx_t io, const char *o,
                                  const char *name, char *buf, size_t len);
# 1661 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_setxattr(rados_ioctx_t io, const char *o,
                                  const char *name, const char *buf,
                                  size_t len);
# 1673 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_rmxattr(rados_ioctx_t io, const char *o,
                                 const char *name);
# 1686 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_getxattrs(rados_ioctx_t io, const char *oid,
                                   rados_xattrs_iter_t *iter);
# 1704 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_getxattrs_next(rados_xattrs_iter_t iter,
                                        const char **name, const char **val,
                                        size_t *len);
# 1715 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_getxattrs_end(rados_xattrs_iter_t iter);
# 1736 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_omap_get_next(rados_omap_iter_t iter,
                                       char **key,
                                       char **val,
                                       size_t *len);
# 1762 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_omap_get_next2(rados_omap_iter_t iter,
                                       char **key,
                                       char **val,
                                       size_t *key_len,
                                       size_t *val_len);






 unsigned int rados_omap_iter_size(rados_omap_iter_t iter);
# 1782 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_omap_get_end(rados_omap_iter_t iter);
# 1795 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_stat(rados_ioctx_t io, const char *o, uint64_t *psize,
                              time_t *pmtime);
# 1819 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_exec(rados_ioctx_t io, const char *oid,
                              const char *cls, const char *method,
                       const char *in_buf, size_t in_len, char *buf,
                              size_t out_len);
# 1840 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void (*rados_callback_t)(rados_completion_t cb, void *arg);
# 1864 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_create_completion(void *cb_arg,
                                               rados_callback_t cb_complete,
                                               rados_callback_t cb_safe,
                   rados_completion_t *pc);
# 1879 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_wait_for_complete(rados_completion_t c);
# 1891 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_wait_for_safe(rados_completion_t c);
# 1902 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_is_complete(rados_completion_t c);
# 1913 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_is_safe(rados_completion_t c);
# 1925 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_wait_for_complete_and_cb(rados_completion_t c);
# 1937 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_wait_for_safe_and_cb(rados_completion_t c);







 int rados_aio_is_complete_and_cb(rados_completion_t c);







 int rados_aio_is_safe_and_cb(rados_completion_t c);
# 1969 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_get_return_value(rados_completion_t c);
# 1985 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 uint64_t rados_aio_get_version(rados_completion_t c);
# 1995 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_aio_release(rados_completion_t c);
# 2012 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_write(rados_ioctx_t io, const char *oid,
                     rados_completion_t completion,
                     const char *buf, size_t len, uint64_t off);
# 2032 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_append(rados_ioctx_t io, const char *oid,
                      rados_completion_t completion,
                      const char *buf, size_t len);
# 2054 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_write_full(rados_ioctx_t io, const char *oid,
                   rados_completion_t completion,
                   const char *buf, size_t len);
# 2076 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_writesame(rados_ioctx_t io, const char *oid,
                  rados_completion_t completion,
                  const char *buf, size_t data_len,
           size_t write_len, uint64_t off);
# 2095 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_remove(rados_ioctx_t io, const char *oid,
                      rados_completion_t completion);
# 2117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_read(rados_ioctx_t io, const char *oid,
                    rados_completion_t completion,
                    char *buf, size_t len, uint64_t off);
# 2133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_flush(rados_ioctx_t io);
# 2145 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_flush_async(rados_ioctx_t io,
                                         rados_completion_t completion);
# 2159 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_stat(rados_ioctx_t io, const char *o,
                    rados_completion_t completion,
                    uint64_t *psize, time_t *pmtime);
# 2175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_cmpext(rados_ioctx_t io, const char *o,
                                    rados_completion_t completion,
                                    const char *cmp_buf,
                                    size_t cmp_len,
                                    uint64_t off);
# 2188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_cancel(rados_ioctx_t io,
                                    rados_completion_t completion);
# 2211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_exec(rados_ioctx_t io, const char *o,
      rados_completion_t completion,
      const char *cls, const char *method,
      const char *in_buf, size_t in_len,
      char *buf, size_t out_len);
# 2240 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_getxattr(rados_ioctx_t io, const char *o,
          rados_completion_t completion,
          const char *name, char *buf, size_t len);
# 2255 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_setxattr(rados_ioctx_t io, const char *o,
          rados_completion_t completion,
          const char *name, const char *buf,
          size_t len);
# 2269 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_rmxattr(rados_ioctx_t io, const char *o,
         rados_completion_t completion,
         const char *name);
# 2284 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_getxattrs(rados_ioctx_t io, const char *oid,
           rados_completion_t completion,
           rados_xattrs_iter_t *iter);
# 2321 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void (*rados_watchcb_t)(uint8_t opcode, uint64_t ver, void *arg);
# 2336 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void (*rados_watchcb2_t)(void *arg,
     uint64_t notify_id,
     uint64_t handle,
     uint64_t notifier_id,
     void *data,
     size_t data_len);
# 2355 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
  typedef void (*rados_watcherrcb_t)(void *pre, uint64_t cookie, int err);
# 2381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_watch(rados_ioctx_t io, const char *o, uint64_t ver,
          uint64_t *cookie,
          rados_watchcb_t watchcb, void *arg)
  __attribute__((deprecated));
# 2407 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_watch2(rados_ioctx_t io, const char *o, uint64_t *cookie,
    rados_watchcb2_t watchcb,
    rados_watcherrcb_t watcherrcb,
    void *arg);
# 2430 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_watch3(rados_ioctx_t io, const char *o, uint64_t *cookie,
        rados_watchcb2_t watchcb,
        rados_watcherrcb_t watcherrcb,
        uint32_t timeout,
        void *arg);
# 2456 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_watch(rados_ioctx_t io, const char *o,
       rados_completion_t completion, uint64_t *handle,
       rados_watchcb2_t watchcb,
       rados_watcherrcb_t watcherrcb,
       void *arg);
# 2484 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_watch2(rados_ioctx_t io, const char *o,
           rados_completion_t completion, uint64_t *handle,
           rados_watchcb2_t watchcb,
           rados_watcherrcb_t watcherrcb,
           uint32_t timeout,
           void *arg);
# 2505 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_watch_check(rados_ioctx_t io, uint64_t cookie);
# 2518 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_unwatch(rados_ioctx_t io, const char *o, uint64_t cookie)
  __attribute__((deprecated));
# 2531 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_unwatch2(rados_ioctx_t io, uint64_t cookie);
# 2544 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_unwatch(rados_ioctx_t io, uint64_t cookie,
                                     rados_completion_t completion);
# 2563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_notify(rados_ioctx_t io, const char *o, uint64_t ver,
    const char *buf, int buf_len)
  __attribute__((deprecated));
# 2613 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_notify(rados_ioctx_t io, const char *o,
        rados_completion_t completion,
        const char *buf, int buf_len,
        uint64_t timeout_ms, char **reply_buffer,
        size_t *reply_buffer_len);
 int rados_notify2(rados_ioctx_t io, const char *o,
     const char *buf, int buf_len,
     uint64_t timeout_ms,
     char **reply_buffer, size_t *reply_buffer_len);
# 2634 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_notify_ack(rados_ioctx_t io, const char *o,
        uint64_t notify_id, uint64_t cookie,
        const char *buf, int buf_len);
# 2650 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_watch_flush(rados_t cluster);
# 2665 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_watch_flush(rados_t cluster, rados_completion_t completion);
# 2679 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_cache_pin(rados_ioctx_t io, const char *o);
# 2690 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_cache_unpin(rados_ioctx_t io, const char *o);
# 2711 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_set_alloc_hint(rados_ioctx_t io, const char *o,
                                        uint64_t expected_object_size,
                                        uint64_t expected_write_size);
# 2729 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_set_alloc_hint2(rados_ioctx_t io, const char *o,
      uint64_t expected_object_size,
      uint64_t expected_write_size,
      uint32_t flags);
# 2758 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 rados_write_op_t rados_create_write_op(void);





 void rados_release_write_op(rados_write_op_t write_op);







 void rados_write_op_set_flags(rados_write_op_t write_op,
                                             int flags);





 void rados_write_op_assert_exists(rados_write_op_t write_op);
# 2794 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_assert_version(rados_write_op_t write_op, uint64_t ver);
# 2806 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_cmpext(rados_write_op_t write_op,
                                          const char *cmp_buf,
                                          size_t cmp_len,
                                          uint64_t off,
                                          int *prval);
# 2823 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_cmpxattr(rados_write_op_t write_op,
                                            const char *name,
                                            uint8_t comparison_operator,
                                            const char *value,
                                            size_t value_len);
# 2842 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_omap_cmp(rados_write_op_t write_op,
                                            const char *key,
                                            uint8_t comparison_operator,
                                            const char *val,
                                            size_t val_len,
                                            int *prval);
# 2863 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_omap_cmp2(rados_write_op_t write_op,
                                            const char *key,
                                            uint8_t comparison_operator,
                                            const char *val,
                                            size_t key_len,
                                            size_t val_len,
                                            int *prval);
# 2878 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_setxattr(rados_write_op_t write_op,
                                            const char *name,
                                            const char *value,
                                            size_t value_len);






 void rados_write_op_rmxattr(rados_write_op_t write_op,
                                           const char *name);
# 2899 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_create(rados_write_op_t write_op,
                                          int exclusive,
                                          const char* category);
# 2910 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_write(rados_write_op_t write_op,
                                         const char *buffer,
                                         size_t len,
                                         uint64_t offset);







 void rados_write_op_write_full(rados_write_op_t write_op,
                                              const char *buffer,
                                              size_t len);
# 2933 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_writesame(rados_write_op_t write_op,
                                             const char *buffer,
                                             size_t data_len,
                                             size_t write_len,
                                             uint64_t offset);







 void rados_write_op_append(rados_write_op_t write_op,
                                          const char *buffer,
                                          size_t len);




 void rados_write_op_remove(rados_write_op_t write_op);






 void rados_write_op_truncate(rados_write_op_t write_op,
                                            uint64_t offset);







 void rados_write_op_zero(rados_write_op_t write_op,
                   uint64_t offset,
                   uint64_t len);
# 2983 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_exec(rados_write_op_t write_op,
                   const char *cls,
                   const char *method,
                   const char *in_buf,
                   size_t in_len,
                   int *prval);
# 2999 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_omap_set(rados_write_op_t write_op,
                                            char const* const* keys,
                                            char const* const* vals,
                                            const size_t *lens,
                                            size_t num);
# 3015 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_omap_set2(rados_write_op_t write_op,
                                            char const* const* keys,
                                            char const* const* vals,
                                            const size_t *key_lens,
                                            const size_t *val_lens,
                                            size_t num);
# 3029 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_omap_rm_keys(rados_write_op_t write_op,
                                                char const* const* keys,
                                                size_t keys_len);
# 3041 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_omap_rm_keys2(rados_write_op_t write_op,
                                                char const* const* keys,
                                                const size_t* key_lens,
                                                size_t keys_len);






 void rados_write_op_omap_clear(rados_write_op_t write_op);
# 3060 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_set_alloc_hint(rados_write_op_t write_op,
                                                  uint64_t expected_object_size,
                                                  uint64_t expected_write_size);
# 3072 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_write_op_set_alloc_hint2(rados_write_op_t write_op,
         uint64_t expected_object_size,
         uint64_t expected_write_size,
         uint32_t flags);
# 3085 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_write_op_operate(rados_write_op_t write_op,
                     rados_ioctx_t io,
                     const char *oid,
                     time_t *mtime,
                     int flags);
# 3099 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_write_op_operate2(rados_write_op_t write_op,
                                           rados_ioctx_t io,
                                           const char *oid,
                                           struct timespec *mtime,
                                           int flags);
# 3114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_write_op_operate(rados_write_op_t write_op,
                                              rados_ioctx_t io,
                                              rados_completion_t completion,
                                              const char *oid,
                                              time_t *mtime,
                         int flags);
# 3129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 rados_read_op_t rados_create_read_op(void);





 void rados_release_read_op(rados_read_op_t read_op);







 void rados_read_op_set_flags(rados_read_op_t read_op, int flags);





 void rados_read_op_assert_exists(rados_read_op_t read_op);
# 3164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_assert_version(rados_read_op_t read_op, uint64_t ver);
# 3176 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_cmpext(rados_read_op_t read_op,
                                         const char *cmp_buf,
                                         size_t cmp_len,
                                         uint64_t off,
                                         int *prval);
# 3193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_cmpxattr(rados_read_op_t read_op,
                      const char *name,
                      uint8_t comparison_operator,
                      const char *value,
                      size_t value_len);
# 3206 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_getxattrs(rados_read_op_t read_op,
                       rados_xattrs_iter_t *iter,
                       int *prval);
# 3223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_cmp(rados_read_op_t read_op,
                                           const char *key,
                                           uint8_t comparison_operator,
                                           const char *val,
                                           size_t val_len,
                                           int *prval);
# 3244 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_cmp2(rados_read_op_t read_op,
                                           const char *key,
                                           uint8_t comparison_operator,
                                           const char *val,
                                           size_t key_len,
                                           size_t val_len,
                                           int *prval);
# 3259 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_stat(rados_read_op_t read_op,
                  uint64_t *psize,
                  time_t *pmtime,
                  int *prval);
# 3278 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_read(rados_read_op_t read_op,
                  uint64_t offset,
                  size_t len,
                  char *buffer,
                  size_t *bytes_read,
                  int *prval);
# 3299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_checksum(rados_read_op_t read_op,
        rados_checksum_type_t type,
        const char *init_value,
        size_t init_value_len,
        uint64_t offset, size_t len,
        size_t chunk_size, char *pchecksum,
        size_t checksum_len, int *prval);
# 3325 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_exec(rados_read_op_t read_op,
                  const char *cls,
                  const char *method,
                  const char *in_buf,
                  size_t in_len,
                  char **out_buf,
                  size_t *out_len,
                  int *prval);
# 3351 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_exec_user_buf(rados_read_op_t read_op,
                    const char *cls,
                    const char *method,
                    const char *in_buf,
                    size_t in_len,
                    char *out_buf,
                    size_t out_len,
                    size_t *used_len,
                    int *prval);
# 3373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_get_vals(rados_read_op_t read_op,
                    const char *start_after,
                    const char *filter_prefix,
                    uint64_t max_return,
                    rados_omap_iter_t *iter,
                    int *prval)
  __attribute__((deprecated));
# 3394 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_get_vals2(rados_read_op_t read_op,
       const char *start_after,
       const char *filter_prefix,
       uint64_t max_return,
       rados_omap_iter_t *iter,
       unsigned char *pmore,
       int *prval);
# 3414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_get_keys(rados_read_op_t read_op,
                    const char *start_after,
                    uint64_t max_return,
                    rados_omap_iter_t *iter,
                    int *prval)
  __attribute__((deprecated));
# 3434 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_get_keys2(rados_read_op_t read_op,
       const char *start_after,
       uint64_t max_return,
       rados_omap_iter_t *iter,
       unsigned char *pmore,
       int *prval);
# 3452 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_get_vals_by_keys(rados_read_op_t read_op,
                                                        char const* const* keys,
                                                        size_t keys_len,
                                                        rados_omap_iter_t *iter,
                                                        int *prval);
# 3470 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_read_op_omap_get_vals_by_keys2(rados_read_op_t read_op,
                                                        char const* const* keys,
                                                        size_t num_keys,
                                                        const size_t* key_lens,
                                                        rados_omap_iter_t *iter,
                                                        int *prval);
# 3484 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_read_op_operate(rados_read_op_t read_op,
                    rados_ioctx_t io,
                    const char *oid,
                    int flags);
# 3497 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_read_op_operate(rados_read_op_t read_op,
                        rados_ioctx_t io,
                        rados_completion_t completion,
                        const char *oid,
                        int flags);
# 3519 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_lock_exclusive(rados_ioctx_t io, const char * oid,
                                        const char * name, const char * cookie,
                                        const char * desc,
                                        struct timeval * duration,
                                        uint8_t flags);
# 3540 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_lock_shared(rados_ioctx_t io, const char * o,
                                     const char * name, const char * cookie,
                                     const char * tag, const char * desc,
                              struct timeval * duration, uint8_t flags);
# 3555 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_unlock(rados_ioctx_t io, const char *o,
                                const char *name, const char *cookie);
# 3568 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_aio_unlock(rados_ioctx_t io, const char *o,
                                    const char *name, const char *cookie,
               rados_completion_t completion);
# 3595 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 ssize_t rados_list_lockers(rados_ioctx_t io, const char *o,
                     const char *name, int *exclusive,
                     char *tag, size_t *tag_len,
                     char *clients, size_t *clients_len,
                     char *cookies, size_t *cookies_len,
                     char *addrs, size_t *addrs_len);
# 3615 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_break_lock(rados_ioctx_t io, const char *o,
                                    const char *name, const char *client,
                                    const char *cookie);
# 3627 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_blacklist_add(rados_t cluster,
           char *client_address,
           uint32_t expire_seconds);

 void rados_set_osdmap_full_try(rados_ioctx_t io);

 void rados_unset_osdmap_full_try(rados_ioctx_t io);
# 3643 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_application_enable(rados_ioctx_t io,
                                            const char *app_name, int force);
# 3659 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_application_list(rados_ioctx_t io, char *values,
                                          size_t *values_len);
# 3672 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_application_metadata_get(rados_ioctx_t io,
                                                  const char *app_name,
                                                  const char *key, char *value,
                                                  size_t *value_len);
# 3686 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_application_metadata_set(rados_ioctx_t io,
                                                  const char *app_name,
                                                  const char *key,
                                                  const char *value);
# 3699 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_application_metadata_remove(rados_ioctx_t io,
                                                     const char *app_name,
                                                     const char *key);
# 3722 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_application_metadata_list(rados_ioctx_t io,
                                                   const char *app_name,
                                                   char *keys, size_t *key_len,
                                                   char *values,
                                                   size_t *vals_len);
# 3758 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_mon_command(rados_t cluster, const char **cmd,
                                     size_t cmdlen, const char *inbuf,
                                     size_t inbuflen, char **outbuf,
                                     size_t *outbuflen, char **outs,
                                     size_t *outslen);
# 3786 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_mgr_command(rados_t cluster, const char **cmd,
                                     size_t cmdlen, const char *inbuf,
                                     size_t inbuflen, char **outbuf,
                                     size_t *outbuflen, char **outs,
                                     size_t *outslen);
# 3815 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_mon_command_target(rados_t cluster, const char *name,
                       const char **cmd, size_t cmdlen,
                       const char *inbuf, size_t inbuflen,
                       char **outbuf, size_t *outbuflen,
                       char **outs, size_t *outslen);
# 3828 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 void rados_buffer_free(char *buf);

 int rados_osd_command(rados_t cluster, int osdid,
                                     const char **cmd, size_t cmdlen,
                       const char *inbuf, size_t inbuflen,
                       char **outbuf, size_t *outbuflen,
                       char **outs, size_t *outslen);

 int rados_pg_command(rados_t cluster, const char *pgstr,
                                    const char **cmd, size_t cmdlen,
                      const char *inbuf, size_t inbuflen,
                      char **outbuf, size_t *outbuflen,
                      char **outs, size_t *outslen);

 int rados_mgr_command(rados_t cluster,
                                     const char **cmd, size_t cmdlen,
                       const char *inbuf, size_t inbuflen,
                       char **outbuf, size_t *outbuflen,
                       char **outs, size_t *outslen);
# 3870 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void (*rados_log_callback_t)(void *arg,
         const char *line,
         const char *who,
         uint64_t sec, uint64_t nsec,
         uint64_t seq, const char *level,
         const char *msg);
# 3899 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
typedef void (*rados_log_callback2_t)(void *arg,
         const char *line,
         const char *channel,
         const char *who,
         const char *name,
         uint64_t sec, uint64_t nsec,
         uint64_t seq, const char *level,
         const char *msg);

 int rados_monitor_log(rados_t cluster, const char *level,
                                     rados_log_callback_t cb, void *arg);
 int rados_monitor_log2(rados_t cluster, const char *level,
          rados_log_callback2_t cb, void *arg);
# 3932 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_service_register(
  rados_t cluster,
  const char *service,
  const char *daemon,
  const char *metadata_dict);
# 3950 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.h"
 int rados_service_update_status(
  rados_t cluster,
  const char *status_dict);






 int rados_objects_list_open(
  rados_ioctx_t io,
  rados_list_ctx_t *ctx) __attribute__((deprecated));
 uint32_t rados_objects_list_get_pg_hash_position(
  rados_list_ctx_t ctx) __attribute__((deprecated));
 uint32_t rados_objects_list_seek(
  rados_list_ctx_t ctx,
  uint32_t pos) __attribute__((deprecated));
 int rados_objects_list_next(
  rados_list_ctx_t ctx,
  const char **entry,
  const char **key) __attribute__((deprecated));
 void rados_objects_list_close(
  rados_list_ctx_t ctx) __attribute__((deprecated));



}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados_fwd.hpp" 1



namespace libradosstriper {

class RadosStriper;

}

namespace librados {
inline namespace v14_2_0 {

class AioCompletion;
class IoCtx;
class ListObject;
class NObjectIterator;
class ObjectCursor;
class ObjectItem;
class ObjectOperation;
class ObjectOperationCompletion;
class ObjectReadOperation;
class ObjectWriteOperation;
class PlacementGroup;
class PoolAsyncCompletion;
class Rados;
class WatchCtx;
class WatchCtx2;

}
}
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/rados_types.hpp" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/rados_types.hpp"
namespace librados {

typedef uint64_t snap_t;

enum {
  SNAP_HEAD = (uint64_t)(-2),
  SNAP_DIR = (uint64_t)(-1)
};

struct clone_info_t {
  snap_t cloneid;
  std::vector<snap_t> snaps;
  std::vector< std::pair<uint64_t,uint64_t> > overlap;
  uint64_t size;
  clone_info_t() : cloneid(0), size(0) {}
};

struct snap_set_t {
  std::vector<clone_info_t> clones;
  snap_t seq;
  snap_set_t() : seq(0) {}
};

struct object_id_t {
  std::string name;
  std::string nspace;
  std::string locator;
  snap_t snap = 0;
  object_id_t() = default;
  object_id_t(const std::string& name,
              const std::string& nspace,
              const std::string& locator,
              snap_t snap)
    : name(name),
      nspace(nspace),
      locator(locator),
      snap(snap)
  {}
};

struct err_t {
  enum : uint64_t {
    SHARD_MISSING = 1 << 1,
    SHARD_STAT_ERR = 1 << 2,
    SHARD_READ_ERR = 1 << 3,
    DATA_DIGEST_MISMATCH_OI = 1 << 9,
    DATA_DIGEST_MISMATCH_INFO = 1 << 9,
    OMAP_DIGEST_MISMATCH_OI = 1 << 10,
    OMAP_DIGEST_MISMATCH_INFO = 1 << 10,
    SIZE_MISMATCH_OI = 1 << 11,
    SIZE_MISMATCH_INFO = 1 << 11,
    SHARD_EC_HASH_MISMATCH = 1 << 12,
    SHARD_EC_SIZE_MISMATCH = 1 << 13,
    OI_ATTR_MISSING = 1 << 14,
    INFO_MISSING = 1 << 14,
    OI_ATTR_CORRUPTED = 1 << 15,
    INFO_CORRUPTED = 1 << 15,
    SS_ATTR_MISSING = 1 << 16,
    SNAPSET_MISSING = 1 << 16,
    SS_ATTR_CORRUPTED = 1 << 17,
    SNAPSET_CORRUPTED = 1 << 17,
    OBJ_SIZE_OI_MISMATCH = 1 << 18,
    OBJ_SIZE_INFO_MISMATCH = 1 << 18,
    HINFO_MISSING = 1 << 19,
    HINFO_CORRUPTED = 1 << 20

  };
  uint64_t errors = 0;
  static constexpr uint64_t SHALLOW_ERRORS = SHARD_MISSING|SHARD_STAT_ERR|SIZE_MISMATCH_INFO|INFO_MISSING|INFO_CORRUPTED|SNAPSET_MISSING|SNAPSET_CORRUPTED|OBJ_SIZE_INFO_MISMATCH|HINFO_MISSING|HINFO_CORRUPTED;
  static constexpr uint64_t DEEP_ERRORS = SHARD_READ_ERR|DATA_DIGEST_MISMATCH_INFO|OMAP_DIGEST_MISMATCH_INFO|SHARD_EC_HASH_MISMATCH|SHARD_EC_SIZE_MISMATCH;
  bool has_shard_missing() const {
    return errors & SHARD_MISSING;
  }
  bool has_stat_error() const {
    return errors & SHARD_STAT_ERR;
  }
  bool has_read_error() const {
    return errors & SHARD_READ_ERR;
  }
  bool has_data_digest_mismatch_oi() const {
    return errors & DATA_DIGEST_MISMATCH_OI;
  }
  bool has_data_digest_mismatch_info() const {
    return errors & DATA_DIGEST_MISMATCH_INFO;
  }
  bool has_omap_digest_mismatch_oi() const {
    return errors & OMAP_DIGEST_MISMATCH_OI;
  }
  bool has_omap_digest_mismatch_info() const {
    return errors & OMAP_DIGEST_MISMATCH_INFO;
  }
  bool has_size_mismatch_oi() const {
    return errors & SIZE_MISMATCH_OI;
  }
  bool has_size_mismatch_info() const {
    return errors & SIZE_MISMATCH_INFO;
  }
  bool has_ec_hash_error() const {
    return errors & SHARD_EC_HASH_MISMATCH;
  }
  bool has_ec_size_error() const {
    return errors & SHARD_EC_SIZE_MISMATCH;
  }
  bool has_oi_attr_missing() const {
    return errors & OI_ATTR_MISSING;
  }
  bool has_info_missing() const {
    return errors & INFO_MISSING;
  }
  bool has_oi_attr_corrupted() const {
    return errors & OI_ATTR_CORRUPTED;
  }
  bool has_info_corrupted() const {
    return errors & INFO_CORRUPTED;
  }
  bool has_ss_attr_missing() const {
    return errors & SS_ATTR_MISSING;
  }
  bool has_snapset_missing() const {
    return errors & SNAPSET_MISSING;
  }
  bool has_ss_attr_corrupted() const {
    return errors & SS_ATTR_CORRUPTED;
  }
  bool has_snapset_corrupted() const {
    return errors & SNAPSET_CORRUPTED;
  }
  bool has_shallow_errors() const {
    return errors & SHALLOW_ERRORS;
  }
  bool has_deep_errors() const {
    return errors & DEEP_ERRORS;
  }
  bool has_obj_size_oi_mismatch() const {
    return errors & OBJ_SIZE_OI_MISMATCH;
   }
  bool has_obj_size_info_mismatch() const {
    return errors & OBJ_SIZE_INFO_MISMATCH;
  }
  bool has_hinfo_missing() const {
    return errors & HINFO_MISSING;
  }
  bool has_hinfo_corrupted() const {
    return errors & HINFO_CORRUPTED;
  }
};

struct shard_info_t : err_t {
  std::map<std::string, ceph::bufferlist> attrs;
  uint64_t size = -1;
  bool omap_digest_present = false;
  uint32_t omap_digest = 0;
  bool data_digest_present = false;
  uint32_t data_digest = 0;
  bool selected_oi = false;
  bool primary = false;
};

struct osd_shard_t {
  int32_t osd;
  int8_t shard;
};

inline bool operator<(const osd_shard_t &lhs, const osd_shard_t &rhs) {
  if (lhs.osd < rhs.osd)
    return true;
  else if (lhs.osd > rhs.osd)
    return false;
  else
    return lhs.shard < rhs.shard;
}

struct obj_err_t {
  enum : uint64_t {
    OBJECT_INFO_INCONSISTENCY = 1 << 1,

    DATA_DIGEST_MISMATCH = 1 << 4,
    OMAP_DIGEST_MISMATCH = 1 << 5,
    SIZE_MISMATCH = 1 << 6,
    ATTR_VALUE_MISMATCH = 1 << 7,
    ATTR_NAME_MISMATCH = 1 << 8,
    SNAPSET_INCONSISTENCY = 1 << 9,
    HINFO_INCONSISTENCY = 1 << 10,
    SIZE_TOO_LARGE = 1 << 11,

  };
  uint64_t errors = 0;
  static constexpr uint64_t SHALLOW_ERRORS = OBJECT_INFO_INCONSISTENCY|SIZE_MISMATCH|ATTR_VALUE_MISMATCH
   |ATTR_NAME_MISMATCH|SNAPSET_INCONSISTENCY|HINFO_INCONSISTENCY|SIZE_TOO_LARGE;
  static constexpr uint64_t DEEP_ERRORS = DATA_DIGEST_MISMATCH|OMAP_DIGEST_MISMATCH;
  bool has_object_info_inconsistency() const {
    return errors & OBJECT_INFO_INCONSISTENCY;
  }
  bool has_data_digest_mismatch() const {
    return errors & DATA_DIGEST_MISMATCH;
  }
  bool has_omap_digest_mismatch() const {
    return errors & OMAP_DIGEST_MISMATCH;
  }
  bool has_size_mismatch() const {
    return errors & SIZE_MISMATCH;
  }
  bool has_attr_value_mismatch() const {
    return errors & ATTR_VALUE_MISMATCH;
  }
  bool has_attr_name_mismatch() const {
    return errors & ATTR_NAME_MISMATCH;
  }
  bool has_shallow_errors() const {
    return errors & SHALLOW_ERRORS;
  }
  bool has_deep_errors() const {
    return errors & DEEP_ERRORS;
  }
  bool has_snapset_inconsistency() const {
    return errors & SNAPSET_INCONSISTENCY;
  }
  bool has_hinfo_inconsistency() const {
    return errors & HINFO_INCONSISTENCY;
  }
  bool has_size_too_large() const {
    return errors & SIZE_TOO_LARGE;
  }
};

struct inconsistent_obj_t : obj_err_t {
  inconsistent_obj_t() = default;
  inconsistent_obj_t(const object_id_t& object)
    : object{object}, version(0)
  {}
  object_id_t object;
  uint64_t version;
  std::map<osd_shard_t, shard_info_t> shards;
  err_t union_shards;
};

struct inconsistent_snapset_t {
  inconsistent_snapset_t() = default;
  inconsistent_snapset_t(const object_id_t& head)
    : object{head}
  {}
  enum {
    SNAPSET_MISSING = 1 << 0,
    SNAPSET_CORRUPTED = 1 << 1,
    CLONE_MISSING = 1 << 2,
    SNAP_ERROR = 1 << 3,
    HEAD_MISMATCH = 1 << 4,
    HEADLESS_CLONE = 1 << 5,
    SIZE_MISMATCH = 1 << 6,
    OI_MISSING = 1 << 7,
    INFO_MISSING = 1 << 7,
    OI_CORRUPTED = 1 << 8,
    INFO_CORRUPTED = 1 << 8,
    EXTRA_CLONES = 1 << 9,
  };
  uint64_t errors = 0;
  object_id_t object;

  std::vector<snap_t> clones;
  std::vector<snap_t> missing;
  ceph::bufferlist ss_bl;

  bool ss_attr_missing() const {
    return errors & SNAPSET_MISSING;
  }
  bool snapset_missing() const {
    return errors & SNAPSET_MISSING;
  }
  bool ss_attr_corrupted() const {
    return errors & SNAPSET_CORRUPTED;
  }
  bool snapset_corrupted() const {
    return errors & SNAPSET_CORRUPTED;
  }
  bool clone_missing() const {
    return errors & CLONE_MISSING;
  }
  bool snapset_mismatch() const {
    return errors & SNAP_ERROR;
  }
  bool snapset_error() const {
    return errors & SNAP_ERROR;
  }
  bool head_mismatch() const {
    return false;
  }
  bool headless() const {
    return errors & HEADLESS_CLONE;
  }
  bool size_mismatch() const {
    return errors & SIZE_MISMATCH;
  }
  bool oi_attr_missing() const {
    return errors & OI_MISSING;
  }
  bool info_missing() const {
    return errors & INFO_MISSING;
  }
  bool oi_attr_corrupted() const {
    return errors & OI_CORRUPTED;
  }
  bool info_corrupted() const {
    return errors & INFO_CORRUPTED;
  }
  bool extra_clones() const {
    return errors & EXTRA_CLONES;
  }
};







const std::string all_nspaces("\001");

}
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp" 2

namespace libradosstriper
{
  class RadosStriper;
}

namespace librados {

using ceph::bufferlist;

struct AioCompletionImpl;
struct IoCtxImpl;
struct ListObjectImpl;
class NObjectIteratorImpl;
struct ObjListCtx;
class ObjectOperationImpl;
struct PlacementGroupImpl;
struct PoolAsyncCompletionImpl;

typedef struct rados_cluster_stat_t cluster_stat_t;
typedef struct rados_pool_stat_t pool_stat_t;

typedef void *list_ctx_t;
typedef uint64_t auid_t;
typedef void *config_t;

typedef struct {
  std::string client;
  std::string cookie;
  std::string address;
} locker_t;

typedef std::map<std::string, pool_stat_t> stats_map;

typedef void *completion_t;
typedef void (*callback_t)(completion_t cb, void *arg);

inline namespace v14_2_0 {

  class IoCtx;
  class RadosClient;

  class ListObject
  {
  public:
    const std::string& get_nspace() const;
    const std::string& get_oid() const;
    const std::string& get_locator() const;

    ListObject();
    ~ListObject();
    ListObject( const ListObject&);
    ListObject& operator=(const ListObject& rhs);
  private:
    ListObject(ListObjectImpl *impl);

    friend class librados::NObjectIteratorImpl;
    friend std::ostream& operator<<(std::ostream& out, const ListObject& lop);

    ListObjectImpl *impl;
  };
  std::ostream& operator<<(std::ostream& out, const librados::ListObject& lop);

  class NObjectIterator;

  class ObjectCursor
  {
    public:
    ObjectCursor();
    ObjectCursor(const ObjectCursor &rhs);
    explicit ObjectCursor(rados_object_list_cursor c);
    ~ObjectCursor();
    ObjectCursor& operator=(const ObjectCursor& rhs);
    bool operator<(const ObjectCursor &rhs) const;
    bool operator==(const ObjectCursor &rhs) const;
    void set(rados_object_list_cursor c);

    friend class IoCtx;
    friend class librados::NObjectIteratorImpl;
    friend std::ostream& operator<<(std::ostream& os, const librados::ObjectCursor& oc);

    std::string to_str() const;
    bool from_str(const std::string& s);

    protected:
    rados_object_list_cursor c_cursor;
  };
  std::ostream& operator<<(std::ostream& os, const librados::ObjectCursor& oc);

  class NObjectIterator : public std::iterator <std::forward_iterator_tag, ListObject> {
  public:
    static const NObjectIterator __EndObjectIterator;
    NObjectIterator(): impl(
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp" 3 4
                           __null
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
                               ) {}
    ~NObjectIterator();
    NObjectIterator(const NObjectIterator &rhs);
    NObjectIterator& operator=(const NObjectIterator& rhs);

    bool operator==(const NObjectIterator& rhs) const;
    bool operator!=(const NObjectIterator& rhs) const;
    const ListObject& operator*() const;
    const ListObject* operator->() const;
    NObjectIterator &operator++();
    NObjectIterator operator++(int);
    friend class IoCtx;
    friend class librados::NObjectIteratorImpl;


    uint32_t get_pg_hash_position() const;



    uint32_t seek(uint32_t pos);


    uint32_t seek(const ObjectCursor& cursor);


    ObjectCursor get_cursor();





    void set_filter(const bufferlist &bl);

  private:
    NObjectIterator(ObjListCtx *ctx_);
    void get_next();
    NObjectIteratorImpl *impl;
  };

  class ObjectItem
  {
    public:
    std::string oid;
    std::string nspace;
    std::string locator;
  };


  class WatchCtx {
  public:
    virtual ~WatchCtx();
    virtual void notify(uint8_t opcode, uint64_t ver, bufferlist& bl) = 0;
  };

  class WatchCtx2 {
  public:
    virtual ~WatchCtx2();
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    virtual void handle_notify(uint64_t notify_id,
          uint64_t cookie,
          uint64_t notifier_id,
          bufferlist& bl) = 0;
# 189 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    virtual void handle_error(uint64_t cookie, int err) = 0;
  };

  struct AioCompletion {
    AioCompletion(AioCompletionImpl *pc_) : pc(pc_) {}
    int set_complete_callback(void *cb_arg, callback_t cb);
    int set_safe_callback(void *cb_arg, callback_t cb);
    int wait_for_complete();
    int wait_for_safe();
    int wait_for_complete_and_cb();
    int wait_for_safe_and_cb();
    bool is_complete();
    bool is_safe();
    bool is_complete_and_cb();
    bool is_safe_and_cb();
    int get_return_value();
    int get_version() __attribute__ ((deprecated));
    uint64_t get_version64();
    void release();
    AioCompletionImpl *pc;
  };

  struct PoolAsyncCompletion {
    PoolAsyncCompletion(PoolAsyncCompletionImpl *pc_) : pc(pc_) {}
    int set_callback(void *cb_arg, callback_t cb);
    int wait();
    bool is_complete();
    int get_return_value();
    void release();
    PoolAsyncCompletionImpl *pc;
  };





  enum ObjectOperationFlags {
    OP_EXCL = LIBRADOS_OP_FLAG_EXCL,
    OP_FAILOK = LIBRADOS_OP_FLAG_FAILOK,
    OP_FADVISE_RANDOM = LIBRADOS_OP_FLAG_FADVISE_RANDOM,
    OP_FADVISE_SEQUENTIAL = LIBRADOS_OP_FLAG_FADVISE_SEQUENTIAL,
    OP_FADVISE_WILLNEED = LIBRADOS_OP_FLAG_FADVISE_WILLNEED,
    OP_FADVISE_DONTNEED = LIBRADOS_OP_FLAG_FADVISE_DONTNEED,
    OP_FADVISE_NOCACHE = LIBRADOS_OP_FLAG_FADVISE_NOCACHE,
  };

  class ObjectOperationCompletion {
  public:
    virtual ~ObjectOperationCompletion() {}
    virtual void handle_completion(int r, bufferlist& outbl) = 0;
  };
# 261 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
  enum ObjectOperationGlobalFlags {
    OPERATION_NOFLAG = LIBRADOS_OPERATION_NOFLAG,
    OPERATION_BALANCE_READS = LIBRADOS_OPERATION_BALANCE_READS,
    OPERATION_LOCALIZE_READS = LIBRADOS_OPERATION_LOCALIZE_READS,
    OPERATION_ORDER_READS_WRITES = LIBRADOS_OPERATION_ORDER_READS_WRITES,
    OPERATION_IGNORE_CACHE = LIBRADOS_OPERATION_IGNORE_CACHE,
    OPERATION_SKIPRWLOCKS = LIBRADOS_OPERATION_SKIPRWLOCKS,
    OPERATION_IGNORE_OVERLAY = LIBRADOS_OPERATION_IGNORE_OVERLAY,



    OPERATION_FULL_TRY = LIBRADOS_OPERATION_FULL_TRY,

    OPERATION_FULL_FORCE = LIBRADOS_OPERATION_FULL_FORCE,
    OPERATION_IGNORE_REDIRECT = LIBRADOS_OPERATION_IGNORE_REDIRECT,
    OPERATION_ORDERSNAP = LIBRADOS_OPERATION_ORDERSNAP,
  };




  enum AllocHintFlags {
    ALLOC_HINT_FLAG_SEQUENTIAL_WRITE = 1,
    ALLOC_HINT_FLAG_RANDOM_WRITE = 2,
    ALLOC_HINT_FLAG_SEQUENTIAL_READ = 4,
    ALLOC_HINT_FLAG_RANDOM_READ = 8,
    ALLOC_HINT_FLAG_APPEND_ONLY = 16,
    ALLOC_HINT_FLAG_IMMUTABLE = 32,
    ALLOC_HINT_FLAG_SHORTLIVED = 64,
    ALLOC_HINT_FLAG_LONGLIVED = 128,
    ALLOC_HINT_FLAG_COMPRESSIBLE = 256,
    ALLOC_HINT_FLAG_INCOMPRESSIBLE = 512,
  };






  class ObjectOperation
  {
  public:
    ObjectOperation();
    virtual ~ObjectOperation();

    size_t size();
    void set_op_flags(ObjectOperationFlags flags) __attribute__((deprecated));

    void set_op_flags2(int flags);

    void cmpext(uint64_t off, const bufferlist& cmp_bl, int *prval);
    void cmpxattr(const char *name, uint8_t op, const bufferlist& val);
    void cmpxattr(const char *name, uint8_t op, uint64_t v);
    void exec(const char *cls, const char *method, bufferlist& inbl);
    void exec(const char *cls, const char *method, bufferlist& inbl, bufferlist *obl, int *prval);
    void exec(const char *cls, const char *method, bufferlist& inbl, ObjectOperationCompletion *completion);





    void assert_version(uint64_t ver);




    void assert_exists();
# 347 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_cmp(
      const std::map<std::string, std::pair<bufferlist, int> > &assertions,
      int *prval);

  protected:
    ObjectOperationImpl *impl;
    ObjectOperation(const ObjectOperation& rhs);
    ObjectOperation& operator=(const ObjectOperation& rhs);
    friend class IoCtx;
    friend class Rados;
  };






  class ObjectWriteOperation : public ObjectOperation
  {
  protected:
    time_t *unused;
  public:
    ObjectWriteOperation() : unused(
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp" 3 4
                                   __null
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
                                       ) {}
    ~ObjectWriteOperation() override {}

    void mtime(time_t *pt);
    void mtime2(struct timespec *pts);

    void create(bool exclusive);
    void create(bool exclusive,
  const std::string& category);

    void write(uint64_t off, const bufferlist& bl);
    void write_full(const bufferlist& bl);
    void writesame(uint64_t off, uint64_t write_len,
     const bufferlist& bl);
    void append(const bufferlist& bl);
    void remove();
    void truncate(uint64_t off);
    void zero(uint64_t off, uint64_t len);
    void rmxattr(const char *name);
    void setxattr(const char *name, const bufferlist& bl);
    void setxattr(const char *name, const bufferlist&& bl);
    void tmap_update(const bufferlist& cmdbl);
    void tmap_put(const bufferlist& bl);
    void selfmanaged_snap_rollback(uint64_t snapid);
# 401 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void snap_rollback(uint64_t snapid);






    void omap_set(const std::map<std::string, bufferlist> &map);






    void omap_set_header(const bufferlist &bl);




    void omap_clear();






    void omap_rm_keys(const std::set<std::string> &to_rm);
# 441 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void copy_from(const std::string& src, const IoCtx& src_ioctx,
     uint64_t src_version, uint32_t src_fadvise_flags);






    void undirty();
# 458 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void set_alloc_hint(uint64_t expected_object_size,
                        uint64_t expected_write_size);
    void set_alloc_hint2(uint64_t expected_object_size,
    uint64_t expected_write_size,
    uint32_t flags);






    void cache_pin();
    void cache_unpin();






    void set_redirect(const std::string& tgt_obj, const IoCtx& tgt_ioctx,
        uint64_t tgt_version, int flag = 0);
    void set_chunk(uint64_t src_offset, uint64_t src_length, const IoCtx& tgt_ioctx,
                   std::string tgt_oid, uint64_t tgt_offset, int flag = 0);
    void tier_promote();
    void unset_manifest();


    friend class IoCtx;
  };






  class ObjectReadOperation : public ObjectOperation
  {
  public:
    ObjectReadOperation() {}
    ~ObjectReadOperation() override {}

    void stat(uint64_t *psize, time_t *pmtime, int *prval);
    void stat2(uint64_t *psize, struct timespec *pts, int *prval);
    void getxattr(const char *name, bufferlist *pbl, int *prval);
    void getxattrs(std::map<std::string, bufferlist> *pattrs, int *prval);
    void read(size_t off, uint64_t len, bufferlist *pbl, int *prval);
    void checksum(rados_checksum_type_t type, const bufferlist &init_value_bl,
    uint64_t off, size_t len, size_t chunk_size, bufferlist *pbl,
    int *prval);




    void sparse_read(uint64_t off, uint64_t len, std::map<uint64_t,uint64_t> *m,
                    bufferlist *data_bl, int *prval);
# 524 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_get_vals(
      const std::string &start_after,
      uint64_t max_return,
      std::map<std::string, bufferlist> *out_vals,
      int *prval) __attribute__ ((deprecated));
# 540 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_get_vals2(
      const std::string &start_after,
      uint64_t max_return,
      std::map<std::string, bufferlist> *out_vals,
      bool *pmore,
      int *prval);
# 558 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_get_vals(
      const std::string &start_after,
      const std::string &filter_prefix,
      uint64_t max_return,
      std::map<std::string, bufferlist> *out_vals,
      int *prval) __attribute__ ((deprecated));
# 577 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_get_vals2(
      const std::string &start_after,
      const std::string &filter_prefix,
      uint64_t max_return,
      std::map<std::string, bufferlist> *out_vals,
      bool *pmore,
      int *prval);
# 596 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_get_keys(const std::string &start_after,
                       uint64_t max_return,
                       std::set<std::string> *out_keys,
                       int *prval) __attribute__ ((deprecated));
# 612 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_get_keys2(const std::string &start_after,
   uint64_t max_return,
   std::set<std::string> *out_keys,
   bool *pmore,
   int *prval);







    void omap_get_header(bufferlist *header, int *prval);
# 633 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void omap_get_vals_by_keys(const std::set<std::string> &keys,
          std::map<std::string, bufferlist> *map,
          int *prval);







    void list_watchers(std::list<obj_watch_t> *out_watchers, int *prval);
# 659 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void list_snaps(snap_set_t *out_snaps, int *prval);







    void is_dirty(bool *isdirty, int *prval);
# 676 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void cache_flush();
# 685 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    void cache_try_flush();







    void cache_evict();
  };
# 710 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
  class IoCtx
  {
  public:
    IoCtx();
    static void from_rados_ioctx_t(rados_ioctx_t p, IoCtx &pool);
    IoCtx(const IoCtx& rhs);
    IoCtx& operator=(const IoCtx& rhs);
    IoCtx(IoCtx&& rhs) noexcept;
    IoCtx& operator=(IoCtx&& rhs) noexcept;

    ~IoCtx();

    bool is_valid() const;


    void close();


    void dup(const IoCtx& rhs);


    int set_auid(uint64_t auid_)
      __attribute__ ((deprecated));


    int set_auid_async(uint64_t auid_, PoolAsyncCompletion *c)
      __attribute__ ((deprecated));


    int get_auid(uint64_t *auid_)
      __attribute__ ((deprecated));

    uint64_t get_instance_id() const;

    std::string get_pool_name();

    bool pool_requires_alignment();
    int pool_requires_alignment2(bool * req);
    uint64_t pool_required_alignment();
    int pool_required_alignment2(uint64_t * alignment);


    int create(const std::string& oid, bool exclusive);
    int create(const std::string& oid, bool exclusive,
        const std::string& category);






    int write(const std::string& oid, bufferlist& bl, size_t len, uint64_t off);





    int append(const std::string& oid, bufferlist& bl, size_t len);





    int write_full(const std::string& oid, bufferlist& bl);
    int writesame(const std::string& oid, bufferlist& bl,
    size_t write_len, uint64_t off);
    int read(const std::string& oid, bufferlist& bl, size_t len, uint64_t off);
    int checksum(const std::string& o, rados_checksum_type_t type,
   const bufferlist &init_value_bl, size_t len, uint64_t off,
   size_t chunk_size, bufferlist *pbl);
    int remove(const std::string& oid);
    int remove(const std::string& oid, int flags);
    int trunc(const std::string& oid, uint64_t size);
    int mapext(const std::string& o, uint64_t off, size_t len, std::map<uint64_t,uint64_t>& m);
    int cmpext(const std::string& o, uint64_t off, bufferlist& cmp_bl);
    int sparse_read(const std::string& o, std::map<uint64_t,uint64_t>& m, bufferlist& bl, size_t len, uint64_t off);
    int getxattr(const std::string& oid, const char *name, bufferlist& bl);
    int getxattrs(const std::string& oid, std::map<std::string, bufferlist>& attrset);
    int setxattr(const std::string& oid, const char *name, bufferlist& bl);
    int rmxattr(const std::string& oid, const char *name);
    int stat(const std::string& oid, uint64_t *psize, time_t *pmtime);
    int stat2(const std::string& oid, uint64_t *psize, struct timespec *pts);
    int exec(const std::string& oid, const char *cls, const char *method,
      bufferlist& inbl, bufferlist& outbl);





    int tmap_update(const std::string& oid, bufferlist& cmdbl);

    int omap_get_vals(const std::string& oid,
                      const std::string& start_after,
                      uint64_t max_return,
                      std::map<std::string, bufferlist> *out_vals);
    int omap_get_vals2(const std::string& oid,
         const std::string& start_after,
         uint64_t max_return,
         std::map<std::string, bufferlist> *out_vals,
         bool *pmore);
    int omap_get_vals(const std::string& oid,
                      const std::string& start_after,
                      const std::string& filter_prefix,
                      uint64_t max_return,
                      std::map<std::string, bufferlist> *out_vals);
    int omap_get_vals2(const std::string& oid,
         const std::string& start_after,
         const std::string& filter_prefix,
         uint64_t max_return,
         std::map<std::string, bufferlist> *out_vals,
         bool *pmore);
    int omap_get_keys(const std::string& oid,
                      const std::string& start_after,
                      uint64_t max_return,
                      std::set<std::string> *out_keys);
    int omap_get_keys2(const std::string& oid,
         const std::string& start_after,
         uint64_t max_return,
         std::set<std::string> *out_keys,
         bool *pmore);
    int omap_get_header(const std::string& oid,
                        bufferlist *bl);
    int omap_get_vals_by_keys(const std::string& oid,
                              const std::set<std::string>& keys,
                              std::map<std::string, bufferlist> *vals);
    int omap_set(const std::string& oid,
                 const std::map<std::string, bufferlist>& map);
    int omap_set_header(const std::string& oid,
                        const bufferlist& bl);
    int omap_clear(const std::string& oid);
    int omap_rm_keys(const std::string& oid,
                     const std::set<std::string>& keys);

    void snap_set_read(snap_t seq);
    int selfmanaged_snap_set_write_ctx(snap_t seq, std::vector<snap_t>& snaps);


    int snap_create(const char *snapname);



    int snap_lookup(const char *snapname, snap_t *snap);


    int snap_get_stamp(snap_t snapid, time_t *t);


    int snap_get_name(snap_t snapid, std::string *s);


    int snap_remove(const char *snapname);

    int snap_list(std::vector<snap_t> *snaps);

    int snap_rollback(const std::string& oid, const char *snapname);


    int rollback(const std::string& oid, const char *snapname)
      __attribute__ ((deprecated));

    int selfmanaged_snap_create(uint64_t *snapid);
    void aio_selfmanaged_snap_create(uint64_t *snapid, AioCompletion *c);

    int selfmanaged_snap_remove(uint64_t snapid);
    void aio_selfmanaged_snap_remove(uint64_t snapid, AioCompletion *c);

    int selfmanaged_snap_rollback(const std::string& oid, uint64_t snapid);


    int lock_exclusive(const std::string &oid, const std::string &name,
         const std::string &cookie,
         const std::string &description,
         struct timeval * duration, uint8_t flags);

    int lock_shared(const std::string &oid, const std::string &name,
      const std::string &cookie, const std::string &tag,
      const std::string &description,
      struct timeval * duration, uint8_t flags);

    int unlock(const std::string &oid, const std::string &name,
        const std::string &cookie);

    int break_lock(const std::string &oid, const std::string &name,
     const std::string &client, const std::string &cookie);

    int list_lockers(const std::string &oid, const std::string &name,
       int *exclusive,
       std::string *tag,
       std::list<librados::locker_t> *lockers);



    NObjectIterator nobjects_begin(const bufferlist &filter=bufferlist());


    NObjectIterator nobjects_begin(uint32_t start_hash_position,
                                   const bufferlist &filter=bufferlist());


    NObjectIterator nobjects_begin(const librados::ObjectCursor& cursor,
                                   const bufferlist &filter=bufferlist());

    const NObjectIterator& nobjects_end() const;


    ObjectCursor object_list_begin();


    ObjectCursor object_list_end();


    bool object_list_is_end(const ObjectCursor &oc);


    int object_list(const ObjectCursor &start, const ObjectCursor &finish,
                    const size_t result_count,
                    const bufferlist &filter,
                    std::vector<ObjectItem> *result,
                    ObjectCursor *next);


    void object_list_slice(
        const ObjectCursor start,
        const ObjectCursor finish,
        const size_t n,
        const size_t m,
        ObjectCursor *split_start,
        ObjectCursor *split_finish);
# 946 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int hit_set_list(uint32_t hash, AioCompletion *c,
       std::list< std::pair<time_t, time_t> > *pls);
# 957 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int hit_set_get(uint32_t hash, AioCompletion *c, time_t stamp,
      bufferlist *pbl);

    uint64_t get_last_version();

    int aio_read(const std::string& oid, AioCompletion *c,
   bufferlist *pbl, size_t len, uint64_t off);
# 982 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int aio_read(const std::string& oid, AioCompletion *c,
   bufferlist *pbl, size_t len, uint64_t off, uint64_t snapid);
    int aio_sparse_read(const std::string& oid, AioCompletion *c,
   std::map<uint64_t,uint64_t> *m, bufferlist *data_bl,
   size_t len, uint64_t off);
# 1009 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int aio_sparse_read(const std::string& oid, AioCompletion *c,
   std::map<uint64_t,uint64_t> *m, bufferlist *data_bl,
   size_t len, uint64_t off, uint64_t snapid);
# 1022 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int aio_cmpext(const std::string& oid,
     librados::AioCompletion *c,
     uint64_t off,
     bufferlist& cmp_bl);
    int aio_write(const std::string& oid, AioCompletion *c, const bufferlist& bl,
    size_t len, uint64_t off);
    int aio_append(const std::string& oid, AioCompletion *c, const bufferlist& bl,
    size_t len);
    int aio_write_full(const std::string& oid, AioCompletion *c, const bufferlist& bl);
    int aio_writesame(const std::string& oid, AioCompletion *c, const bufferlist& bl,
        size_t write_len, uint64_t off);
# 1047 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int aio_remove(const std::string& oid, AioCompletion *c);
    int aio_remove(const std::string& oid, AioCompletion *c, int flags);






    int aio_flush();
# 1065 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int aio_flush_async(AioCompletion *c);
    int aio_getxattr(const std::string& oid, AioCompletion *c, const char *name, bufferlist& bl);
    int aio_getxattrs(const std::string& oid, AioCompletion *c, std::map<std::string, bufferlist>& attrset);
    int aio_setxattr(const std::string& oid, AioCompletion *c, const char *name, bufferlist& bl);
    int aio_rmxattr(const std::string& oid, AioCompletion *c, const char *name);
    int aio_stat(const std::string& oid, AioCompletion *c, uint64_t *psize, time_t *pmtime);
    int aio_stat2(const std::string& oid, AioCompletion *c, uint64_t *psize, struct timespec *pts);







    int aio_cancel(AioCompletion *c);

    int aio_exec(const std::string& oid, AioCompletion *c, const char *cls, const char *method,
          bufferlist& inbl, bufferlist *outbl);




    int aio_unlock(const std::string &oid, const std::string &name,
            const std::string &cookie, AioCompletion *c);


    int operate(const std::string& oid, ObjectWriteOperation *op);
    int operate(const std::string& oid, ObjectReadOperation *op, bufferlist *pbl);
    int aio_operate(const std::string& oid, AioCompletion *c, ObjectWriteOperation *op);
    int aio_operate(const std::string& oid, AioCompletion *c, ObjectWriteOperation *op, int flags);
# 1109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int aio_operate(const std::string& oid, AioCompletion *c,
      ObjectWriteOperation *op, snap_t seq,
      std::vector<snap_t>& snaps);
    int aio_operate(const std::string& oid, AioCompletion *c,
        ObjectWriteOperation *op, snap_t seq,
        std::vector<snap_t>& snaps,
        const blkin_trace_info *trace_info);
    int aio_operate(const std::string& oid, AioCompletion *c,
        ObjectWriteOperation *op, snap_t seq,
        std::vector<snap_t>& snaps, int flags,
        const blkin_trace_info *trace_info);
    int aio_operate(const std::string& oid, AioCompletion *c,
      ObjectReadOperation *op, bufferlist *pbl);

    int aio_operate(const std::string& oid, AioCompletion *c,
      ObjectReadOperation *op, snap_t snapid, int flags,
      bufferlist *pbl)
      __attribute__ ((deprecated));

    int aio_operate(const std::string& oid, AioCompletion *c,
      ObjectReadOperation *op, int flags,
      bufferlist *pbl);
    int aio_operate(const std::string& oid, AioCompletion *c,
        ObjectReadOperation *op, int flags,
        bufferlist *pbl, const blkin_trace_info *trace_info);


    int watch2(const std::string& o, uint64_t *handle,
        librados::WatchCtx2 *ctx);
    int watch3(const std::string& o, uint64_t *handle,
        librados::WatchCtx2 *ctx, uint32_t timeout);
    int aio_watch(const std::string& o, AioCompletion *c, uint64_t *handle,
        librados::WatchCtx2 *ctx);
    int aio_watch2(const std::string& o, AioCompletion *c, uint64_t *handle,
        librados::WatchCtx2 *ctx, uint32_t timeout);
    int unwatch2(uint64_t handle);
    int aio_unwatch(uint64_t handle, AioCompletion *c);
# 1167 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int notify2(const std::string& o,
  bufferlist& bl,
  uint64_t timeout_ms,
  bufferlist *pbl);
    int aio_notify(const std::string& o,
                   AioCompletion *c,
                   bufferlist& bl,
                   uint64_t timeout_ms,
                   bufferlist *pbl);

    int list_watchers(const std::string& o, std::list<obj_watch_t> *out_watchers);
    int list_snaps(const std::string& o, snap_set_t *out_snaps);
    void set_notify_timeout(uint32_t timeout);


    void notify_ack(const std::string& o,
      uint64_t notify_id,
      uint64_t cookie,
      bufferlist& bl);
# 1201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int watch_check(uint64_t cookie);


    int watch(const std::string& o, uint64_t ver, uint64_t *cookie,
       librados::WatchCtx *ctx) __attribute__ ((deprecated));
    int notify(const std::string& o, uint64_t ver, bufferlist& bl)
      __attribute__ ((deprecated));
    int unwatch(const std::string& o, uint64_t cookie)
      __attribute__ ((deprecated));
# 1223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int set_alloc_hint(const std::string& o,
                       uint64_t expected_object_size,
                       uint64_t expected_write_size);
    int set_alloc_hint2(const std::string& o,
   uint64_t expected_object_size,
   uint64_t expected_write_size,
   uint32_t flags);


    void set_assert_version(uint64_t ver);







    int cache_pin(const std::string& o);
    int cache_unpin(const std::string& o);

    std::string get_pool_name() const;

    void locator_set_key(const std::string& key);
    void set_namespace(const std::string& nspace);
    std::string get_namespace() const;

    int64_t get_id();


    uint32_t get_object_hash_position(const std::string& oid)
      __attribute__ ((deprecated));
    uint32_t get_object_pg_hash_position(const std::string& oid)
      __attribute__ ((deprecated));

    int get_object_hash_position2(const std::string& oid, uint32_t *hash_position);
    int get_object_pg_hash_position2(const std::string& oid, uint32_t *pg_hash_position);

    config_t cct();

    void set_osdmap_full_try();
    void unset_osdmap_full_try();

    int application_enable(const std::string& app_name, bool force);
    int application_enable_async(const std::string& app_name,
                                 bool force, PoolAsyncCompletion *c);
    int application_list(std::set<std::string> *app_names);
    int application_metadata_get(const std::string& app_name,
                                 const std::string &key,
                                 std::string *value);
    int application_metadata_set(const std::string& app_name,
                                 const std::string &key,
                                 const std::string& value);
    int application_metadata_remove(const std::string& app_name,
                                    const std::string &key);
    int application_metadata_list(const std::string& app_name,
                                  std::map<std::string, std::string> *values);

  private:

    IoCtx(IoCtxImpl *io_ctx_impl_);

    friend class Rados;
    friend class libradosstriper::RadosStriper;
    friend class ObjectWriteOperation;

    IoCtxImpl *io_ctx_impl;
  };

  struct PlacementGroup {
    PlacementGroup();
    PlacementGroup(const PlacementGroup&);
    ~PlacementGroup();
    bool parse(const char*);
    std::unique_ptr<PlacementGroupImpl> impl;
  };

  std::ostream& operator<<(std::ostream&, const PlacementGroup&);

  class Rados
  {
  public:
    static void version(int *major, int *minor, int *extra);

    Rados();
    explicit Rados(IoCtx& ioctx);
    ~Rados();
    static void from_rados_t(rados_t cluster, Rados &rados);

    int init(const char * const id);
    int init2(const char * const name, const char * const clustername,
       uint64_t flags);
    int init_with_context(config_t cct_);
    config_t cct();
    int connect();
    void shutdown();
    int watch_flush();
    int aio_watch_flush(AioCompletion*);
    int conf_read_file(const char * const path) const;
    int conf_parse_argv(int argc, const char ** argv) const;
    int conf_parse_argv_remainder(int argc, const char ** argv,
      const char ** remargv) const;
    int conf_parse_env(const char *env) const;
    int conf_set(const char *option, const char *value);
    int conf_get(const char *option, std::string &val);

    int service_daemon_register(
      const std::string& service,
      const std::string& name,
      const std::map<std::string,std::string>& metadata);
    int service_daemon_update_status(
      std::map<std::string,std::string>&& status);

    int pool_create(const char *name);
    int pool_create(const char *name, uint64_t auid)
      __attribute__ ((deprecated));
    int pool_create(const char *name, uint64_t auid, uint8_t crush_rule)
      __attribute__ ((deprecated));
    int pool_create_with_rule(const char *name, uint8_t crush_rule);
    int pool_create_async(const char *name, PoolAsyncCompletion *c);
    int pool_create_async(const char *name, uint64_t auid, PoolAsyncCompletion *c)
      __attribute__ ((deprecated));
    int pool_create_async(const char *name, uint64_t auid, uint8_t crush_rule, PoolAsyncCompletion *c)
      __attribute__ ((deprecated));
    int pool_create_with_rule_async(const char *name, uint8_t crush_rule, PoolAsyncCompletion *c);
    int pool_get_base_tier(int64_t pool, int64_t* base_tier);
    int pool_delete(const char *name);
    int pool_delete_async(const char *name, PoolAsyncCompletion *c);
    int64_t pool_lookup(const char *name);
    int pool_reverse_lookup(int64_t id, std::string *name);

    uint64_t get_instance_id();

    int get_min_compatible_osd(int8_t* require_osd_release);
    int get_min_compatible_client(int8_t* min_compat_client,
                                  int8_t* require_min_compat_client);

    int mon_command(std::string cmd, const bufferlist& inbl,
      bufferlist *outbl, std::string *outs);
    int mgr_command(std::string cmd, const bufferlist& inbl,
      bufferlist *outbl, std::string *outs);
    int osd_command(int osdid, std::string cmd, const bufferlist& inbl,
                    bufferlist *outbl, std::string *outs);
    int pg_command(const char *pgstr, std::string cmd, const bufferlist& inbl,
                   bufferlist *outbl, std::string *outs);

    int ioctx_create(const char *name, IoCtx &pioctx);
    int ioctx_create2(int64_t pool_id, IoCtx &pioctx);


    void test_blacklist_self(bool set);


    int pool_list(std::list<std::string>& v);
    int pool_list2(std::list<std::pair<int64_t, std::string> >& v);
    int get_pool_stats(std::list<std::string>& v,
         stats_map& result);

    int get_pool_stats(std::list<std::string>& v,
         std::map<std::string, stats_map>& stats);

    int get_pool_stats(std::list<std::string>& v,
                       std::string& category,
         std::map<std::string, stats_map>& stats);

    bool get_pool_is_selfmanaged_snaps_mode(const std::string& poolname);

    int cluster_stat(cluster_stat_t& result);
    int cluster_fsid(std::string *fsid);







    int get_inconsistent_pgs(int64_t pool_id,
                             std::vector<PlacementGroup>* pgs);
# 1412 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int get_inconsistent_objects(const PlacementGroup& pg,
                                 const object_id_t &start_after,
                                 unsigned max_return,
                                 AioCompletion *c,
                                 std::vector<inconsistent_obj_t>* objects,
                                 uint32_t* interval);
# 1430 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados.hpp"
    int get_inconsistent_snapsets(const PlacementGroup& pg,
                                  const object_id_t &start_after,
                                  unsigned max_return,
                                  AioCompletion *c,
                                  std::vector<inconsistent_snapset_t>* snapset,
                                  uint32_t* interval);


    int wait_for_latest_osdmap();

    int blacklist_add(const std::string& client_address,
                      uint32_t expire_seconds);







    static PoolAsyncCompletion *pool_async_create_completion();


    static AioCompletion *aio_create_completion();
    static AioCompletion *aio_create_completion(void *cb_arg, callback_t cb_complete,
      callback_t cb_safe);

    friend std::ostream& operator<<(std::ostream &oss, const Rados& r);
  private:

    Rados(const Rados& rhs);
    const Rados& operator=(const Rados& rhs);
    RadosClient *client;
  };

}
}
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2

namespace ceph {
  class Formatter;
}

using ceph::crypto::MD5;
# 255 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
struct req_state;

typedef void *RGWAccessHandle;


int gen_rand_base64(CephContext *cct, char *dest, int size);
void gen_rand_alphanumeric(CephContext *cct, char *dest, int size);
void gen_rand_alphanumeric_lower(CephContext *cct, char *dest, int size);
void gen_rand_alphanumeric_upper(CephContext *cct, char *dest, int size);
void gen_rand_alphanumeric_no_underscore(CephContext *cct, char *dest, int size);
void gen_rand_alphanumeric_plain(CephContext *cct, char *dest, int size);
void gen_rand_alphanumeric_lower(CephContext *cct, string *str, int length);

enum RGWIntentEvent {
  DEL_OBJ = 0,
  DEL_DIR = 1,
};

enum HostStyle {
  PathStyle = 0,
  VirtualStyle = 1,
};


struct rgw_err {
  rgw_err();
  void clear();
  bool is_clear() const;
  bool is_err() const;
  friend std::ostream& operator<<(std::ostream& oss, const rgw_err &err);

  int http_ret;
  int ret;
  std::string err_code;
  std::string message;
};




class NameVal
{
   const std::string str;
   std::string name;
   std::string val;
 public:
    explicit NameVal(const std::string& nv) : str(nv) {}

    int parse();

    std::string& get_name() { return name; }
    std::string& get_val() { return val; }
};


class RGWHTTPArgs {
  std::string str, empty_str;
  std::map<std::string, std::string> val_map;
  std::map<std::string, std::string> sys_val_map;
  std::map<std::string, std::string> sub_resources;
  bool has_resp_modifier = false;
  bool admin_subresource_added = false;
 public:
  RGWHTTPArgs() = default;
  explicit RGWHTTPArgs(const std::string& s) {
      set(s);
      parse();
  }


  void set(const std::string& s) {
    has_resp_modifier = false;
    val_map.clear();
    sub_resources.clear();
    str = s;
  }

  int parse();
  void append(const std::string& name, const string& val);

  const string& get(const std::string& name, bool *exists = 
# 335 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
                                                           __null
# 335 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
                                                               ) const;
  boost::optional<const std::string&>
  get_optional(const std::string& name) const;
  int get_bool(const std::string& name, bool *val, bool *exists);
  int get_bool(const char *name, bool *val, bool *exists);
  void get_bool(const char *name, bool *val, bool def_val);
  int get_int(const char *name, int *val, int def_val);


  std::string sys_get(const std::string& name, bool *exists = nullptr) const;


  bool exists(const char *name) const {
    return (val_map.find(name) != std::end(val_map));
  }
  bool sub_resource_exists(const char *name) const {
    return (sub_resources.find(name) != std::end(sub_resources));
  }
  std::map<std::string, std::string>& get_params() {
    return val_map;
  }
  const std::map<std::string, std::string>& get_sub_resources() const {
    return sub_resources;
  }
  unsigned get_num_params() const {
    return val_map.size();
  }
  bool has_response_modifier() const {
    return has_resp_modifier;
  }
  void set_system() {
    std::map<std::string, std::string>::iterator iter;
    for (iter = sys_val_map.begin(); iter != sys_val_map.end(); ++iter) {
      val_map[iter->first] = iter->second;
    }
  }
  const std::string& get_str() {
    return str;
  }
};

const char *rgw_conf_get(const map<string, string, ltstr_nocase>& conf_map, const char *name, const char *def_val);
int rgw_conf_get_int(const map<string, string, ltstr_nocase>& conf_map, const char *name, int def_val);
bool rgw_conf_get_bool(const map<string, string, ltstr_nocase>& conf_map, const char *name, bool def_val);

class RGWEnv;

class RGWConf {
  friend class RGWEnv;
  int enable_ops_log;
  int enable_usage_log;
  uint8_t defer_to_bucket_acls;
  void init(CephContext *cct);
public:
  RGWConf()
    : enable_ops_log(1),
      enable_usage_log(1),
      defer_to_bucket_acls(0) {
  }
};

class RGWEnv {
  std::map<string, string, ltstr_nocase> env_map;
  RGWConf conf;
public:
  void init(CephContext *cct);
  void init(CephContext *cct, char **envp);
  void set(std::string name, std::string val);
  const char *get(const char *name, const char *def_val = nullptr) const;
  int get_int(const char *name, int def_val = 0) const;
  bool get_bool(const char *name, bool def_val = 0);
  size_t get_size(const char *name, size_t def_val = 0) const;
  bool exists(const char *name) const;
  bool exists_prefix(const char *prefix) const;
  void remove(const char *name);
  const std::map<string, string, ltstr_nocase>& get_map() const { return env_map; }
  int get_enable_ops_log() const {
    return conf.enable_ops_log;
  }

  int get_enable_usage_log() const {
    return conf.enable_usage_log;
  }

  int get_defer_to_bucket_acls() const {
    return conf.defer_to_bucket_acls;
  }
};



bool rgw_transport_is_secure(CephContext *cct, const RGWEnv& env);

enum http_op {
  OP_GET,
  OP_PUT,
  OP_DELETE,
  OP_HEAD,
  OP_POST,
  OP_COPY,
  OP_OPTIONS,
  OP_UNKNOWN,
};

enum RGWOpType {
  RGW_OP_UNKNOWN = 0,
  RGW_OP_GET_OBJ,
  RGW_OP_LIST_BUCKETS,
  RGW_OP_STAT_ACCOUNT,
  RGW_OP_LIST_BUCKET,
  RGW_OP_GET_BUCKET_LOGGING,
  RGW_OP_GET_BUCKET_LOCATION,
  RGW_OP_GET_BUCKET_VERSIONING,
  RGW_OP_SET_BUCKET_VERSIONING,
  RGW_OP_GET_BUCKET_WEBSITE,
  RGW_OP_SET_BUCKET_WEBSITE,
  RGW_OP_STAT_BUCKET,
  RGW_OP_CREATE_BUCKET,
  RGW_OP_DELETE_BUCKET,
  RGW_OP_PUT_OBJ,
  RGW_OP_STAT_OBJ,
  RGW_OP_POST_OBJ,
  RGW_OP_PUT_METADATA_ACCOUNT,
  RGW_OP_PUT_METADATA_BUCKET,
  RGW_OP_PUT_METADATA_OBJECT,
  RGW_OP_SET_TEMPURL,
  RGW_OP_DELETE_OBJ,
  RGW_OP_COPY_OBJ,
  RGW_OP_GET_ACLS,
  RGW_OP_PUT_ACLS,
  RGW_OP_GET_CORS,
  RGW_OP_PUT_CORS,
  RGW_OP_DELETE_CORS,
  RGW_OP_OPTIONS_CORS,
  RGW_OP_GET_REQUEST_PAYMENT,
  RGW_OP_SET_REQUEST_PAYMENT,
  RGW_OP_INIT_MULTIPART,
  RGW_OP_COMPLETE_MULTIPART,
  RGW_OP_ABORT_MULTIPART,
  RGW_OP_LIST_MULTIPART,
  RGW_OP_LIST_BUCKET_MULTIPARTS,
  RGW_OP_DELETE_MULTI_OBJ,
  RGW_OP_BULK_DELETE,
  RGW_OP_SET_ATTRS,
  RGW_OP_GET_CROSS_DOMAIN_POLICY,
  RGW_OP_GET_HEALTH_CHECK,
  RGW_OP_GET_INFO,
  RGW_OP_CREATE_ROLE,
  RGW_OP_DELETE_ROLE,
  RGW_OP_GET_ROLE,
  RGW_OP_MODIFY_ROLE,
  RGW_OP_LIST_ROLES,
  RGW_OP_PUT_ROLE_POLICY,
  RGW_OP_GET_ROLE_POLICY,
  RGW_OP_LIST_ROLE_POLICIES,
  RGW_OP_DELETE_ROLE_POLICY,
  RGW_OP_PUT_BUCKET_POLICY,
  RGW_OP_GET_BUCKET_POLICY,
  RGW_OP_DELETE_BUCKET_POLICY,
  RGW_OP_PUT_OBJ_TAGGING,
  RGW_OP_GET_OBJ_TAGGING,
  RGW_OP_DELETE_OBJ_TAGGING,
  RGW_OP_PUT_LC,
  RGW_OP_GET_LC,
  RGW_OP_DELETE_LC,
  RGW_OP_PUT_USER_POLICY,
  RGW_OP_GET_USER_POLICY,
  RGW_OP_LIST_USER_POLICIES,
  RGW_OP_DELETE_USER_POLICY,
  RGW_OP_PUT_BUCKET_OBJ_LOCK,
  RGW_OP_GET_BUCKET_OBJ_LOCK,
  RGW_OP_PUT_OBJ_RETENTION,
  RGW_OP_GET_OBJ_RETENTION,
  RGW_OP_PUT_OBJ_LEGAL_HOLD,
  RGW_OP_GET_OBJ_LEGAL_HOLD,

  RGW_OP_ADMIN_SET_METADATA,
  RGW_OP_GET_OBJ_LAYOUT,
  RGW_OP_BULK_UPLOAD,
  RGW_OP_METADATA_SEARCH,
  RGW_OP_CONFIG_BUCKET_META_SEARCH,
  RGW_OP_GET_BUCKET_META_SEARCH,
  RGW_OP_DEL_BUCKET_META_SEARCH,

  RGW_STS_ASSUME_ROLE,
  RGW_STS_GET_SESSION_TOKEN,
  RGW_STS_ASSUME_ROLE_WEB_IDENTITY,

  RGW_OP_PUBSUB_TOPIC_CREATE,
  RGW_OP_PUBSUB_TOPICS_LIST,
  RGW_OP_PUBSUB_TOPIC_GET,
  RGW_OP_PUBSUB_TOPIC_DELETE,
  RGW_OP_PUBSUB_SUB_CREATE,
  RGW_OP_PUBSUB_SUB_GET,
  RGW_OP_PUBSUB_SUB_DELETE,
  RGW_OP_PUBSUB_SUB_PULL,
  RGW_OP_PUBSUB_SUB_ACK,
  RGW_OP_PUBSUB_NOTIF_CREATE,
  RGW_OP_PUBSUB_NOTIF_DELETE,
  RGW_OP_PUBSUB_NOTIF_LIST,
};

class RGWAccessControlPolicy;
class JSONObj;

struct RGWAccessKey {
  string id;
  string key;
  string subuser;

  RGWAccessKey() {}
  RGWAccessKey(std::string _id, std::string _key)
    : id(std::move(_id)), key(std::move(_key)) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(id, bl);
    encode(key, bl);
    encode(subuser, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } else if (3u) { if (bl.get_remaining() < 3u) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); bl.advance(3u); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
     decode(id, bl);
     decode(key, bl);
     decode(subuser, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void dump_plain(Formatter *f) const;
  void dump(Formatter *f, const string& user, bool swift) const;
  static void generate_test_instances(list<RGWAccessKey*>& o);

  void decode_json(JSONObj *obj);
  void decode_json(JSONObj *obj, bool swift);
};
inline void encode(const RGWAccessKey &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWAccessKey &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWSubUser {
  string name;
  uint32_t perm_mask;

  RGWSubUser() : perm_mask(0) {}
  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(name, bl);
    encode(perm_mask, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } else if (3u) { if (bl.get_remaining() < 3u) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); bl.advance(3u); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
     decode(name, bl);
     decode(perm_mask, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void dump(Formatter *f, const string& user) const;
  static void generate_test_instances(list<RGWSubUser*>& o);

  void decode_json(JSONObj *obj);
};
inline void encode(const RGWSubUser &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWSubUser &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWUserCaps
{
  map<string, uint32_t> caps;

  int get_cap(const string& cap, string& type, uint32_t *perm);
  int add_cap(const string& cap);
  int remove_cap(const string& cap);
public:
  static int parse_cap_perm(const string& str, uint32_t *perm);
  int add_from_string(const string& str);
  int remove_from_string(const string& str);

  void encode(bufferlist& bl) const {
     __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
     encode(caps, bl);
     } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(caps, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  int check_cap(const string& cap, uint32_t perm);
  bool is_valid_cap_type(const string& tp);
  void dump(Formatter *f) const;
  void dump(Formatter *f, const char *name) const;

  void decode_json(JSONObj *obj);
};
inline void encode(const RGWUserCaps &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWUserCaps &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

void encode_json(const char *name, const obj_version& v, Formatter *f);
void encode_json(const char *name, const RGWUserCaps& val, Formatter *f);

void decode_json_obj(obj_version& v, JSONObj *obj);



enum RGWIdentityType
{
  TYPE_NONE=0,
  TYPE_RGW=1,
  TYPE_KEYSTONE=2,
  TYPE_LDAP=3,
  TYPE_ROLE=4,
  TYPE_WEB=5,
};

static string RGW_STORAGE_CLASS_STANDARD = "STANDARD";

struct rgw_placement_rule {
  std::string name;
  std::string storage_class;

  rgw_placement_rule() {}
  rgw_placement_rule(const string& _n, const string& _sc) : name(_n), storage_class(_sc) {}
  rgw_placement_rule(const rgw_placement_rule& _r, const string& _sc) : name(_r.name) {
    if (!_sc.empty()) {
      storage_class = _sc;
    } else {
      storage_class = _r.storage_class;
    }
  }

  bool empty() const {
    return name.empty() && storage_class.empty();
  }

  void inherit_from(const rgw_placement_rule& r) {
    if (name.empty()) {
      name = r.name;
    }
    if (storage_class.empty()) {
      storage_class = r.storage_class;
    }
  }

  void clear() {
    name.clear();
    storage_class.clear();
  }

  void init(const string& n, const string& c) {
    name = n;
    storage_class = c;
  }

  static const string& get_canonical_storage_class(const string& storage_class) {
    if (storage_class.empty()) {
      return RGW_STORAGE_CLASS_STANDARD;
    }
    return storage_class;
  }

  const string& get_storage_class() const {
    return get_canonical_storage_class(storage_class);
  }

  int compare(const rgw_placement_rule& r) const {
    int c = name.compare(r.name);
    if (c != 0) {
      return c;
    }
    return get_storage_class().compare(r.get_storage_class());
  }

  bool operator==(const rgw_placement_rule& r) const {
    return (name == r.name &&
            get_storage_class() == r.get_storage_class());
  }

  bool operator!=(const rgw_placement_rule& r) const {
    return !(*this == r);
  }

  void encode(bufferlist& bl) const {

    std::string s = to_str();
    ceph::encode(s, bl);
  }

  void decode(bufferlist::const_iterator& bl) {
    std::string s;
    ceph::decode(s, bl);
    from_str(s);
  }

  std::string to_str() const {
    if (standard_storage_class()) {
      return name;
    }
    return to_str_explicit();
  }

  std::string to_str_explicit() const {
    return name + "/" + storage_class;
  }

  void from_str(const std::string& s) {
    size_t pos = s.find("/");
    if (pos == std::string::npos) {
      name = s;
      storage_class.clear();
      return;
    }
    name = s.substr(0, pos);
    storage_class = s.substr(pos + 1);
  }

  bool standard_storage_class() const {
    return storage_class.empty() || storage_class == RGW_STORAGE_CLASS_STANDARD;
  }
};
inline void encode(const rgw_placement_rule &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_placement_rule &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

void encode_json(const char *name, const rgw_placement_rule& val, ceph::Formatter *f);
void decode_json_obj(rgw_placement_rule& v, JSONObj *obj);

inline ostream& operator<<(ostream& out, const rgw_placement_rule& rule) {
  return out << rule.to_str();
}
struct RGWUserInfo
{
  rgw_user user_id;
  string display_name;
  string user_email;
  map<string, RGWAccessKey> access_keys;
  map<string, RGWAccessKey> swift_keys;
  map<string, RGWSubUser> subusers;
  __u8 suspended;
  int32_t max_buckets;
  uint32_t op_mask;
  RGWUserCaps caps;
  __u8 admin;
  __u8 system;
  rgw_placement_rule default_placement;
  list<string> placement_tags;
  RGWQuotaInfo bucket_quota;
  map<int, string> temp_url_keys;
  RGWQuotaInfo user_quota;
  uint32_t type;
  set<string> mfa_ids;
  string assumed_role_arn;

  RGWUserInfo()
    : suspended(0),
      max_buckets(1000),
      op_mask((0x01 | 0x02 | 0x04)),
      admin(0),
      system(0),
      type(TYPE_NONE) {
  }

  RGWAccessKey* get_key(const string& access_key) {
    if (access_keys.empty())
      return nullptr;

    auto k = access_keys.find(access_key);
    if (k == access_keys.end())
      return nullptr;
    else
      return &(k->second);
  }

  void encode(bufferlist& bl) const {
     __u8 struct_v = 21; __u8 struct_compat = 9; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
     encode((uint64_t)0, bl);
     string access_key;
     string secret_key;
     if (!access_keys.empty()) {
       map<string, RGWAccessKey>::const_iterator iter = access_keys.begin();
       const RGWAccessKey& k = iter->second;
       access_key = k.id;
       secret_key = k.key;
     }
     encode(access_key, bl);
     encode(secret_key, bl);
     encode(display_name, bl);
     encode(user_email, bl);
     string swift_name;
     string swift_key;
     if (!swift_keys.empty()) {
       map<string, RGWAccessKey>::const_iterator iter = swift_keys.begin();
       const RGWAccessKey& k = iter->second;
       swift_name = k.id;
       swift_key = k.key;
     }
     encode(swift_name, bl);
     encode(swift_key, bl);
     encode(user_id.id, bl);
     encode(access_keys, bl);
     encode(subusers, bl);
     encode(suspended, bl);
     encode(swift_keys, bl);
     encode(max_buckets, bl);
     encode(caps, bl);
     encode(op_mask, bl);
     encode(system, bl);
     encode(default_placement, bl);
     encode(placement_tags, bl);
     encode(bucket_quota, bl);
     encode(temp_url_keys, bl);
     encode(user_quota, bl);
     encode(user_id.tenant, bl);
     encode(admin, bl);
     encode(type, bl);
     encode(mfa_ids, bl);
     encode(assumed_role_arn, bl);
     } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
     using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 9) { __u8 struct_compat; decode(struct_compat, bl); if (20 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "20" " < " + std::to_string(struct_compat))); } else if (3u) { if (bl.get_remaining() < 3u) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); bl.advance(3u); } unsigned struct_end = 0; if (struct_v >= 9) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
     if (struct_v >= 2) {
       uint64_t old_auid;
       decode(old_auid, bl);
     }
     string access_key;
     string secret_key;
    decode(access_key, bl);
    decode(secret_key, bl);
    if (struct_v < 6) {
      RGWAccessKey k;
      k.id = access_key;
      k.key = secret_key;
      access_keys[access_key] = k;
    }
    decode(display_name, bl);
    decode(user_email, bl);

    string swift_name;
    string swift_key;
    if (struct_v >= 3) decode(swift_name, bl);
    if (struct_v >= 4) decode(swift_key, bl);
    if (struct_v >= 5)
      decode(user_id.id, bl);
    else
      user_id.id = access_key;
    if (struct_v >= 6) {
      decode(access_keys, bl);
      decode(subusers, bl);
    }
    suspended = 0;
    if (struct_v >= 7) {
      decode(suspended, bl);
    }
    if (struct_v >= 8) {
      decode(swift_keys, bl);
    }
    if (struct_v >= 10) {
      decode(max_buckets, bl);
    } else {
      max_buckets = 1000;
    }
    if (struct_v >= 11) {
      decode(caps, bl);
    }
    if (struct_v >= 12) {
      decode(op_mask, bl);
    } else {
      op_mask = (0x01 | 0x02 | 0x04);
    }
    if (struct_v >= 13) {
      decode(system, bl);
      decode(default_placement, bl);
      decode(placement_tags, bl);
    }
    if (struct_v >= 14) {
      decode(bucket_quota, bl);
    }
    if (struct_v >= 15) {
     decode(temp_url_keys, bl);
    }
    if (struct_v >= 16) {
      decode(user_quota, bl);
    }
    if (struct_v >= 17) {
      decode(user_id.tenant, bl);
    } else {
      user_id.tenant.clear();
    }
    if (struct_v >= 18) {
      decode(admin, bl);
    }
    if (struct_v >= 19) {
      decode(type, bl);
    }
    if (struct_v >= 20) {
      decode(mfa_ids, bl);
    }
    if (struct_v >= 21) {
      decode(assumed_role_arn, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWUserInfo*>& o);

  void decode_json(JSONObj *obj);
};
inline void encode(const RGWUserInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWUserInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_pool {
  std::string name;
  std::string ns;

  rgw_pool() = default;
  rgw_pool(const rgw_pool& _p) : name(_p.name), ns(_p.ns) {}
  rgw_pool(rgw_pool&&) = default;
  rgw_pool(const string& _s) {
    from_str(_s);
  }
  rgw_pool(const string& _name, const string& _ns) : name(_name), ns(_ns) {}

  string to_str() const;
  void from_str(const string& s);

  void init(const string& _s) {
    from_str(_s);
  }

  bool empty() const {
    return name.empty();
  }

  int compare(const rgw_pool& p) const {
    int r = name.compare(p.name);
    if (r != 0) {
      return r;
    }
    return ns.compare(p.ns);
  }

  void encode(bufferlist& bl) const {
     __u8 struct_v = 10; __u8 struct_compat = 10; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(name, bl);
    encode(ns, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode_from_bucket(bufferlist::const_iterator& bl);

  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (10 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "10" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;

    decode(name, bl);

    if (struct_v < 10) {
# 996 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
    } else {
      decode(ns, bl);
    }

    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  rgw_pool& operator=(const rgw_pool&) = default;

  bool operator==(const rgw_pool& p) const {
    return (compare(p) == 0);
  }
  bool operator!=(const rgw_pool& p) const {
    return !(*this == p);
  }
  bool operator<(const rgw_pool& p) const {
    int r = name.compare(p.name);
    if (r == 0) {
      return (ns.compare(p.ns) < 0);
    }
    return (r < 0);
  }
};
inline void encode(const rgw_pool &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_pool &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_data_placement_target {
  rgw_pool data_pool;
  rgw_pool data_extra_pool;
  rgw_pool index_pool;

  rgw_data_placement_target() = default;
  rgw_data_placement_target(const rgw_data_placement_target&) = default;
  rgw_data_placement_target(rgw_data_placement_target&&) = default;

  rgw_data_placement_target(const rgw_pool& data_pool,
                            const rgw_pool& data_extra_pool,
                            const rgw_pool& index_pool)
    : data_pool(data_pool),
      data_extra_pool(data_extra_pool),
      index_pool(index_pool) {
  }

  rgw_data_placement_target&
  operator=(const rgw_data_placement_target&) = default;

  const rgw_pool& get_data_extra_pool() const {
    if (data_extra_pool.empty()) {
      return data_pool;
    }
    return data_extra_pool;
  }

  int compare(const rgw_data_placement_target& t) {
    int c = data_pool.compare(t.data_pool);
    if (c != 0) {
      return c;
    }
    c = data_extra_pool.compare(t.data_extra_pool);
    if (c != 0) {
      return c;
    }
    return index_pool.compare(t.index_pool);
  };

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};

inline ostream& operator<<(ostream& out, const rgw_pool& p) {
  out << p.to_str();
  return out;
}

struct rgw_raw_obj {
  rgw_pool pool;
  std::string oid;
  std::string loc;

  rgw_raw_obj() {}
  rgw_raw_obj(const rgw_pool& _pool, const std::string& _oid) {
    init(_pool, _oid);
  }
  rgw_raw_obj(const rgw_pool& _pool, const std::string& _oid, const string& _loc) : loc(_loc) {
    init(_pool, _oid);
  }

  void init(const rgw_pool& _pool, const std::string& _oid) {
    pool = _pool;
    oid = _oid;
  }

  bool empty() const {
    return oid.empty();
  }

  void encode(bufferlist& bl) const {
     __u8 struct_v = 6; __u8 struct_compat = 6; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(pool, bl);
    encode(oid, bl);
    encode(loc, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode_from_rgw_obj(bufferlist::const_iterator& bl);

  void decode(bufferlist::const_iterator& bl) {
    unsigned ofs = bl.get_off();
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (6 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "6" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    if (struct_v < 6) {




      bl.seek(ofs);
      decode_from_rgw_obj(bl);
      return;
    }
    decode(pool, bl);
    decode(oid, bl);
    decode(loc, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  bool operator<(const rgw_raw_obj& o) const {
    int r = pool.compare(o.pool);
    if (r == 0) {
      r = oid.compare(o.oid);
      if (r == 0) {
        r = loc.compare(o.loc);
      }
    }
    return (r < 0);
  }

  bool operator==(const rgw_raw_obj& o) const {
    return (pool == o.pool && oid == o.oid && loc == o.loc);
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const rgw_raw_obj &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_raw_obj &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

inline ostream& operator<<(ostream& out, const rgw_raw_obj& o) {
  out << o.pool << ":" << o.oid;
  return out;
}

struct rgw_bucket {
  std::string tenant;
  std::string name;
  std::string marker;
  std::string bucket_id;
  rgw_data_placement_target explicit_placement;

  std::string oid;



  rgw_bucket() { }

  explicit rgw_bucket(const rgw_user& u, const cls_user_bucket& b) :
    tenant(u.tenant),
    name(b.name),
    marker(b.marker),
    bucket_id(b.bucket_id),
    explicit_placement(b.explicit_placement.data_pool,
                       b.explicit_placement.data_extra_pool,
                       b.explicit_placement.index_pool) {}
  rgw_bucket(const rgw_bucket&) = default;
  rgw_bucket(rgw_bucket&&) = default;

  void convert(cls_user_bucket *b) const {
    b->name = name;
    b->marker = marker;
    b->bucket_id = bucket_id;
    b->explicit_placement.data_pool = explicit_placement.data_pool.to_str();
    b->explicit_placement.data_extra_pool = explicit_placement.data_extra_pool.to_str();
    b->explicit_placement.index_pool = explicit_placement.index_pool.to_str();
  }

  void encode(bufferlist& bl) const {
     __u8 struct_v = 10; __u8 struct_compat = 10; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(name, bl);
    encode(marker, bl);
    encode(bucket_id, bl);
    encode(tenant, bl);
    bool encode_explicit = !explicit_placement.data_pool.empty();
    encode(encode_explicit, bl);
    if (encode_explicit) {
      encode(explicit_placement.data_pool, bl);
      encode(explicit_placement.data_extra_pool, bl);
      encode(explicit_placement.index_pool, bl);
    }
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (10 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "10" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(name, bl);
    if (struct_v < 10) {
      decode(explicit_placement.data_pool.name, bl);
    }
    if (struct_v >= 2) {
      decode(marker, bl);
      if (struct_v <= 3) {
        uint64_t id;
        decode(id, bl);
        char buf[16];
        snprintf(buf, sizeof(buf), "%" 
# 1204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
                                      "l" "u"
# 1204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
                                            , id);
        bucket_id = buf;
      } else {
        decode(bucket_id, bl);
      }
    }
    if (struct_v < 10) {
      if (struct_v >= 5) {
        decode(explicit_placement.index_pool.name, bl);
      } else {
        explicit_placement.index_pool = explicit_placement.data_pool;
      }
      if (struct_v >= 7) {
        decode(explicit_placement.data_extra_pool.name, bl);
      }
    }
    if (struct_v >= 8) {
      decode(tenant, bl);
    }
    if (struct_v >= 10) {
      bool decode_explicit = !explicit_placement.data_pool.empty();
      decode(decode_explicit, bl);
      if (decode_explicit) {
        decode(explicit_placement.data_pool, bl);
        decode(explicit_placement.data_extra_pool, bl);
        decode(explicit_placement.index_pool, bl);
      }
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void update_bucket_id(const string& new_bucket_id) {
    bucket_id = new_bucket_id;
    oid.clear();
  }


  std::string get_key(char tenant_delim = '/',
                      char id_delim = ':',
                      size_t reserve = 0) const;

  const rgw_pool& get_data_extra_pool() const {
    return explicit_placement.get_data_extra_pool();
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(list<rgw_bucket*>& o);

  rgw_bucket& operator=(const rgw_bucket&) = default;

  bool operator<(const rgw_bucket& b) const {
    if (tenant == b.tenant) {
      return name < b.name;
    } else {
      return tenant < b.tenant;
    }
  }

  bool operator==(const rgw_bucket& b) const {
    return (tenant == b.tenant) && (name == b.name) &&
           (bucket_id == b.bucket_id);
  }
};
inline void encode(const rgw_bucket &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_bucket &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

inline ostream& operator<<(ostream& out, const rgw_bucket &b) {
  out << b.name << "[" << b.marker << "]";
  return out;
}

struct rgw_bucket_shard {
  rgw_bucket bucket;
  int shard_id;

  rgw_bucket_shard() : shard_id(-1) {}
  rgw_bucket_shard(const rgw_bucket& _b, int _sid) : bucket(_b), shard_id(_sid) {}

  std::string get_key(char tenant_delim = '/', char id_delim = ':',
                      char shard_delim = ':') const;

  bool operator<(const rgw_bucket_shard& b) const {
    if (bucket < b.bucket) {
      return true;
    }
    if (b.bucket < bucket) {
      return false;
    }
    return shard_id < b.shard_id;
  }
};


struct RGWObjVersionTracker {
  obj_version read_version;
  obj_version write_version;

  obj_version *version_for_read() {
    return &read_version;
  }

  obj_version *version_for_write() {
    if (write_version.ver == 0)
      return 
# 1307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
            __null
# 1307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
                ;

    return &write_version;
  }

  obj_version *version_for_check() {
    if (read_version.ver == 0)
      return 
# 1314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
            __null
# 1314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
                ;

    return &read_version;
  }

  void prepare_op_for_read(librados::ObjectReadOperation *op);
  void prepare_op_for_write(librados::ObjectWriteOperation *op);

  void apply_write() {
    read_version = write_version;
    write_version = obj_version();
  }

  void clear() {
    read_version = obj_version();
    write_version = obj_version();
  }

  void generate_new_write_ver(CephContext *cct);
};

inline ostream& operator<<(ostream& out, const obj_version &v)
{
  out << v.tag << ":" << v.ver;
  return out;
}

inline ostream& operator<<(ostream& out, const RGWObjVersionTracker &ot)
{
  out << "{r=" << ot.read_version << ",w=" << ot.write_version << "}";
  return out;
}

enum RGWBucketFlags {
  BUCKET_SUSPENDED = 0x1,
  BUCKET_VERSIONED = 0x2,
  BUCKET_VERSIONS_SUSPENDED = 0x4,
  BUCKET_DATASYNC_DISABLED = 0X8,
  BUCKET_MFA_ENABLED = 0X10,
  BUCKET_OBJ_LOCK_ENABLED = 0X20,
};

enum RGWBucketIndexType {
  RGWBIType_Normal = 0,
  RGWBIType_Indexless = 1,
};

inline ostream& operator<<(ostream& out, const RGWBucketIndexType &index_type)
{
  switch (index_type) {
    case RGWBIType_Normal:
      return out << "Normal";
    case RGWBIType_Indexless:
      return out << "Indexless";
    default:
      return out << "Unknown";
  }
}

struct RGWBucketInfo {
  enum BIShardsHashType {
    MOD = 0
  };

  rgw_bucket bucket;
  rgw_user owner;
  uint32_t flags;
  string zonegroup;
  ceph::real_time creation_time;
  rgw_placement_rule placement_rule;
  bool has_instance_obj;
  RGWObjVersionTracker objv_tracker;
  obj_version ep_objv;
  RGWQuotaInfo quota;





  uint32_t num_shards;


  uint8_t bucket_index_shard_hash_type;


  const static uint32_t NUM_SHARDS_BLIND_BUCKET;

  bool requester_pays;

  bool has_website;
  RGWBucketWebsiteConf website_conf;

  RGWBucketIndexType index_type = RGWBIType_Normal;

  bool swift_versioning;
  string swift_ver_location;

  map<string, uint32_t> mdsearch_config;




  uint8_t reshard_status;
  string new_bucket_instance_id;

  RGWObjectLock obj_lock;

  void encode(bufferlist& bl) const {
     __u8 struct_v = 20; __u8 struct_compat = 4; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
     encode(bucket, bl);
     encode(owner.id, bl);
     encode(flags, bl);
     encode(zonegroup, bl);
     uint64_t ct = real_clock::to_time_t(creation_time);
     encode(ct, bl);
     encode(placement_rule, bl);
     encode(has_instance_obj, bl);
     encode(quota, bl);
     encode(num_shards, bl);
     encode(bucket_index_shard_hash_type, bl);
     encode(requester_pays, bl);
     encode(owner.tenant, bl);
     encode(has_website, bl);
     if (has_website) {
       encode(website_conf, bl);
     }
     encode((uint32_t)index_type, bl);
     encode(swift_versioning, bl);
     if (swift_versioning) {
       encode(swift_ver_location, bl);
     }
     encode(creation_time, bl);
     encode(mdsearch_config, bl);
     encode(reshard_status, bl);
     encode(new_bucket_instance_id, bl);
     if (obj_lock_enabled()) {
       encode(obj_lock, bl);
     }
     } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 4) { __u8 struct_compat; decode(struct_compat, bl); if (20 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "20" " < " + std::to_string(struct_compat))); } else if (3u) { if (bl.get_remaining() < 3u) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); bl.advance(3u); } unsigned struct_end = 0; if (struct_v >= 4) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
     decode(bucket, bl);
     if (struct_v >= 2) {
       string s;
       decode(s, bl);
       owner.from_str(s);
     }
     if (struct_v >= 3)
       decode(flags, bl);
     if (struct_v >= 5)
       decode(zonegroup, bl);
     if (struct_v >= 6) {
       uint64_t ct;
       decode(ct, bl);
       if (struct_v < 17)
  creation_time = ceph::real_clock::from_time_t((time_t)ct);
     }
     if (struct_v >= 7)
       decode(placement_rule, bl);
     if (struct_v >= 8)
       decode(has_instance_obj, bl);
     if (struct_v >= 9)
       decode(quota, bl);
     if (struct_v >= 10)
       decode(num_shards, bl);
     if (struct_v >= 11)
       decode(bucket_index_shard_hash_type, bl);
     if (struct_v >= 12)
       decode(requester_pays, bl);
     if (struct_v >= 13)
       decode(owner.tenant, bl);
     if (struct_v >= 14) {
       decode(has_website, bl);
       if (has_website) {
         decode(website_conf, bl);
       } else {
         website_conf = RGWBucketWebsiteConf();
       }
     }
     if (struct_v >= 15) {
       uint32_t it;
       decode(it, bl);
       index_type = (RGWBucketIndexType)it;
     } else {
       index_type = RGWBIType_Normal;
     }
     swift_versioning = false;
     swift_ver_location.clear();
     if (struct_v >= 16) {
       decode(swift_versioning, bl);
       if (swift_versioning) {
         decode(swift_ver_location, bl);
       }
     }
     if (struct_v >= 17) {
       decode(creation_time, bl);
     }
     if (struct_v >= 18) {
       decode(mdsearch_config, bl);
     }
     if (struct_v >= 19) {
       decode(reshard_status, bl);
       decode(new_bucket_instance_id, bl);
     }
     if (struct_v >= 20 && obj_lock_enabled()) {
       decode(obj_lock, bl);
     }
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWBucketInfo*>& o);

  void decode_json(JSONObj *obj);

  bool versioned() const { return (flags & BUCKET_VERSIONED) != 0; }
  int versioning_status() const { return flags & (BUCKET_VERSIONED | BUCKET_VERSIONS_SUSPENDED | BUCKET_MFA_ENABLED); }
  bool versioning_enabled() const { return (versioning_status() & (BUCKET_VERSIONED | BUCKET_VERSIONS_SUSPENDED)) == BUCKET_VERSIONED; }
  bool mfa_enabled() const { return (versioning_status() & BUCKET_MFA_ENABLED) != 0; }
  bool datasync_flag_enabled() const { return (flags & BUCKET_DATASYNC_DISABLED) == 0; }
  bool obj_lock_enabled() const { return (flags & BUCKET_OBJ_LOCK_ENABLED) != 0; }

  bool has_swift_versioning() const {

    return swift_versioning && !versioned();
  }

  RGWBucketInfo() : flags(0), has_instance_obj(false), num_shards(0), bucket_index_shard_hash_type(MOD), requester_pays(false),
                    has_website(false), swift_versioning(false), reshard_status(0) {}
};
inline void encode(const RGWBucketInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBucketInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWBucketEntryPoint
{
  rgw_bucket bucket;
  rgw_user owner;
  ceph::real_time creation_time;
  bool linked;

  bool has_bucket_info;
  RGWBucketInfo old_bucket_info;

  RGWBucketEntryPoint() : linked(false), has_bucket_info(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 10; __u8 struct_compat = 8; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(bucket, bl);
    encode(owner.id, bl);
    encode(linked, bl);
    uint64_t ctime = (uint64_t)real_clock::to_time_t(creation_time);
    encode(ctime, bl);
    encode(owner, bl);
    encode(creation_time, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    auto orig_iter = bl;
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 4) { __u8 struct_compat; decode(struct_compat, bl); if (10 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "10" " < " + std::to_string(struct_compat))); } else if (3u) { if (bl.get_remaining() < 3u) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); bl.advance(3u); } unsigned struct_end = 0; if (struct_v >= 4) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    if (struct_v < 8) {

      old_bucket_info.decode(orig_iter);
      has_bucket_info = true;
      return;
    }
    has_bucket_info = false;
    decode(bucket, bl);
    decode(owner.id, bl);
    decode(linked, bl);
    uint64_t ctime;
    decode(ctime, bl);
    if (struct_v < 10) {
      creation_time = real_clock::from_time_t((time_t)ctime);
    }
    if (struct_v >= 9) {
      decode(owner, bl);
    }
    if (struct_v >= 10) {
      decode(creation_time, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const RGWBucketEntryPoint &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBucketEntryPoint &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWStorageStats
{
  RGWObjCategory category;
  uint64_t size;
  uint64_t size_rounded;
  uint64_t size_utilized{0};
  uint64_t num_objects;

  RGWStorageStats()
    : category(RGWObjCategory::None),
      size(0),
      size_rounded(0),
      num_objects(0) {}

  void dump(Formatter *f) const;
};

class RGWEnv;


namespace rgw {
  namespace auth {
    namespace s3 {
      class AWSBrowserUploadAbstractor;
    }
    class Completer;
  }
  namespace io {
    class BasicClient;
  }
}


struct req_info {
  const RGWEnv *env;
  RGWHTTPArgs args;
  map<string, string> x_meta_map;

  string host;
  const char *method;
  string script_uri;
  string request_uri;
  string request_uri_aws4;
  string effective_uri;
  string request_params;
  string domain;
  string storage_class;

  req_info(CephContext *cct, const RGWEnv *env);
  void rebuild_from(req_info& src);
  void init_meta_info(bool *found_bad_meta);
};

typedef cls_rgw_obj_key rgw_obj_index_key;

struct rgw_obj_key {
  string name;
  string instance;
  string ns;

  rgw_obj_key() {}

  rgw_obj_key(const string& n) : name(n) {}
  rgw_obj_key(const string& n, const string& i) : name(n), instance(i) {}
  rgw_obj_key(const string& n, const string& i, const string& _ns) : name(n), instance(i), ns(_ns) {}

  rgw_obj_key(const rgw_obj_index_key& k) {
    parse_index_key(k.name, &name, &ns);
    instance = k.instance;
  }

  static void parse_index_key(const string& key, string *name, string *ns) {
    if (key[0] != '_') {
      *name = key;
      ns->clear();
      return;
    }
    if (key[1] == '_') {
      *name = key.substr(1);
      ns->clear();
      return;
    }
    ssize_t pos = key.find('_', 1);
    if (pos < 0) {

      *name = key;
      ns->clear();
      return;
    }

    *name = key.substr(pos + 1);
    *ns = key.substr(1, pos -1);
  }

  void set(const string& n) {
    name = n;
    instance.clear();
    ns.clear();
  }

  void set(const string& n, const string& i) {
    name = n;
    instance = i;
    ns.clear();
  }

  void set(const string& n, const string& i, const string& _ns) {
    name = n;
    instance = i;
    ns = _ns;
  }

  bool set(const rgw_obj_index_key& index_key) {
    if (!parse_raw_oid(index_key.name, this)) {
      return false;
    }
    instance = index_key.instance;
    return true;
  }

  void set_instance(const string& i) {
    instance = i;
  }

  const string& get_instance() const {
    return instance;
  }

  string get_index_key_name() const {
    if (ns.empty()) {
      if (name.size() < 1 || name[0] != '_') {
        return name;
      }
      return string("_") + name;
    };

    char buf[ns.size() + 16];
    snprintf(buf, sizeof(buf), "_%s_", ns.c_str());
    return string(buf) + name;
  };

  void get_index_key(rgw_obj_index_key *key) const {
    key->name = get_index_key_name();
    key->instance = instance;
  }

  string get_loc() const {






    if (name[0] == '_' && ns.empty()) {
      return name;
    }

    return string();
  }

  bool empty() const {
    return name.empty();
  }

  bool have_null_instance() const {
    return instance == "null";
  }

  bool have_instance() const {
    return !instance.empty();
  }

  bool need_to_encode_instance() const {
    return have_instance() && !have_null_instance();
  }

  string get_oid() const {
    if (ns.empty() && !need_to_encode_instance()) {
      if (name.size() < 1 || name[0] != '_') {
        return name;
      }
      return string("_") + name;
    }

    string oid = "_";
    oid.append(ns);
    if (need_to_encode_instance()) {
      oid.append(string(":") + instance);
    }
    oid.append("_");
    oid.append(name);
    return oid;
  }

  bool operator==(const rgw_obj_key& k) const {
    return (name.compare(k.name) == 0) &&
           (instance.compare(k.instance) == 0);
  }

  bool operator<(const rgw_obj_key& k) const {
    int r = name.compare(k.name);
    if (r == 0) {
      r = instance.compare(k.instance);
    }
    return (r < 0);
  }

  bool operator<=(const rgw_obj_key& k) const {
    return !(k < *this);
  }

  static void parse_ns_field(string& ns, string& instance) {
    int pos = ns.find(':');
    if (pos >= 0) {
      instance = ns.substr(pos + 1);
      ns = ns.substr(0, pos);
    } else {
      instance.clear();
    }
  }



  static bool parse_raw_oid(const string& oid, rgw_obj_key *key) {
    key->instance.clear();
    key->ns.clear();
    if (oid[0] != '_') {
      key->name = oid;
      return true;
    }

    if (oid.size() >= 2 && oid[1] == '_') {
      key->name = oid.substr(1);
      return true;
    }

    if (oid.size() < 3)
      return false;

    size_t pos = oid.find('_', 2);
    if (pos == string::npos)
      return false;

    key->ns = oid.substr(1, pos - 1);
    parse_ns_field(key->ns, key->instance);

    key->name = oid.substr(pos + 1);
    return true;
  }
# 1859 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
  static bool oid_to_key_in_ns(const string& oid, rgw_obj_key *key, const string& ns) {
    bool ret = parse_raw_oid(oid, key);
    if (!ret) {
      return ret;
    }

    return (ns == key->ns);
  }
# 1876 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
  static bool strip_namespace_from_name(string& name, string& ns, string& instance) {
    ns.clear();
    instance.clear();
    if (name[0] != '_') {
      return true;
    }

    size_t pos = name.find('_', 1);
    if (pos == string::npos) {
      return false;
    }

    if (name[1] == '_') {
      name = name.substr(1);
      return true;
    }

    size_t period_pos = name.find('.');
    if (period_pos < pos) {
      return false;
    }

    ns = name.substr(1, pos-1);
    name = name.substr(pos+1, string::npos);

    parse_ns_field(ns, instance);
    return true;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(name, bl);
    encode(instance, bl);
    encode(ns, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(name, bl);
    decode(instance, bl);
    if (struct_v >= 2) {
      decode(ns, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);

  string to_str() const {
    if (instance.empty()) {
      return name;
    }
    char buf[name.size() + instance.size() + 16];
    snprintf(buf, sizeof(buf), "%s[%s]", name.c_str(), instance.c_str());
    return buf;
  }
};
inline void encode(const rgw_obj_key &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_obj_key &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

inline ostream& operator<<(ostream& out, const rgw_obj_key &o) {
  return out << o.to_str();
}

inline ostream& operator<<(ostream& out, const rgw_obj_index_key &o) {
  if (o.instance.empty()) {
    return out << o.name;
  } else {
    return out << o.name << "[" << o.instance << "]";
  }
}

struct req_init_state {

  string url_bucket;
  string src_bucket;
};

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h" 1
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 1
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_keystone.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_keystone.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_client.h" 1







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/lockdep.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/lockdep.h"
class CephContext;

extern bool g_lockdep;

extern void lockdep_register_ceph_context(CephContext *cct);
extern void lockdep_unregister_ceph_context(CephContext *cct);
extern int lockdep_register(const char *n);
extern void lockdep_unregister(int id);
extern int lockdep_will_lock(const char *n, int id, bool force_backtrace=false,
        bool recursive=false);
extern int lockdep_locked(const char *n, int id, bool force_backtrace=false);
extern int lockdep_will_unlock(const char *n, int id);
extern int lockdep_dump_locks();
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/valgrind.h" 1
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h" 2



class RWLock final
{
  mutable pthread_rwlock_t L;
  std::string name;
  mutable int id;
  mutable std::atomic<unsigned> nrlock = { 0 }, nwlock = { 0 };
  bool track, lockdep;

  std::string unique_name(const char* name) const;

public:
  RWLock(const RWLock& other) = delete;
  const RWLock& operator=(const RWLock& other) = delete;

  RWLock(const std::string &n, bool track_lock=true, bool ld=true, bool prioritize_write=false)
    : name(n), id(-1), track(track_lock),
      lockdep(ld) {

    if (prioritize_write) {
      pthread_rwlockattr_t attr;
      pthread_rwlockattr_init(&attr);



      pthread_rwlockattr_setkind_np(&attr,
          PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);
      pthread_rwlock_init(&L, &attr);
      pthread_rwlockattr_destroy(&attr);
    } else


    {
      pthread_rwlock_init(&L, 
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h" 3 4
                             __null
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h"
                                 );
    }
    (void)0;
    (void)0;
    (void)0;
    if (lockdep && g_lockdep) id = lockdep_register(name.c_str());
  }

  bool is_locked() const {
    do { static const ceph::assert_data assert_data_ctx = {"track", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 70, __PRETTY_FUNCTION__}; ((track) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    return (nrlock > 0) || (nwlock > 0);
  }

  bool is_wlocked() const {
    do { static const ceph::assert_data assert_data_ctx = {"track", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 75, __PRETTY_FUNCTION__}; ((track) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    return (nwlock > 0);
  }
  ~RWLock() {


    if (track)
      do { static const ceph::assert_data assert_data_ctx = {"!is_locked()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 82, __PRETTY_FUNCTION__}; ((!is_locked()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    pthread_rwlock_destroy(&L);
    if (lockdep && g_lockdep) {
      lockdep_unregister(id);
    }
  }

  void unlock(bool lockdep=true) const {
    if (track) {
      if (nwlock > 0) {
        nwlock--;
      } else {
        do { static const ceph::assert_data assert_data_ctx = {"nrlock > 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 94, __PRETTY_FUNCTION__}; ((nrlock > 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
        nrlock--;
      }
    }
    if (lockdep && this->lockdep && g_lockdep)
      id = lockdep_will_unlock(name.c_str(), id);
    int r = pthread_rwlock_unlock(&L);
    do { static const ceph::assert_data assert_data_ctx = {"r == 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 101, __PRETTY_FUNCTION__}; ((r == 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
  }


  void get_read() const {
    if (lockdep && g_lockdep) id = lockdep_will_lock(name.c_str(), id);
    int r = pthread_rwlock_rdlock(&L);
    do { static const ceph::assert_data assert_data_ctx = {"r == 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 108, __PRETTY_FUNCTION__}; ((r == 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    if (lockdep && g_lockdep) id = lockdep_locked(name.c_str(), id);
    if (track)
      nrlock++;
  }
  bool try_get_read() const {
    if (pthread_rwlock_tryrdlock(&L) == 0) {
      if (track)
         nrlock++;
      if (lockdep && g_lockdep) id = lockdep_locked(name.c_str(), id);
      return true;
    }
    return false;
  }
  void put_read() const {
    unlock();
  }


  void get_write(bool lockdep=true) {
    if (lockdep && this->lockdep && g_lockdep)
      id = lockdep_will_lock(name.c_str(), id);
    int r = pthread_rwlock_wrlock(&L);
    do { static const ceph::assert_data assert_data_ctx = {"r == 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 131, __PRETTY_FUNCTION__}; ((r == 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    if (lockdep && this->lockdep && g_lockdep)
      id = lockdep_locked(name.c_str(), id);
    if (track)
      nwlock++;

  }
  bool try_get_write(bool lockdep=true) {
    if (pthread_rwlock_trywrlock(&L) == 0) {
      if (lockdep && this->lockdep && g_lockdep)
 id = lockdep_locked(name.c_str(), id);
      if (track)
         nwlock++;
      return true;
    }
    return false;
  }
  void put_write() {
    unlock();
  }

  void get(bool for_write) {
    if (for_write) {
      get_write();
    } else {
      get_read();
    }
  }

public:
  class RLocker {
    const RWLock &m_lock;

    bool locked;

  public:
   explicit RLocker(const RWLock& lock) : m_lock(lock) {
      m_lock.get_read();
      locked = true;
    }
    void unlock() {
      do { static const ceph::assert_data assert_data_ctx = {"locked", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 172, __PRETTY_FUNCTION__}; ((locked) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
      m_lock.unlock();
      locked = false;
    }
    ~RLocker() {
      if (locked) {
        m_lock.unlock();
      }
    }
  };

  class WLocker {
    RWLock &m_lock;

    bool locked;

  public:
    explicit WLocker(RWLock& lock) : m_lock(lock) {
      m_lock.get_write();
      locked = true;
    }
    void unlock() {
      do { static const ceph::assert_data assert_data_ctx = {"locked", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 194, __PRETTY_FUNCTION__}; ((locked) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
      m_lock.unlock();
      locked = false;
    }
    ~WLocker() {
      if (locked) {
        m_lock.unlock();
      }
    }
  };

  class Context {
    RWLock& lock;

  public:
    enum LockState {
      Untaken = 0,
      TakenForRead = 1,
      TakenForWrite = 2,
    };

  private:
    LockState state;

  public:
    explicit Context(RWLock& l) : lock(l), state(Untaken) {}
    Context(RWLock& l, LockState s) : lock(l), state(s) {}

    void get_write() {
      do { static const ceph::assert_data assert_data_ctx = {"state == Untaken", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 223, __PRETTY_FUNCTION__}; ((state == Untaken) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

      lock.get_write();
      state = TakenForWrite;
    }

    void get_read() {
      do { static const ceph::assert_data assert_data_ctx = {"state == Untaken", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 230, __PRETTY_FUNCTION__}; ((state == Untaken) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

      lock.get_read();
      state = TakenForRead;
    }

    void unlock() {
      do { static const ceph::assert_data assert_data_ctx = {"state != Untaken", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 237, __PRETTY_FUNCTION__}; ((state != Untaken) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
      lock.unlock();
      state = Untaken;
    }

    void promote() {
      do { static const ceph::assert_data assert_data_ctx = {"state == TakenForRead", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RWLock.h", 243, __PRETTY_FUNCTION__}; ((state == TakenForRead) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
      unlock();
      get_write();
    }

    LockState get_state() { return state; }
    void set_state(LockState s) {
      state = s;
    }

    bool is_locked() {
      return (state != Untaken);
    }

    bool is_rlocked() {
      return (state == TakenForRead);
    }

    bool is_wlocked() {
      return (state == TakenForWrite);
    }
  };
};
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_client.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 1
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/function.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 2





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Mutex.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Mutex.h"
using namespace ceph;

class Mutex {
private:
  std::string name;
  int id;
  bool recursive;
  bool lockdep;
  bool backtrace;

  pthread_mutex_t _m;
  int nlock;
  pthread_t locked_by;


  void operator=(const Mutex &M);
  Mutex(const Mutex &M);

  void _register() {
    id = lockdep_register(name.c_str());
  }
  void _will_lock() {
    id = lockdep_will_lock(name.c_str(), id, backtrace, recursive);
  }
  void _locked() {
    id = lockdep_locked(name.c_str(), id, backtrace);
  }
  void _will_unlock() {
    id = lockdep_will_unlock(name.c_str(), id);
  }

public:
  Mutex(const std::string &n, bool r = false, bool ld=true, bool bt=false);
  ~Mutex();
  bool is_locked() const {
    return (nlock > 0);
  }
  bool is_locked_by_me() const {
    return nlock > 0 && locked_by == pthread_self();
  }

  bool TryLock() {
    return try_lock();
  }
  bool try_lock() {
    int r = pthread_mutex_trylock(&_m);
    if (r == 0) {
      if (lockdep && g_lockdep) _locked();
      _post_lock();
    }
    return r == 0;
  }

  void Lock(bool no_lockdep=false) {
    lock(no_lockdep);
  }
  void lock(bool no_lockdep=false);

  void _post_lock() {
    if (!recursive) {
      do { static const ceph::assert_data assert_data_ctx = {"nlock == 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Mutex.h", 85, __PRETTY_FUNCTION__}; ((nlock == 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
      locked_by = pthread_self();
    };
    nlock++;
  }

  void _pre_unlock() {
    do { static const ceph::assert_data assert_data_ctx = {"nlock > 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Mutex.h", 92, __PRETTY_FUNCTION__}; ((nlock > 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    --nlock;
    if (!recursive) {
      do { static const ceph::assert_data assert_data_ctx = {"locked_by == pthread_self()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Mutex.h", 95, __PRETTY_FUNCTION__}; ((locked_by == pthread_self()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
      locked_by = 0;
      do { static const ceph::assert_data assert_data_ctx = {"nlock == 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Mutex.h", 97, __PRETTY_FUNCTION__}; ((nlock == 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    }
  }
  void Unlock() {
    unlock();
  }
  void unlock();

  friend class Cond;


public:
  typedef std::lock_guard<Mutex> Locker;
};
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 2






template <typename T>
class GenContext {
  GenContext(const GenContext& other);
  const GenContext& operator=(const GenContext& other);

 protected:
  virtual void finish(T t) = 0;

 public:
  GenContext() {}
  virtual ~GenContext() {}

  template <typename C>
  void complete(C &&t) {
    finish(std::forward<C>(t));
    delete this;
  }
};

template <typename T>
using GenContextURef = std::unique_ptr<GenContext<T> >;




class Finisher;
class Context {
  Context(const Context& other);
  const Context& operator=(const Context& other);

 protected:
  virtual void finish(int r) = 0;



  virtual bool sync_finish(int r) {
    return false;
  }

 public:
  Context() {}
  virtual ~Context() {}
  virtual void complete(int r) {
    finish(r);
    delete this;
  }
  virtual bool sync_complete(int r) {
    if (sync_finish(r)) {
      delete this;
      return true;
    }
    return false;
  }
};




template<class T>
class ContainerContext : public Context {
  T obj;
public:
  ContainerContext(T &obj) : obj(obj) {}
  void finish(int r) override {}
};
template <typename T>
ContainerContext<T> *make_container_context(T &&t) {
  return new ContainerContext<T>(std::forward<T>(t));
}

template <class T>
struct Wrapper : public Context {
  Context *to_run;
  T val;
  Wrapper(Context *to_run, T val) : to_run(to_run), val(val) {}
  void finish(int r) override {
    if (to_run)
      to_run->complete(r);
  }
};
struct RunOnDelete {
  Context *to_run;
  RunOnDelete(Context *to_run) : to_run(to_run) {}
  ~RunOnDelete() {
    if (to_run)
      to_run->complete(0);
  }
};
typedef std::shared_ptr<RunOnDelete> RunOnDeleteRef;

template <typename T>
struct LambdaContext : public Context {
  T t;
  LambdaContext(T &&t) : t(std::forward<T>(t)) {}
  void finish(int) override {
    t();
  }
};
template <typename T>
LambdaContext<T> *make_lambda_context(T &&t) {
  return new LambdaContext<T>(std::move(t));
}

template <typename F, typename T>
struct LambdaGenContext : GenContext<T> {
  F f;
  LambdaGenContext(F &&f) : f(std::forward<F>(f)) {}
  void finish(T t) override {
    f(std::forward<T>(t));
  }
};
template <typename T, typename F>
GenContextURef<T> make_gen_lambda_context(F &&f) {
  return GenContextURef<T>(new LambdaGenContext<F, T>(std::move(f)));
}




template<class C>
inline void finish_contexts(CephContext *cct, C& finished, int result = 0)
{
  if (finished.empty())
    return;

  C ls;
  ls.swap(finished);

  if (cct)
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_context)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_context, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_context, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_context); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << ls.size() << " contexts to finish with " << result << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
  for (Context* c : ls) {
    if (cct)
      do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_context)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_context, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_context, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_context); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "---- " << c << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    c->complete(result);
  }
}

class C_NoopContext : public Context {
public:
  void finish(int r) override { }
};


struct C_Lock : public Context {
  Mutex *lock;
  Context *fin;
  C_Lock(Mutex *l, Context *c) : lock(l), fin(c) {}
  ~C_Lock() override {
    delete fin;
  }
  void finish(int r) override {
    if (fin) {
      lock->Lock();
      fin->complete(r);
      fin = 
# 188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
           __null
# 188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
               ;
      lock->Unlock();
    }
  }
};







template <class ContextType, class ContextInstanceType, class Container = std::list<ContextType *>>
class C_ContextsBase : public ContextInstanceType {
public:
  CephContext *cct;
  Container contexts;

  C_ContextsBase(CephContext *cct_)
    : cct(cct_)
  {
  }
  ~C_ContextsBase() override {
    for (auto c : contexts) {
      delete c;
    }
  }
  void add(ContextType* c) {
    contexts.push_back(c);
  }
  void take(Container& ls) {
    Container c;
    c.swap(ls);
    if constexpr (std::is_same_v<Container, std::list<ContextType *>>) {
      contexts.splice(contexts.end(), c);
    } else {
      contexts.insert(contexts.end(), c.begin(), c.end());
    }
  }
  void complete(int r) override {


    Context::complete(r);
  }
  void finish(int r) override {
    finish_contexts(cct, contexts, r);
  }
  bool empty() { return contexts.empty(); }

  template<class C>
  static ContextType *list_to_context(C& cs) {
    if (cs.size() == 0) {
      return 0;
    } else if (cs.size() == 1) {
      ContextType *c = cs.front();
      cs.clear();
      return c;
    } else {
      C_ContextsBase<ContextType, ContextInstanceType> *c(new C_ContextsBase<ContextType, ContextInstanceType>(0));
      c->take(cs);
      return c;
    }
  }
};

typedef C_ContextsBase<Context, Context> C_Contexts;
# 263 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
template <class ContextType, class ContextInstanceType>
class C_GatherBase {
private:
  CephContext *cct;
  int result;
  ContextType *onfinish;

  std::set<ContextType*> waitfor;

  int sub_created_count;
  int sub_existing_count;
  mutable Mutex lock;
  bool activated;

  void sub_finish(ContextType* sub, int r) {
    lock.Lock();

    do { static const ceph::assert_data assert_data_ctx = {"waitfor.count(sub)", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 280, __PRETTY_FUNCTION__}; ((waitfor.count(sub)) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    waitfor.erase(sub);

    --sub_existing_count;
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_context)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_context, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_context, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_context); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "C_GatherBase " << this << ".sub_finish(r=" << r << ") " << sub

      << " (remaining " << waitfor << ")"

      << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (r < 0 && result == 0)
      result = r;
    if ((activated == false) || (sub_existing_count != 0)) {
      lock.Unlock();
      return;
    }
    lock.Unlock();
    delete_me();
  }

  void delete_me() {
    if (onfinish) {
      onfinish->complete(result);
      onfinish = 0;
    }
    delete this;
  }

  class C_GatherSub : public ContextInstanceType {
    C_GatherBase *gather;
  public:
    C_GatherSub(C_GatherBase *g) : gather(g) {}
    void complete(int r) override {




      Context::complete(r);
    }
    void finish(int r) override {
      gather->sub_finish(this, r);
      gather = 0;
    }
    ~C_GatherSub() override {
      if (gather)
 gather->sub_finish(this, 0);
    }
  };

public:
  C_GatherBase(CephContext *cct_, ContextType *onfinish_)
    : cct(cct_), result(0), onfinish(onfinish_),
      sub_created_count(0), sub_existing_count(0),
      lock("C_GatherBase::lock", true, false),
      activated(false)
  {
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_context)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_context, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_context, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_context); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "C_GatherBase " << this << ".new" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
  }
  ~C_GatherBase() {
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_context)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_context, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_context, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_context); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "C_GatherBase " << this << ".delete" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
  }
  void set_finisher(ContextType *onfinish_) {
    Mutex::Locker l(lock);
    do { static const ceph::assert_data assert_data_ctx = {"!onfinish", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 342, __PRETTY_FUNCTION__}; ((!onfinish) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    onfinish = onfinish_;
  }
  void activate() {
    lock.Lock();
    do { static const ceph::assert_data assert_data_ctx = {"activated == false", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 347, __PRETTY_FUNCTION__}; ((activated == false) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    activated = true;
    if (sub_existing_count != 0) {
      lock.Unlock();
      return;
    }
    lock.Unlock();
    delete_me();
  }
  ContextType *new_sub() {
    Mutex::Locker l(lock);
    do { static const ceph::assert_data assert_data_ctx = {"activated == false", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 358, __PRETTY_FUNCTION__}; ((activated == false) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    sub_created_count++;
    sub_existing_count++;
    ContextType *s = new C_GatherSub(this);

    waitfor.insert(s);

    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_context)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_context, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_context, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_context); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "C_GatherBase " << this << ".new_sub is " << sub_created_count << " " << s << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return s;
  }

  inline int get_sub_existing_count() const {
    Mutex::Locker l(lock);
    return sub_existing_count;
  }

  inline int get_sub_created_count() const {
    Mutex::Locker l(lock);
    return sub_created_count;
  }
};
# 412 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
template <class ContextType, class GatherType>
class C_GatherBuilderBase
{
public:
  C_GatherBuilderBase(CephContext *cct_)
    : cct(cct_), c_gather(
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
                         __null
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
                             ), finisher(
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
                                         __null
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
                                             ), activated(false)
  {
  }
  C_GatherBuilderBase(CephContext *cct_, ContextType *finisher_)
    : cct(cct_), c_gather(
# 421 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
                         __null
# 421 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
                             ), finisher(finisher_), activated(false)
  {
  }
  ~C_GatherBuilderBase() {
    if (c_gather) {
      do { static const ceph::assert_data assert_data_ctx = {"activated", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 426, __PRETTY_FUNCTION__}; ((activated) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    }
    else {
      delete finisher;
    }
  }
  ContextType *new_sub() {
    if (!c_gather) {
      c_gather = new GatherType(cct, finisher);
    }
    return c_gather->new_sub();
  }
  void activate() {
    if (!c_gather)
      return;
    do { static const ceph::assert_data assert_data_ctx = {"finisher != __null", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 441, __PRETTY_FUNCTION__}; ((finisher != 
# 441 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
   __null
# 441 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
   ) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    activated = true;
    c_gather->activate();
  }
  void set_finisher(ContextType *finisher_) {
    finisher = finisher_;
    if (c_gather)
      c_gather->set_finisher(finisher);
  }
  GatherType *get() const {
    return c_gather;
  }
  bool has_subs() const {
    return (c_gather != 
# 454 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
                       __null
# 454 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
                           );
  }
  int num_subs_created() {
    do { static const ceph::assert_data assert_data_ctx = {"!activated", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 457, __PRETTY_FUNCTION__}; ((!activated) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    if (c_gather == 
# 458 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
                   __null
# 458 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
                       )
      return 0;
    return c_gather->get_sub_created_count();
  }
  int num_subs_remaining() {
    do { static const ceph::assert_data assert_data_ctx = {"!activated", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h", 463, __PRETTY_FUNCTION__}; ((!activated) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    if (c_gather == 
# 464 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h" 3 4
                   __null
# 464 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/Context.h"
                       )
      return 0;
    return c_gather->get_sub_existing_count();
  }

private:
  CephContext *cct;
  GatherType *c_gather;
  ContextType *finisher;
  bool activated;
};

typedef C_GatherBase<Context, Context> C_Gather;
typedef C_GatherBuilderBase<Context, C_Gather > C_GatherBuilder;

class FunctionContext : public Context {
public:
  FunctionContext(boost::function<void(int)> &&callback)
    : m_callback(std::move(callback))
  {
  }

  void finish(int r) override {
    m_callback(r);
  }
private:
  boost::function<void(int)> m_callback;
};

template <class ContextType>
class ContextFactory {
public:
  virtual ~ContextFactory() {}
  virtual ContextType *build() = 0;
};
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 2

class Cond {

  pthread_cond_t _c;

  Mutex *waiter_mutex;


  void operator=(Cond &C);
  Cond(const Cond &C);

 public:
  Cond() : waiter_mutex(
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
                       __null
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
                           ) {
    int r = pthread_cond_init(&_c,
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
                                 __null
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
                                     );
    do { static const ceph::assert_data assert_data_ctx = {"r == 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 35, __PRETTY_FUNCTION__}; ((r == 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
  }
  virtual ~Cond() {
    pthread_cond_destroy(&_c);
  }

  int Wait(Mutex &mutex) {

    do { static const ceph::assert_data assert_data_ctx = {"waiter_mutex == __null || waiter_mutex == &mutex", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 43, __PRETTY_FUNCTION__}; ((waiter_mutex == 
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
   __null 
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
   || waiter_mutex == &mutex) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    waiter_mutex = &mutex;

    do { static const ceph::assert_data assert_data_ctx = {"mutex.is_locked()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 46, __PRETTY_FUNCTION__}; ((mutex.is_locked()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

    mutex._pre_unlock();
    int r = pthread_cond_wait(&_c, &mutex._m);
    mutex._post_lock();
    return r;
  }

  int WaitUntil(Mutex &mutex, utime_t when) {

    do { static const ceph::assert_data assert_data_ctx = {"waiter_mutex == __null || waiter_mutex == &mutex", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 56, __PRETTY_FUNCTION__}; ((waiter_mutex == 
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
   __null 
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
   || waiter_mutex == &mutex) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
    waiter_mutex = &mutex;

    do { static const ceph::assert_data assert_data_ctx = {"mutex.is_locked()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 59, __PRETTY_FUNCTION__}; ((mutex.is_locked()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

    struct timespec ts;
    when.to_timespec(&ts);

    mutex._pre_unlock();
    int r = pthread_cond_timedwait(&_c, &mutex._m, &ts);
    mutex._post_lock();

    return r;
  }

  int WaitInterval(Mutex &mutex, utime_t interval) {
    utime_t when = ceph_clock_now();
    when += interval;
    return WaitUntil(mutex, when);
  }

  template<typename Duration>
  int WaitInterval(Mutex &mutex, Duration interval) {
    ceph::real_time when(ceph::real_clock::now());
    when += interval;

    struct timespec ts = ceph::real_clock::to_timespec(when);

    mutex._pre_unlock();
    int r = pthread_cond_timedwait(&_c, &mutex._m, &ts);
    mutex._post_lock();

    return r;
  }

  int SloppySignal() {
    int r = pthread_cond_broadcast(&_c);
    return r;
  }
  int Signal() {

    do { static const ceph::assert_data assert_data_ctx = {"waiter_mutex == __null || waiter_mutex->is_locked()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 97, __PRETTY_FUNCTION__}; ((waiter_mutex == 
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
   __null 
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
   || waiter_mutex->is_locked()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false)
                              ;

    int r = pthread_cond_broadcast(&_c);
    return r;
  }
  int SignalOne() {

    do { static const ceph::assert_data assert_data_ctx = {"waiter_mutex == __null || waiter_mutex->is_locked()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 105, __PRETTY_FUNCTION__}; ((waiter_mutex == 
# 105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
   __null 
# 105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
   || waiter_mutex->is_locked()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false)
                              ;

    int r = pthread_cond_signal(&_c);
    return r;
  }
  int SignalAll() {

    do { static const ceph::assert_data assert_data_ctx = {"waiter_mutex == __null || waiter_mutex->is_locked()", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h", 113, __PRETTY_FUNCTION__}; ((waiter_mutex == 
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
   __null 
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
   || waiter_mutex->is_locked()) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false)
                              ;

    int r = pthread_cond_broadcast(&_c);
    return r;
  }
};







class C_Cond : public Context {
  Cond *cond;
  bool *done;
  int *rval;
public:
  C_Cond(Cond *c, bool *d, int *r) : cond(c), done(d), rval(r) {
    *done = false;
  }
  void finish(int r) override {
    *done = true;
    *rval = r;
    cond->Signal();
  }
};
# 149 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
class C_SafeCond : public Context {
  Mutex *lock;
  Cond *cond;
  bool *done;
  int *rval;
public:
  C_SafeCond(Mutex *l, Cond *c, bool *d, int *r=0) : lock(l), cond(c), done(d), rval(r) {
    *done = false;
  }
  void finish(int r) override {
    lock->lock();
    if (rval)
      *rval = r;
    *done = true;
    cond->Signal();
    lock->unlock();
  }
};







class C_SaferCond : public Context {
  Mutex lock;
  Cond cond;
  bool done;
  int rval;
public:
  C_SaferCond() : lock("C_SaferCond"), done(false), rval(0) {}
  explicit C_SaferCond(const std::string &name) : lock(name), done(false), rval(0) {}
  void finish(int r) override { complete(r); }


  void complete(int r) override {
    std::lock_guard l(lock);
    done = true;
    rval = r;
    cond.Signal();
  }


  int wait() {
    std::lock_guard l(lock);
    while (!done)
      cond.Wait(lock);
    return rval;
  }


  int wait_for(double secs) {
    utime_t interval;
    interval.set_from_double(secs);
    std::lock_guard l{lock};
    if (done) {
      return rval;
    }
    cond.WaitInterval(lock, interval);
    return done ? rval : 
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 3 4
                        110
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h"
                                 ;
  }
};
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_client.h" 2





using param_pair_t = pair<string, string>;
using param_vec_t = vector<param_pair_t>;

void rgw_http_client_init(CephContext *cct);
void rgw_http_client_cleanup();

struct rgw_http_req_data;
class RGWHTTPManager;

class RGWIOIDProvider
{
  std::atomic<int64_t> max = {0};

public:
  RGWIOIDProvider() {}
  int64_t get_next() {
    return ++max;
  }
};

struct rgw_io_id {
  int64_t id{0};
  int channels{0};

  rgw_io_id() {}
  rgw_io_id(int64_t _id, int _channels) : id(_id), channels(_channels) {}

  bool intersects(const rgw_io_id& rhs) {
    return (id == rhs.id && ((channels | rhs.channels) != 0));
  }

  bool operator<(const rgw_io_id& rhs) const {
    if (id < rhs.id) {
      return true;
    }
    return (id == rhs.id &&
            channels < rhs.channels);
  }
};

class RGWIOProvider
{
  int64_t id{-1};

public:
  RGWIOProvider() {}
  virtual ~RGWIOProvider() = default;

  void assign_io(RGWIOIDProvider& io_id_provider, int io_type = -1);
  rgw_io_id get_io_id(int io_type) {
    return rgw_io_id{id, io_type};
  }

  virtual void set_io_user_info(void *_user_info) = 0;
  virtual void *get_io_user_info() = 0;
};

class RGWHTTPClient : public RGWIOProvider
{
  friend class RGWHTTPManager;

  bufferlist send_bl;
  bufferlist::iterator send_iter;
  bool has_send_len;
  long http_status;
  bool send_data_hint{false};
  size_t receive_pause_skip{0};


  void *user_info{nullptr};

  rgw_http_req_data *req_data;

  bool verify_ssl;

  std::atomic<unsigned> stopped { 0 };


protected:
  CephContext *cct;

  string method;
  string url;

  size_t send_len{0};

  param_vec_t headers;

  RGWHTTPManager *get_manager();

  int init_request(rgw_http_req_data *req_data);

  virtual int receive_header(void *ptr, size_t len) {
    return 0;
  }
  virtual int receive_data(void *ptr, size_t len, bool *pause) {
    return 0;
  }

  virtual int send_data(void *ptr, size_t len, bool *pause=nullptr) {
    return 0;
  }


  static size_t receive_http_header(void *ptr,
                                    size_t size,
                                    size_t nmemb,
                                    void *_info);

  static size_t receive_http_data(void *ptr,
                                  size_t size,
                                  size_t nmemb,
                                  void *_info);

  static size_t send_http_data(void *ptr,
                               size_t size,
                               size_t nmemb,
                               void *_info);

  Mutex& get_req_lock();


  void _set_write_paused(bool pause);
  void _set_read_paused(bool pause);
public:
  static const long HTTP_STATUS_NOSTATUS = 0;
  static const long HTTP_STATUS_UNAUTHORIZED = 401;
  static const long HTTP_STATUS_NOTFOUND = 404;

  static constexpr int HTTPCLIENT_IO_READ = 0x1;
  static constexpr int HTTPCLIENT_IO_WRITE = 0x2;
  static constexpr int HTTPCLIENT_IO_CONTROL = 0x4;

  virtual ~RGWHTTPClient();
  explicit RGWHTTPClient(CephContext *cct,
                         const string& _method,
                         const string& _url)
    : has_send_len(false),
      http_status(HTTP_STATUS_NOSTATUS),
      req_data(nullptr),
      verify_ssl(cct->_conf->rgw_verify_ssl),
      cct(cct),
      method(_method),
      url(_url) {
  }

  void append_header(const string& name, const string& val) {
    headers.push_back(pair<string, string>(name, val));
  }

  void set_send_length(size_t len) {
    send_len = len;
    has_send_len = true;
  }

  void set_send_data_hint(bool hint) {
    send_data_hint = hint;
  }

  long get_http_status() const {
    return http_status;
  }

  void set_verify_ssl(bool flag) {
    verify_ssl = flag;
  }

  int process(optional_yield y=null_yield);

  int wait(optional_yield y=null_yield);
  void cancel();
  bool is_done();

  rgw_http_req_data *get_req_data() { return req_data; }

  string to_str();

  int get_req_retcode();

  void set_url(const string& _url) {
    url = _url;
  }

  void set_method(const string& _method) {
    method = _method;
  }

  void set_io_user_info(void *_user_info) override {
    user_info = _user_info;
  }

  void *get_io_user_info() override {
    return user_info;
  }
};


class RGWHTTPHeadersCollector : public RGWHTTPClient {
public:
  typedef std::string header_name_t;
  typedef std::string header_value_t;
  typedef std::set<header_name_t, ltstr_nocase> header_spec_t;

  RGWHTTPHeadersCollector(CephContext * const cct,
                          const string& method,
                          const string& url,
                          const header_spec_t &relevant_headers)
    : RGWHTTPClient(cct, method, url),
      relevant_headers(relevant_headers) {
  }

  std::map<header_name_t, header_value_t, ltstr_nocase> get_headers() const {
    return found_headers;
  }


  const header_value_t& get_header_value(const header_name_t& name) const {
    return found_headers.at(name);
  }

protected:
  int receive_header(void *ptr, size_t len) override;

private:
  const std::set<header_name_t, ltstr_nocase> relevant_headers;
  std::map<header_name_t, header_value_t, ltstr_nocase> found_headers;
};


class RGWHTTPTransceiver : public RGWHTTPHeadersCollector {
  bufferlist * const read_bl;
  std::string post_data;
  size_t post_data_index;

public:
  RGWHTTPTransceiver(CephContext * const cct,
                     const string& method,
                     const string& url,
                     bufferlist * const read_bl,
                     const header_spec_t intercept_headers = {})
    : RGWHTTPHeadersCollector(cct, method, url, intercept_headers),
      read_bl(read_bl),
      post_data_index(0) {
  }

  RGWHTTPTransceiver(CephContext * const cct,
                     const string& method,
                     const string& url,
                     bufferlist * const read_bl,
                     const bool verify_ssl,
                     const header_spec_t intercept_headers = {})
    : RGWHTTPHeadersCollector(cct, method, url, intercept_headers),
      read_bl(read_bl),
      post_data_index(0) {
    set_verify_ssl(verify_ssl);
  }

  void set_post_data(const std::string& _post_data) {
    this->post_data = _post_data;
  }

protected:
  int send_data(void* ptr, size_t len, bool *pause=nullptr) override;

  int receive_data(void *ptr, size_t len, bool *pause) override {
    read_bl->append((char *)ptr, len);
    return 0;
  }
};

typedef RGWHTTPTransceiver RGWPostHTTPData;


class RGWCompletionManager;

enum RGWHTTPRequestSetState {
  SET_NOP = 0,
  SET_WRITE_PAUSED = 1,
  SET_WRITE_RESUME = 2,
  SET_READ_PAUSED = 3,
  SET_READ_RESUME = 4,
};

class RGWHTTPManager {
  struct set_state {
    rgw_http_req_data *req;
    int bitmask;

    set_state(rgw_http_req_data *_req, int _bitmask) : req(_req), bitmask(_bitmask) {}
  };
  CephContext *cct;
  RGWCompletionManager *completion_mgr;
  void *multi_handle;
  bool is_started;
  std::atomic<unsigned> going_down { 0 };
  std::atomic<unsigned> is_stopped { 0 };

  RWLock reqs_lock;
  map<uint64_t, rgw_http_req_data *> reqs;
  list<rgw_http_req_data *> unregistered_reqs;
  list<set_state> reqs_change_state;
  map<uint64_t, rgw_http_req_data *> complete_reqs;
  int64_t num_reqs;
  int64_t max_threaded_req;
  int thread_pipe[2];

  void register_request(rgw_http_req_data *req_data);
  void complete_request(rgw_http_req_data *req_data);
  void _complete_request(rgw_http_req_data *req_data);
  bool unregister_request(rgw_http_req_data *req_data);
  void _unlink_request(rgw_http_req_data *req_data);
  void unlink_request(rgw_http_req_data *req_data);
  void finish_request(rgw_http_req_data *req_data, int r);
  void _finish_request(rgw_http_req_data *req_data, int r);
  void _set_req_state(set_state& ss);
  int link_request(rgw_http_req_data *req_data);

  void manage_pending_requests();

  class ReqsThread : public Thread {
    RGWHTTPManager *manager;

  public:
    explicit ReqsThread(RGWHTTPManager *_m) : manager(_m) {}
    void *entry() override;
  };

  ReqsThread *reqs_thread;

  void *reqs_thread_entry();

  int signal_thread();

public:
  RGWHTTPManager(CephContext *_cct, RGWCompletionManager *completion_mgr = 
# 349 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_client.h" 3 4
                                                                          __null
# 349 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_client.h"
                                                                              );
  ~RGWHTTPManager();

  int start();
  void stop();

  int add_request(RGWHTTPClient *client);
  int remove_request(RGWHTTPClient *client);
  int set_request_state(RGWHTTPClient *client, RGWHTTPRequestSetState state);
};

class RGWHTTP
{
public:
  static int send(RGWHTTPClient *req);
  static int process(RGWHTTPClient *req, optional_yield y=null_yield);
};
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_keystone.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_init.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_init.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive_ptr.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 3 4

# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 3 4
namespace boost
{
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 3 4
template<class T> class intrusive_ptr
{
private:

    typedef intrusive_ptr this_type;

public:

    typedef T element_type;

    constexpr intrusive_ptr() noexcept : px( 0 )
    {
    }

    intrusive_ptr( T * p, bool add_ref = true ): px( p )
    {
        if( px != 0 && add_ref ) intrusive_ptr_add_ref( px );
    }



    template<class U>


    intrusive_ptr( intrusive_ptr<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() )






    : px( rhs.get() )
    {
        if( px != 0 ) intrusive_ptr_add_ref( px );
    }



    intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
    {
        if( px != 0 ) intrusive_ptr_add_ref( px );
    }

    ~intrusive_ptr()
    {
        if( px != 0 ) intrusive_ptr_release( px );
    }



    template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }







    intrusive_ptr(intrusive_ptr && rhs) noexcept : px( rhs.px )
    {
        rhs.px = 0;
    }

    intrusive_ptr & operator=(intrusive_ptr && rhs) noexcept
    {
        this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
        return *this;
    }

    template<class U> friend class intrusive_ptr;

    template<class U>


    intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())






    : px( rhs.px )
    {
        rhs.px = 0;
    }

    template<class U>
    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) noexcept
    {
        this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
        return *this;
    }



    intrusive_ptr & operator=(intrusive_ptr const & rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }

    intrusive_ptr & operator=(T * rhs)
    {
        this_type(rhs).swap(*this);
        return *this;
    }

    void reset()
    {
        this_type().swap( *this );
    }

    void reset( T * rhs )
    {
        this_type( rhs ).swap( *this );
    }

    void reset( T * rhs, bool add_ref )
    {
        this_type( rhs, add_ref ).swap( *this );
    }

    T * get() const noexcept
    {
        return px;
    }

    T * detach() noexcept
    {
        T * ret = px;
        px = 0;
        return ret;
    }

    T & operator*() const noexcept
    {
        (static_cast<void> (0));
        return *px;
    }

    T * operator->() const noexcept
    {
        (static_cast<void> (0));
        return px;
    }


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    explicit operator bool () const noexcept
    {
        return px != 0;
    }
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    bool operator! () const noexcept
    {
        return px == 0;
    }
# 205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 2 3 4

    void swap(intrusive_ptr & rhs) noexcept
    {
        T * tmp = px;
        px = rhs.px;
        rhs.px = tmp;
    }

private:

    T * px;
};

template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
{
    return a.get() != b.get();
}

template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) noexcept
{
    return a.get() == b;
}

template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept
{
    return a.get() != b;
}

template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) noexcept
{
    return a == b.get();
}

template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept
{
    return a != b.get();
}
# 261 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 3 4
template<class T> inline bool operator==( intrusive_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, intrusive_ptr<T> const & p ) noexcept
{
    return p.get() == 0;
}

template<class T> inline bool operator!=( intrusive_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, intrusive_ptr<T> const & p ) noexcept
{
    return p.get() != 0;
}



template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept
{
    return std::less<T *>()(a.get(), b.get());
}

template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) noexcept
{
    lhs.swap(rhs);
}



template<class T> T * get_pointer(intrusive_ptr<T> const & p) noexcept
{
    return p.get();
}

template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
{
    return static_cast<T *>(p.get());
}

template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
{
    return const_cast<T *>(p.get());
}

template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
{
    return dynamic_cast<T *>(p.get());
}
# 337 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 3 4
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)

{
    os << p.get();
    return os;
}
# 352 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/smart_ptr/intrusive_ptr.hpp" 3 4
template< class T > struct hash;

template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) noexcept
{
    return boost::hash< T* >()( p.get() );
}

}
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive_ptr.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_init.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/common_init.h" 1
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/common_init.h"

# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/common_init.h"
class CephContext;

enum common_init_flags_t {

  CINIT_FLAG_UNPRIVILEGED_DAEMON_DEFAULTS = 0x1,


  CINIT_FLAG_NO_DEFAULT_CONFIG_FILE = 0x2,


  CINIT_FLAG_NO_CLOSE_STDERR = 0x4,


  CINIT_FLAG_NO_DAEMON_ACTIONS = 0x8,


  CINIT_FLAG_DEFER_DROP_PRIVILEGES = 0x10,


  CINIT_FLAG_NO_MON_CONFIG = 0x20,


  CINIT_FLAG_NO_CCT_PERF_COUNTERS = 0x40,
};


class CephInitParameters;
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/common_init.h"
CephContext *common_preinit(const CephInitParameters &iparams,
       enum code_environment_t code_env, int flags);



void complain_about_parse_errors(CephContext *cct,
     std::deque<std::string> *parse_errors);
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/common_init.h"
void common_init_finish(CephContext *cct);
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_init.h" 2

class CephContext;






boost::intrusive_ptr<CephContext>
global_init(
  const std::map<std::string,std::string> *defaults,
  std::vector < const char* >& args,
  uint32_t module_type,
  code_environment_t code_env,
  int flags,
  const char *data_dir_option = 0,
  bool run_pre_init = true);

void intrusive_ptr_add_ref(CephContext* cct);
void intrusive_ptr_release(CephContext* cct);



void global_pre_init(const std::map<std::string,std::string> *defaults,
       std::vector < const char* >& args,
       uint32_t module_type, code_environment_t code_env,
       int flags);






int global_init_prefork(CephContext *cct);





void global_init_postfork_start(CephContext *cct);




void global_init_postfork_finish(CephContext *cct);
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_init.h"
void global_init_daemonize(CephContext *cct);






void global_init_chdir(const CephContext *cct);
# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/global/global_init.h"
int global_init_shutdown_stderr(CephContext *cct);





int global_init_preload_erasure_code(const CephContext *cct);




void global_print_banner(void);
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_keystone.h" 2



int rgw_open_cms_envelope(CephContext *cct,
                          const std::string& src,
                          std::string& dst);
int rgw_decode_b64_cms(CephContext *cct,
                       const string& signed_b64,
                       bufferlist& bl);
bool rgw_is_pki_token(const string& token);
void rgw_get_token_id(const string& token, string& token_id);
static inline std::string rgw_get_token_id(const string& token)
{
  std::string token_id;
  rgw_get_token_id(token, token_id);

  return token_id;
}
bool rgw_decode_pki_token(CephContext *cct,
                          const string& token,
                          bufferlist& bl);

namespace rgw {
namespace keystone {

enum class ApiVersion {
  VER_2,
  VER_3
};


class Config {
protected:
  Config() = default;
  virtual ~Config() = default;

public:
  virtual std::string get_endpoint_url() const noexcept = 0;
  virtual ApiVersion get_api_version() const noexcept = 0;

  virtual std::string get_admin_token() const noexcept = 0;
  virtual boost::string_ref get_admin_user() const noexcept = 0;
  virtual std::string get_admin_password() const noexcept = 0;
  virtual boost::string_ref get_admin_tenant() const noexcept = 0;
  virtual boost::string_ref get_admin_project() const noexcept = 0;
  virtual boost::string_ref get_admin_domain() const noexcept = 0;
};

class CephCtxConfig : public Config {
protected:
  CephCtxConfig() = default;
  virtual ~CephCtxConfig() = default;

  const static std::string empty;

public:
  static CephCtxConfig& get_instance() {
    static CephCtxConfig instance;
    return instance;
  }

  std::string get_endpoint_url() const noexcept override;
  ApiVersion get_api_version() const noexcept override;

  std::string get_admin_token() const noexcept override;

  boost::string_ref get_admin_user() const noexcept override {
    return g_ceph_context->_conf->rgw_keystone_admin_user;
  }

  std::string get_admin_password() const noexcept override;

  boost::string_ref get_admin_tenant() const noexcept override {
    return g_ceph_context->_conf->rgw_keystone_admin_tenant;
  }

  boost::string_ref get_admin_project() const noexcept override {
    return g_ceph_context->_conf->rgw_keystone_admin_project;
  }

  boost::string_ref get_admin_domain() const noexcept override {
    return g_ceph_context->_conf->rgw_keystone_admin_domain;
  }
};


class TokenEnvelope;
class TokenCache;

class Service {
public:
  class RGWKeystoneHTTPTransceiver : public RGWHTTPTransceiver {
  public:
    RGWKeystoneHTTPTransceiver(CephContext * const cct,
                               const string& method,
                               const string& url,
                               bufferlist * const token_body_bl)
      : RGWHTTPTransceiver(cct, method, url, token_body_bl,
                           cct->_conf->rgw_keystone_verify_ssl,
                           { "X-Subject-Token" }) {
    }

    const header_value_t& get_subject_token() const {
      try {
        return get_header_value("X-Subject-Token");
      } catch (std::out_of_range&) {
        static header_value_t empty_val;
        return empty_val;
      }
    }
  };

  typedef RGWKeystoneHTTPTransceiver RGWValidateKeystoneToken;
  typedef RGWKeystoneHTTPTransceiver RGWGetKeystoneAdminToken;
  typedef RGWKeystoneHTTPTransceiver RGWGetRevokedTokens;

  static int get_admin_token(CephContext* const cct,
                             TokenCache& token_cache,
                             const Config& config,
                             std::string& token);
  static int issue_admin_token_request(CephContext* const cct,
                                       const Config& config,
                                       TokenEnvelope& token);
  static int get_keystone_barbican_token(CephContext * const cct,
                                         std::string& token);
};


class TokenEnvelope {
public:
  class Domain {
  public:
    string id;
    string name;
    void decode_json(JSONObj *obj);
  };
  class Project {
  public:
    Domain domain;
    string id;
    string name;
    void decode_json(JSONObj *obj);
  };

  class Token {
  public:
    Token() : expires(0) { }
    string id;
    time_t expires;
    Project tenant_v2;
    void decode_json(JSONObj *obj);
  };

  class Role {
  public:
    string id;
    string name;
    void decode_json(JSONObj *obj);
  };

  class User {
  public:
    string id;
    string name;
    Domain domain;
    list<Role> roles_v2;
    void decode_json(JSONObj *obj);
  };

  Token token;
  Project project;
  User user;
  list<Role> roles;

  void decode_v3(JSONObj* obj);
  void decode_v2(JSONObj* obj);

public:

  TokenEnvelope() = default;

  time_t get_expires() const { return token.expires; }
  const std::string& get_domain_id() const {return project.domain.id;};
  const std::string& get_domain_name() const {return project.domain.name;};
  const std::string& get_project_id() const {return project.id;};
  const std::string& get_project_name() const {return project.name;};
  const std::string& get_user_id() const {return user.id;};
  const std::string& get_user_name() const {return user.name;};
  bool has_role(const string& r) const;
  bool expired() const {
    const uint64_t now = ceph_clock_now().sec();
    return now >= static_cast<uint64_t>(get_expires());
  }
  int parse(CephContext* cct,
            const std::string& token_str,
            ceph::buffer::list& bl ,
            ApiVersion version);
};


class TokenCache {
  struct token_entry {
    TokenEnvelope token;
    list<string>::iterator lru_iter;
  };

  std::atomic<bool> down_flag = { false };

  class RevokeThread : public Thread {
    friend class TokenCache;
    typedef RGWPostHTTPData RGWGetRevokedTokens;

    CephContext* const cct;
    TokenCache* const cache;
    const rgw::keystone::Config& config;

    Mutex lock;
    Cond cond;

    RevokeThread(CephContext* const cct,
                 TokenCache* const cache,
                 const rgw::keystone::Config& config)
      : cct(cct),
        cache(cache),
        config(config),
        lock("rgw::keystone::TokenCache::RevokeThread") {
    }

    void *entry() override;
    void stop();
    int check_revoked();
  } revocator;

  const boost::intrusive_ptr<CephContext> cct;

  std::string admin_token_id;
  std::string barbican_token_id;
  std::map<std::string, token_entry> tokens;
  std::list<std::string> tokens_lru;

  Mutex lock;

  const size_t max;

  explicit TokenCache(const rgw::keystone::Config& config)
    : revocator(g_ceph_context, this, config),
      cct(g_ceph_context),
      lock("rgw::keystone::TokenCache"),
      max(cct->_conf->rgw_keystone_token_cache_size) {





    if (cct->_conf->rgw_keystone_revocation_interval > 0
        && cct->_conf->rgw_keystone_token_cache_size ) {

      revocator.create("rgw_swift_k_rev");
    }
  }

  ~TokenCache() {
    down_flag = true;


    if (revocator.is_started()) {
      revocator.stop();
      revocator.join();
    }
  }

public:
  TokenCache(const TokenCache&) = delete;
  void operator=(const TokenCache&) = delete;

  template<class ConfigT>
  static TokenCache& get_instance() {
    static_assert(std::is_base_of<rgw::keystone::Config, ConfigT>::value,
                  "ConfigT must be a subclass of rgw::keystone::Config");


    static TokenCache instance(ConfigT::get_instance());
    return instance;
  }

  bool find(const std::string& token_id, TokenEnvelope& token);
  boost::optional<TokenEnvelope> find(const std::string& token_id) {
    TokenEnvelope token_envlp;
    if (find(token_id, token_envlp)) {
      return token_envlp;
    }
    return boost::none;
  }
  bool find_admin(TokenEnvelope& token);
  bool find_barbican(TokenEnvelope& token);
  void add(const std::string& token_id, const TokenEnvelope& token);
  void add_admin(const TokenEnvelope& token);
  void add_barbican(const TokenEnvelope& token);
  void invalidate(const std::string& token_id);
  bool going_down() const;
private:
  void add_locked(const std::string& token_id, const TokenEnvelope& token);
  bool find_locked(const std::string& token_id, TokenEnvelope& token);

};


class AdminTokenRequest {
public:
  virtual ~AdminTokenRequest() = default;
  virtual void dump(Formatter* f) const = 0;
};

class AdminTokenRequestVer2 : public AdminTokenRequest {
  const Config& conf;

public:
  explicit AdminTokenRequestVer2(const Config& conf)
    : conf(conf) {
  }
  void dump(Formatter *f) const override;
};

class AdminTokenRequestVer3 : public AdminTokenRequest {
  const Config& conf;

public:
  explicit AdminTokenRequestVer3(const Config& conf)
    : conf(conf) {
  }
  void dump(Formatter *f) const override;
};

class BarbicanTokenRequestVer2 : public AdminTokenRequest {
  CephContext *cct;

public:
  explicit BarbicanTokenRequestVer2(CephContext * const _cct)
    : cct(_cct) {
  }
  void dump(Formatter *f) const override;
};

class BarbicanTokenRequestVer3 : public AdminTokenRequest {
  CephContext *cct;

public:
  explicit BarbicanTokenRequestVer3(CephContext * const _cct)
    : cct(_cct) {
  }
  void dump(Formatter *f) const override;
};


};
};
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_web_idp.h" 1







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_web_idp.h" 2


namespace rgw {
namespace web_idp {


struct WebTokenClaims {

    string sub;

    string aud;

    string iss;

    string user_name;
};

};
};
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h" 2



namespace rgw {
namespace auth {

using Exception = std::system_error;




class Identity {
public:
  typedef std::map<std::string, int> aclspec_t;
  using idset_t = boost::container::flat_set<Principal>;

  virtual ~Identity() = default;
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
  virtual uint32_t get_perms_from_aclspec(const DoutPrefixProvider* dpp, const aclspec_t& aclspec) const = 0;




  virtual bool is_admin_of(const rgw_user& uid) const = 0;




  virtual bool is_owner_of(const rgw_user& uid) const = 0;





  virtual uint32_t get_perm_mask() const = 0;

  virtual bool is_anonymous() const final {



    return is_owner_of(rgw_user("anonymous"));
  }

  virtual void to_str(std::ostream& out) const = 0;



  virtual bool is_identity(const idset_t& ids) const = 0;


  virtual uint32_t get_identity_type() const = 0;


  virtual string get_acct_name() const = 0;
};

inline std::ostream& operator<<(std::ostream& out,
                                const rgw::auth::Identity& id) {
  id.to_str(out);
  return out;
}


std::unique_ptr<Identity> transform_old_authinfo(const req_state* const s);
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
class IdentityApplier : public Identity {
public:
  typedef std::unique_ptr<IdentityApplier> aplptr_t;

  virtual ~IdentityApplier() {};






  virtual void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const = 0;



  virtual void modify_request_state(const DoutPrefixProvider* dpp, req_state* s) const {}
};
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
class Completer {
public:



  typedef std::shared_ptr<Completer> cmplptr_t;

  virtual ~Completer() = default;




  virtual bool complete() = 0;



  virtual void modify_request_state(const DoutPrefixProvider* dpp, req_state* s) = 0;
};
# 187 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
class Engine {
public:
  virtual ~Engine() = default;

  class AuthResult {
    struct rejection_mark_t {};
    bool is_rejected = false;
    int reason = 0;

    std::pair<IdentityApplier::aplptr_t, Completer::cmplptr_t> result_pair;

    explicit AuthResult(const int reason)
      : reason(reason) {
    }

    AuthResult(rejection_mark_t&&, const int reason)
      : is_rejected(true),
        reason(reason) {
    }



    explicit AuthResult(IdentityApplier::aplptr_t&& applier)
      : result_pair(std::move(applier), nullptr) {
    }

    AuthResult(IdentityApplier::aplptr_t&& applier,
               Completer::cmplptr_t&& completer)
      : result_pair(std::move(applier), std::move(completer)) {
    }

  public:
    enum class Status {

      DENIED,


      GRANTED,



      REJECTED
    };

    Status get_status() const {
      if (is_rejected) {
        return Status::REJECTED;
      } else if (! result_pair.first) {
        return Status::DENIED;
      } else {
        return Status::GRANTED;
      }
    }

    int get_reason() const {
      return reason;
    }

    IdentityApplier::aplptr_t get_applier() {
      return std::move(result_pair.first);
    }

    Completer::cmplptr_t&& get_completer() {
      return std::move(result_pair.second);
    }

    static AuthResult reject(const int reason = -
# 253 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h" 3 4
                                                13
# 253 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
                                                      ) {
      return AuthResult(rejection_mark_t(), reason);
    }

    static AuthResult deny(const int reason = -
# 257 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h" 3 4
                                              13
# 257 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
                                                    ) {
      return AuthResult(reason);
    }

    static AuthResult grant(IdentityApplier::aplptr_t&& applier) {
      return AuthResult(std::move(applier));
    }

    static AuthResult grant(IdentityApplier::aplptr_t&& applier,
                            Completer::cmplptr_t&& completer) {
      return AuthResult(std::move(applier), std::move(completer));
    }
  };

  using result_t = AuthResult;


  virtual const char* get_name() const noexcept = 0;
# 284 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
  virtual result_t authenticate(const DoutPrefixProvider* dpp, const req_state* s) const = 0;
};



class TokenExtractor {
public:
  virtual ~TokenExtractor() = default;
  virtual std::string get_token(const req_state* s) const = 0;
};
# 304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
class Strategy : public Engine {
public:


  enum class Control {



    REQUISITE,





    SUFFICIENT,





    FALLBACK,
  };

  Engine::result_t authenticate(const DoutPrefixProvider* dpp, const req_state* s) const override final;

  bool is_empty() const {
    return auth_stack.empty();
  }

  static int apply(const DoutPrefixProvider* dpp, const Strategy& auth_strategy, req_state* s) noexcept;

private:


  using stack_item_t = std::pair<std::reference_wrapper<const Engine>,
                                 Control>;
  std::vector<stack_item_t> auth_stack;

protected:
  void add_engine(Control ctrl_flag, const Engine& engine) noexcept;
};







class StrategyRegistry;

class WebIdentityApplier : public IdentityApplier {
protected:
  CephContext* const cct;
  RGWRados* const store;
  rgw::web_idp::WebTokenClaims token_claims;

  string get_idp_url() const;

public:
  WebIdentityApplier( CephContext* const cct,
                      RGWRados* const store,
                      const rgw::web_idp::WebTokenClaims& token_claims)
    : cct(cct),
      store(store),
      token_claims(token_claims) {
  }

  void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const override {
    user_info.user_id = rgw_user(token_claims.sub);
    user_info.display_name = token_claims.user_name;
  }

  void modify_request_state(const DoutPrefixProvider *dpp, req_state* s) const override;

  uint32_t get_perms_from_aclspec(const DoutPrefixProvider* dpp, const aclspec_t& aclspec) const override {
    return 0x00;
  }

  bool is_admin_of(const rgw_user& uid) const override {
    return false;
  }

  bool is_owner_of(const rgw_user& uid) const override {
    return false;
  }

  uint32_t get_perm_mask() const override {
    return 0x00;
  }

  void to_str(std::ostream& out) const override;

  bool is_identity(const idset_t& ids) const override;

  uint32_t get_identity_type() const override {
    return TYPE_WEB;
  }

  string get_acct_name() const override {
    return token_claims.user_name;
  }

  struct Factory {
    virtual ~Factory() {}

    virtual aplptr_t create_apl_web_identity( CephContext* cct,
                                              const req_state* s,
                                              const rgw::web_idp::WebTokenClaims& token) const = 0;
  };
};
# 422 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth.h"
class RemoteApplier : public IdentityApplier {
public:
  class AuthInfo {
    friend class RemoteApplier;
  protected:
    const rgw_user acct_user;
    const std::string acct_name;
    const uint32_t perm_mask;
    const bool is_admin;
    const uint32_t acct_type;

  public:
    enum class acct_privilege_t {
      IS_ADMIN_ACCT,
      IS_PLAIN_ACCT
    };

    AuthInfo(const rgw_user& acct_user,
             const std::string& acct_name,
             const uint32_t perm_mask,
             const acct_privilege_t level,
             const uint32_t acct_type=TYPE_NONE)
    : acct_user(acct_user),
      acct_name(acct_name),
      perm_mask(perm_mask),
      is_admin(acct_privilege_t::IS_ADMIN_ACCT == level),
      acct_type(acct_type) {
    }
  };

  using aclspec_t = rgw::auth::Identity::aclspec_t;
  typedef std::function<uint32_t(const aclspec_t&)> acl_strategy_t;

protected:
  CephContext* const cct;


  RGWRados* const store;




  const acl_strategy_t extra_acl_strategy;

  const AuthInfo info;
  const bool implicit_tenants;

  virtual void create_account(const DoutPrefixProvider* dpp,
                              const rgw_user& acct_user,
                              RGWUserInfo& user_info) const;

public:
  RemoteApplier(CephContext* const cct,
                RGWRados* const store,
                acl_strategy_t&& extra_acl_strategy,
                const AuthInfo& info,
                const bool implicit_tenants)
    : cct(cct),
      store(store),
      extra_acl_strategy(std::move(extra_acl_strategy)),
      info(info),
      implicit_tenants(implicit_tenants) {
  }

  uint32_t get_perms_from_aclspec(const DoutPrefixProvider* dpp, const aclspec_t& aclspec) const override;
  bool is_admin_of(const rgw_user& uid) const override;
  bool is_owner_of(const rgw_user& uid) const override;
  bool is_identity(const idset_t& ids) const override;

  uint32_t get_perm_mask() const override { return info.perm_mask; }
  void to_str(std::ostream& out) const override;
  void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const override;
  uint32_t get_identity_type() const override { return info.acct_type; }
  string get_acct_name() const override { return info.acct_name; }

  struct Factory {
    virtual ~Factory() {}



    virtual aplptr_t create_apl_remote(CephContext* cct,
                                       const req_state* s,
                                       acl_strategy_t&& extra_acl_strategy,
                                       const AuthInfo &info) const = 0;
  };
};






class LocalApplier : public IdentityApplier {
  using aclspec_t = rgw::auth::Identity::aclspec_t;

protected:
  const RGWUserInfo user_info;
  const std::string subuser;
  uint32_t perm_mask;

  uint32_t get_perm_mask(const std::string& subuser_name,
                         const RGWUserInfo &uinfo) const;

public:
  static const std::string NO_SUBUSER;

  LocalApplier(CephContext* const cct,
               const RGWUserInfo& user_info,
               std::string subuser,
               const boost::optional<uint32_t>& perm_mask)
    : user_info(user_info),
      subuser(std::move(subuser)) {
    if (perm_mask) {
      this->perm_mask = perm_mask.get();
    } else {
      this->perm_mask = 0xFF00;
    }
  }


  uint32_t get_perms_from_aclspec(const DoutPrefixProvider* dpp, const aclspec_t& aclspec) const override;
  bool is_admin_of(const rgw_user& uid) const override;
  bool is_owner_of(const rgw_user& uid) const override;
  bool is_identity(const idset_t& ids) const override;
  uint32_t get_perm_mask() const override {
    if (this->perm_mask == 0xFF00) {
      return get_perm_mask(subuser, user_info);
    } else {
      return this->perm_mask;
    }
  }
  void to_str(std::ostream& out) const override;
  void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const override;
  uint32_t get_identity_type() const override { return TYPE_RGW; }
  string get_acct_name() const override { return {}; }

  struct Factory {
    virtual ~Factory() {}
    virtual aplptr_t create_apl_local(CephContext* cct,
                                      const req_state* s,
                                      const RGWUserInfo& user_info,
                                      const std::string& subuser,
                                      const boost::optional<uint32_t>& perm_mask) const = 0;
    };
};

class RoleApplier : public IdentityApplier {
protected:
  const string role_name;
  const rgw_user user_id;
  vector<std::string> role_policies;

public:

  RoleApplier(CephContext* const cct,
               const string& role_name,
               const rgw_user& user_id,
               const vector<std::string>& role_policies)
    : role_name(role_name),
      user_id(user_id),
      role_policies(role_policies) {}

  uint32_t get_perms_from_aclspec(const DoutPrefixProvider* dpp, const aclspec_t& aclspec) const override {
    return 0;
  }
  bool is_admin_of(const rgw_user& uid) const override {
    return false;
  }
  bool is_owner_of(const rgw_user& uid) const override {
    return false;
  }
  bool is_identity(const idset_t& ids) const override;
  uint32_t get_perm_mask() const override {
    return 0x00;
  }
  void to_str(std::ostream& out) const override;
  void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const override;
  uint32_t get_identity_type() const override { return TYPE_ROLE; }
  string get_acct_name() const override { return {}; }
  void modify_request_state(const DoutPrefixProvider* dpp, req_state* s) const override;

  struct Factory {
    virtual ~Factory() {}
    virtual aplptr_t create_apl_role( CephContext* cct,
                                      const req_state* s,
                                      const string& role_name,
                                      const rgw_user& user_id,
                                      const vector<std::string>& role_policies) const = 0;
    };
};


class AnonymousEngine : public Engine {
  CephContext* const cct;
  const rgw::auth::LocalApplier::Factory* const apl_factory;

public:
  AnonymousEngine(CephContext* const cct,
                  const rgw::auth::LocalApplier::Factory* const apl_factory)
    : cct(cct),
      apl_factory(apl_factory) {
  }

  const char* get_name() const noexcept override {
    return "rgw::auth::AnonymousEngine";
  }

  Engine::result_t authenticate(const DoutPrefixProvider* dpp, const req_state* s) const override final;

protected:
  virtual bool is_applicable(const req_state*) const noexcept {
    return true;
  }
};

}
}


uint32_t rgw_perms_from_aclspec_default_strategy(
  const rgw_user& uid,
  const rgw::auth::Identity::aclspec_t& aclspec);
# 1954 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 2

class RGWObjectCtx;
class RGWSysObjectCtx;


struct req_state : DoutPrefixProvider {
  CephContext *cct;
  rgw::io::BasicClient *cio{nullptr};
  http_op op{OP_UNKNOWN};
  RGWOpType op_type{};
  bool content_started{false};
  int format{0};
  ceph::Formatter *formatter{nullptr};
  string decoded_uri;
  string relative_uri;
  const char *length{nullptr};
  int64_t content_length{0};
  map<string, string> generic_attrs;
  rgw_err err;
  bool expect_cont{false};
  uint64_t obj_size{0};
  bool enable_ops_log;
  bool enable_usage_log;
  uint8_t defer_to_bucket_acls;
  uint32_t perm_mask{0};


  string account_name;

  string bucket_tenant;
  string bucket_name;

  rgw_bucket bucket;
  rgw_obj_key object;
  string src_tenant_name;
  string src_bucket_name;
  rgw_obj_key src_object;
  ACLOwner bucket_owner;
  ACLOwner owner;

  string zonegroup_name;
  string zonegroup_endpoint;
  string bucket_instance_id;
  int bucket_instance_shard_id{-1};
  string redirect_zone_endpoint;

  string redirect;

  RGWBucketInfo bucket_info;
  real_time bucket_mtime;
  std::map<std::string, ceph::bufferlist> bucket_attrs;
  bool bucket_exists{false};
  rgw_placement_rule dest_placement;

  bool has_bad_meta{false};

  RGWUserInfo *user;

  struct {






    std::unique_ptr<rgw::auth::Identity> identity;

    std::shared_ptr<rgw::auth::Completer> completer;





    class {

      friend class RGWPostObj_ObjStore_S3;

      friend class rgw::auth::s3::AWSBrowserUploadAbstractor;

      std::string access_key;
      std::string signature;
      std::string x_amz_algorithm;
      std::string x_amz_credential;
      std::string x_amz_date;
      std::string x_amz_security_token;
      ceph::bufferlist encoded_policy;
    } s3_postobj_creds;
  } auth;

  std::unique_ptr<RGWAccessControlPolicy> user_acl;
  std::unique_ptr<RGWAccessControlPolicy> bucket_acl;
  std::unique_ptr<RGWAccessControlPolicy> object_acl;

  rgw::IAM::Environment env;
  boost::optional<rgw::IAM::Policy> iam_policy;
  vector<rgw::IAM::Policy> iam_user_policies;



  bool system_request{false};

  string canned_acl;
  bool has_acl_header{false};
  bool local_source{false};

  int prot_flags{0};


  struct {
    string override;
    string fallback;
  } content_disp;

  string host_id;

  req_info info;
  req_init_state init_state;

  using Clock = ceph::coarse_real_clock;
  Clock::time_point time;

  Clock::duration time_elapsed() const { return Clock::now() - time; }

  RGWObjectCtx *obj_ctx{nullptr};
  RGWSysObjectCtx *sysobj_ctx{nullptr};
  string dialect;
  string req_id;
  string trans_id;
  uint64_t id;

  bool mfa_verified{false};


  optional_yield yield{null_yield};

  req_state(CephContext* _cct, RGWEnv* e, RGWUserInfo* u, uint64_t id);
  ~req_state();

  bool is_err() const { return err.is_err(); }


  std::ostream& gen_prefix(std::ostream& out) const override;
  CephContext* get_cct() const override { return cct; }
  unsigned get_subsys() const override { return ceph_subsys_rgw; }
};

void set_req_state_err(struct req_state*, int);
void set_req_state_err(struct req_state*, int, const string&);
void set_req_state_err(struct rgw_err&, int, const int);
void dump(struct req_state*);


struct RGWBucketEnt {
  rgw_bucket bucket;
  size_t size;
  size_t size_rounded;
  ceph::real_time creation_time;
  uint64_t count;




  rgw_placement_rule placement_rule;

  RGWBucketEnt()
    : size(0),
      size_rounded(0),
      count(0) {
  }
  RGWBucketEnt(const RGWBucketEnt&) = default;
  RGWBucketEnt(RGWBucketEnt&&) = default;
  explicit RGWBucketEnt(const rgw_user& u, cls_user_bucket_entry&& e)
    : bucket(u, std::move(e.bucket)),
      size(e.size),
      size_rounded(e.size_rounded),
      creation_time(e.creation_time),
      count(e.count) {
  }

  RGWBucketEnt& operator=(const RGWBucketEnt&) = default;

  void convert(cls_user_bucket_entry *b) const {
    bucket.convert(&b->bucket);
    b->size = size;
    b->size_rounded = size_rounded;
    b->creation_time = creation_time;
    b->count = count;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 7; __u8 struct_compat = 5; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    uint64_t s = size;
    __u32 mt = ceph::real_clock::to_time_t(creation_time);
    string empty_str;
    encode(empty_str, bl);
    encode(s, bl);
    encode(mt, bl);
    encode(count, bl);
    encode(bucket, bl);
    s = size_rounded;
    encode(s, bl);
    encode(creation_time, bl);
    encode(placement_rule, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 5) { __u8 struct_compat; decode(struct_compat, bl); if (7 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "7" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 5) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    __u32 mt;
    uint64_t s;
    string empty_str;
    decode(empty_str, bl);
    decode(s, bl);
    decode(mt, bl);
    size = s;
    if (struct_v < 6) {
      creation_time = ceph::real_clock::from_time_t(mt);
    }
    if (struct_v >= 2)
      decode(count, bl);
    if (struct_v >= 3)
      decode(bucket, bl);
    if (struct_v >= 4)
      decode(s, bl);
    size_rounded = s;
    if (struct_v >= 6)
      decode(creation_time, bl);
    if (struct_v >= 7)
      decode(placement_rule, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWBucketEnt*>& o);
};
inline void encode(const RGWBucketEnt &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWBucketEnt &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_obj {
  rgw_bucket bucket;
  rgw_obj_key key;

  bool in_extra_data{false};


  std::string index_hash_source;

  rgw_obj() {}
  rgw_obj(const rgw_bucket& b, const std::string& name) : bucket(b), key(name) {}
  rgw_obj(const rgw_bucket& b, const rgw_obj_key& k) : bucket(b), key(k) {}
  rgw_obj(const rgw_bucket& b, const rgw_obj_index_key& k) : bucket(b), key(k) {}

  void init(const rgw_bucket& b, const std::string& name) {
    bucket = b;
    key.set(name);
  }
  void init(const rgw_bucket& b, const std::string& name, const string& i, const string& n) {
    bucket = b;
    key.set(name, i, n);
  }
  void init_ns(const rgw_bucket& b, const std::string& name, const string& n) {
    bucket = b;
    key.name = name;
    key.instance.clear();
    key.ns = n;
  }

  bool empty() const {
    return key.empty();
  }

  void set_key(const rgw_obj_key& k) {
    key = k;
  }

  string get_oid() const {
    return key.get_oid();
  }

  const string& get_hash_object() const {
    return index_hash_source.empty() ? key.name : index_hash_source;
  }

  void set_in_extra_data(bool val) {
    in_extra_data = val;
  }

  bool is_in_extra_data() const {
    return in_extra_data;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 6; __u8 struct_compat = 6; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(bucket, bl);
    encode(key.ns, bl);
    encode(key.name, bl);
    encode(key.instance, bl);

    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (6 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "6" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    if (struct_v < 6) {
      string s;
      decode(bucket.name, bl);
      decode(s, bl);
      decode(key.ns, bl);
      decode(key.name, bl);
      if (struct_v >= 2)
        decode(bucket, bl);
      if (struct_v >= 4)
        decode(key.instance, bl);
      if (key.ns.empty() && key.instance.empty()) {
        if (key.name[0] == '_') {
          key.name = key.name.substr(1);
        }
      } else {
        if (struct_v >= 5) {
          decode(key.name, bl);
        } else {
          ssize_t pos = key.name.find('_', 1);
          if (pos < 0) {
            throw buffer::error();
          }
          key.name = key.name.substr(pos + 1);
        }
      }
    } else {
      decode(bucket, bl);
      decode(key.ns, bl);
      decode(key.name, bl);
      decode(key.instance, bl);

    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_obj*>& o);

  bool operator==(const rgw_obj& o) const {
    return (key == o.key) &&
           (bucket == o.bucket);
  }
  bool operator<(const rgw_obj& o) const {
    int r = key.name.compare(o.key.name);
    if (r == 0) {
      r = bucket.bucket_id.compare(o.bucket.bucket_id);
      if (r == 0) {
        r = key.ns.compare(o.key.ns);
        if (r == 0) {
          r = key.instance.compare(o.key.instance);
        }
      }
    }

    return (r < 0);
  }

  const rgw_pool& get_explicit_data_pool() {
    if (!in_extra_data || bucket.explicit_placement.data_extra_pool.empty()) {
      return bucket.explicit_placement.data_pool;
    }
    return bucket.explicit_placement.data_extra_pool;
  }
};
inline void encode(const rgw_obj &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_obj &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cache_entry_info {
  string cache_locator;
  uint64_t gen;

  rgw_cache_entry_info() : gen(0) {}
};

inline ostream& operator<<(ostream& out, const rgw_obj &o) {
  return out << o.bucket.name << ":" << o.get_oid();
}

static inline void buf_to_hex(const unsigned char* const buf,
                              const size_t len,
                              char* const str)
{
  str[0] = '\0';
  for (size_t i = 0; i < len; i++) {
    ::sprintf(&str[i*2], "%02x", static_cast<int>(buf[i]));
  }
}

template<size_t N> static inline std::array<char, N * 2 + 1>
buf_to_hex(const std::array<unsigned char, N>& buf)
{
  static_assert(N > 0, "The input array must be at least one element long");

  std::array<char, N * 2 + 1> hex_dest;
  buf_to_hex(buf.data(), N, hex_dest.data());
  return hex_dest;
}

static inline int hexdigit(char c)
{
  if (c >= '0' && c <= '9')
    return (c - '0');
  c = toupper(c);
  if (c >= 'A' && c <= 'F')
    return c - 'A' + 0xa;
  return -
# 2356 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
         22
# 2356 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
               ;
}

static inline int hex_to_buf(const char *hex, char *buf, int len)
{
  int i = 0;
  const char *p = hex;
  while (*p) {
    if (i >= len)
      return -
# 2365 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
             22
# 2365 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
                   ;
    buf[i] = 0;
    int d = hexdigit(*p);
    if (d < 0)
      return d;
    buf[i] = d << 4;
    p++;
    if (!*p)
      return -
# 2373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
             22
# 2373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
                   ;
    d = hexdigit(*p);
    if (d < 0)
      return d;
    buf[i] += d;
    i++;
    p++;
  }
  return i;
}

static inline int rgw_str_to_bool(const char *s, int def_val)
{
  if (!s)
    return def_val;

  return (strcasecmp(s, "true") == 0 ||
          strcasecmp(s, "on") == 0 ||
          strcasecmp(s, "yes") == 0 ||
          strcasecmp(s, "1") == 0);
}

static inline void append_rand_alpha(CephContext *cct, const string& src, string& dest, int len)
{
  dest = src;
  char buf[len + 1];
  gen_rand_alphanumeric(cct, buf, len);
  dest.append("_");
  dest.append(buf);
}

static inline const char *rgw_obj_category_name(RGWObjCategory category)
{
  switch (category) {
  case RGWObjCategory::None:
    return "rgw.none";
  case RGWObjCategory::Main:
    return "rgw.main";
  case RGWObjCategory::Shadow:
    return "rgw.shadow";
  case RGWObjCategory::MultiMeta:
    return "rgw.multimeta";
  }

  return "unknown";
}

static inline uint64_t rgw_rounded_kb(uint64_t bytes)
{
  return (bytes + 1023) / 1024;
}

static inline uint64_t rgw_rounded_objsize(uint64_t bytes)
{
  return ((bytes + 4095) & ~4095);
}

static inline uint64_t rgw_rounded_objsize_kb(uint64_t bytes)
{
  return ((bytes + 4095) & ~4095) / 1024;
}



static inline void add_amz_meta_header(
  std::map<std::string, std::string>& x_meta_map,
  const std::string& k,
  const std::string& v)
{
  auto it = x_meta_map.find(k);
  if (it != x_meta_map.end()) {
    std::string old = it->second;
    boost::algorithm::trim_right(old);
    old.append(",");
    old.append(v);
    x_meta_map[k] = old;
  } else {
    x_meta_map[k] = v;
  }
}

extern string rgw_string_unquote(const string& s);
extern void parse_csv_string(const string& ival, vector<string>& ovals);
extern int parse_key_value(string& in_str, string& key, string& val);
extern int parse_key_value(string& in_str, const char *delim, string& key, string& val);

extern boost::optional<std::pair<boost::string_view, boost::string_view>>
parse_key_value(const boost::string_view& in_str,
                const boost::string_view& delim);
extern boost::optional<std::pair<boost::string_view, boost::string_view>>
parse_key_value(const boost::string_view& in_str);



extern int parse_time(const char *time_str, real_time *time);
extern bool parse_rfc2616(const char *s, struct tm *t);
extern bool parse_iso8601(const char *s, struct tm *t, uint32_t *pns = 
# 2469 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
                                                                      __null
# 2469 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
                                                                          , bool extended_format = true);
extern string rgw_trim_whitespace(const string& src);
extern boost::string_view rgw_trim_whitespace(const boost::string_view& src);
extern string rgw_trim_quotes(const string& val);

extern void rgw_to_iso8601(const real_time& t, char *dest, int buf_size);
extern void rgw_to_iso8601(const real_time& t, string *dest);
extern std::string rgw_to_asctime(const utime_t& t);



rgw::IAM::Effect eval_user_policies(const vector<rgw::IAM::Policy>& user_policies,
                          const rgw::IAM::Environment& env,
                          boost::optional<const rgw::auth::Identity&> id,
                          const uint64_t op,
                          const rgw::ARN& arn);
bool verify_user_permission(const DoutPrefixProvider* dpp,
                            struct req_state * const s,
                            RGWAccessControlPolicy * const user_acl,
                            const vector<rgw::IAM::Policy>& user_policies,
                            const rgw::ARN& res,
                            const uint64_t op);
bool verify_user_permission_no_policy(const DoutPrefixProvider* dpp,
                                      struct req_state * const s,
                                      RGWAccessControlPolicy * const user_acl,
                                      const int perm);
bool verify_user_permission(const DoutPrefixProvider* dpp,
                            struct req_state * const s,
                            const rgw::ARN& res,
                            const uint64_t op);
bool verify_user_permission_no_policy(const DoutPrefixProvider* dpp,
                                      struct req_state * const s,
                                      int perm);
bool verify_bucket_permission(
  const DoutPrefixProvider* dpp,
  struct req_state * const s,
  const rgw_bucket& bucket,
  RGWAccessControlPolicy * const user_acl,
  RGWAccessControlPolicy * const bucket_acl,
  const boost::optional<rgw::IAM::Policy>& bucket_policy,
  const vector<rgw::IAM::Policy>& user_policies,
  const uint64_t op);
bool verify_bucket_permission(const DoutPrefixProvider* dpp, struct req_state * const s, const uint64_t op);
bool verify_bucket_permission_no_policy(
  const DoutPrefixProvider* dpp,
  struct req_state * const s,
  RGWAccessControlPolicy * const user_acl,
  RGWAccessControlPolicy * const bucket_acl,
  const int perm);
bool verify_bucket_permission_no_policy(const DoutPrefixProvider* dpp,
                                        struct req_state * const s,
     const int perm);
int verify_bucket_owner_or_policy(struct req_state* const s,
      const uint64_t op);
extern bool verify_object_permission(
  const DoutPrefixProvider* dpp,
  struct req_state * const s,
  const rgw_obj& obj,
  RGWAccessControlPolicy * const user_acl,
  RGWAccessControlPolicy * const bucket_acl,
  RGWAccessControlPolicy * const object_acl,
  const boost::optional<rgw::IAM::Policy>& bucket_policy,
  const vector<rgw::IAM::Policy>& user_policies,
  const uint64_t op);
extern bool verify_object_permission(const DoutPrefixProvider* dpp, struct req_state *s, uint64_t op);
extern bool verify_object_permission_no_policy(
  const DoutPrefixProvider* dpp,
  struct req_state * const s,
  RGWAccessControlPolicy * const user_acl,
  RGWAccessControlPolicy * const bucket_acl,
  RGWAccessControlPolicy * const object_acl,
  int perm);
extern bool verify_object_permission_no_policy(const DoutPrefixProvider* dpp, struct req_state *s,
            int perm);


extern void rgw_uri_escape_char(char c, string& dst);
extern std::string url_decode(const boost::string_view& src_str,
                              bool in_query = false);
extern void url_encode(const std::string& src, string& dst,
                       bool encode_slash = true);
extern std::string url_encode(const std::string& src, bool encode_slash = true);

extern void calc_hmac_sha1(const char *key, int key_len,
                          const char *msg, int msg_len, char *dest);

static inline sha1_digest_t
calc_hmac_sha1(const boost::string_view& key, const boost::string_view& msg) {
  sha1_digest_t dest;
  calc_hmac_sha1(key.data(), key.size(), msg.data(), msg.size(),
                 reinterpret_cast<char*>(dest.v));
  return dest;
}


extern void calc_hmac_sha256(const char *key, int key_len,
                             const char *msg, int msg_len,
                             char *dest);

static inline sha256_digest_t
calc_hmac_sha256(const char *key, const int key_len,
                 const char *msg, const int msg_len) {
  sha256_digest_t dest;
  calc_hmac_sha256(key, key_len, msg, msg_len,
                   reinterpret_cast<char*>(dest.v));
  return dest;
}

static inline sha256_digest_t
calc_hmac_sha256(const boost::string_view& key, const boost::string_view& msg) {
  sha256_digest_t dest;
  calc_hmac_sha256(key.data(), key.size(),
                   msg.data(), msg.size(),
                   reinterpret_cast<char*>(dest.v));
  return dest;
}

static inline sha256_digest_t
calc_hmac_sha256(const sha256_digest_t &key,
                 const boost::string_view& msg) {
  sha256_digest_t dest;
  calc_hmac_sha256(reinterpret_cast<const char*>(key.v), sha256_digest_t::SIZE,
                   msg.data(), msg.size(),
                   reinterpret_cast<char*>(dest.v));
  return dest;
}

static inline sha256_digest_t
calc_hmac_sha256(const std::vector<unsigned char>& key,
                 const boost::string_view& msg) {
  sha256_digest_t dest;
  calc_hmac_sha256(reinterpret_cast<const char*>(key.data()), key.size(),
                   msg.data(), msg.size(),
                   reinterpret_cast<char*>(dest.v));
  return dest;
}

template<size_t KeyLenN>
static inline sha256_digest_t
calc_hmac_sha256(const std::array<unsigned char, KeyLenN>& key,
                 const boost::string_view& msg) {
  sha256_digest_t dest;
  calc_hmac_sha256(reinterpret_cast<const char*>(key.data()), key.size(),
                   msg.data(), msg.size(),
                   reinterpret_cast<char*>(dest.v));
  return dest;
}

extern sha256_digest_t calc_hash_sha256(const boost::string_view& msg);

extern ceph::crypto::SHA256* calc_hash_sha256_open_stream();
extern void calc_hash_sha256_update_stream(ceph::crypto::SHA256* hash,
                                           const char* msg,
                                           int len);
extern std::string calc_hash_sha256_close_stream(ceph::crypto::SHA256** phash);
extern std::string calc_hash_sha256_restart_stream(ceph::crypto::SHA256** phash);

extern int rgw_parse_op_type_list(const string& str, uint32_t *perm);

static constexpr uint32_t MATCH_POLICY_ACTION = 0x01;
static constexpr uint32_t MATCH_POLICY_RESOURCE = 0x02;
static constexpr uint32_t MATCH_POLICY_ARN = 0x04;
static constexpr uint32_t MATCH_POLICY_STRING = 0x08;

extern bool match_policy(boost::string_view pattern, boost::string_view input,
                         uint32_t flag);

extern string camelcase_dash_http_attr(const string& orig);
extern string lowercase_dash_http_attr(const string& orig);

void rgw_setup_saved_curl_handles();
void rgw_release_all_curl_handles();

static inline void rgw_escape_str(const string& s, char esc_char,
      char special_char, string *dest)
{
  const char *src = s.c_str();
  char dest_buf[s.size() * 2 + 1];
  char *destp = dest_buf;

  for (size_t i = 0; i < s.size(); i++) {
    char c = src[i];
    if (c == esc_char || c == special_char) {
      *destp++ = esc_char;
    }
    *destp++ = c;
  }
  *destp++ = '\0';
  *dest = dest_buf;
}

static inline ssize_t rgw_unescape_str(const string& s, ssize_t ofs,
           char esc_char, char special_char,
           string *dest)
{
  const char *src = s.c_str();
  char dest_buf[s.size() + 1];
  char *destp = dest_buf;
  bool esc = false;

  dest_buf[0] = '\0';

  for (size_t i = ofs; i < s.size(); i++) {
    char c = src[i];
    if (!esc && c == esc_char) {
      esc = true;
      continue;
    }
    if (!esc && c == special_char) {
      *destp = '\0';
      *dest = dest_buf;
      return (ssize_t)i + 1;
    }
    *destp++ = c;
    esc = false;
  }
  *destp = '\0';
  *dest = dest_buf;
  return string::npos;
}

static inline string rgw_bl_str(ceph::buffer::list& raw)
{
  size_t len = raw.length();
  string s(raw.c_str(), len);
  while (len && !s[len - 1]) {
    --len;
    s.resize(len);
  }
  return s;
}

template <typename T>
int decode_bl(bufferlist& bl, T& t)
{
  auto iter = bl.cbegin();
  try {
    decode(t, iter);
  } catch (buffer::error& err) {
    return -
# 2708 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 3 4
           5
# 2708 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h"
              ;
  }
  return 0;
}
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_dmclock.h" 1
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_dmclock.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
       
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
# 1 "/usr/include/assert.h" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 2

# 1 "/usr/include/c++/10/cmath" 1 3
# 39 "/usr/include/c++/10/cmath" 3
       
# 40 "/usr/include/c++/10/cmath" 3
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 2
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h"
       
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h"
# 1 "/usr/include/assert.h" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h" 2


namespace crimson {
  using IndIntruHeapData = size_t;
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h"
  template<typename I,
    typename T,
    IndIntruHeapData T::*heap_info,
    typename C,
    uint K = 2>
  class IndIntruHeap {


    using HeapIndex = IndIntruHeapData;

    static_assert(
      std::is_same<T,typename std::pointer_traits<I>::element_type>::value,
      "class I must resolve to class T by indirection (pointer dereference)");

    static_assert(
      std::is_same<bool,
      typename std::result_of<C(const T&,const T&)>::type>::value,
      "class C must define operator() to take two const T& and return a bool");

    static_assert(K >= 2, "K (degree of branching) must be at least 2");

    class Iterator {
      friend IndIntruHeap<I, T, heap_info, C, K>;

      IndIntruHeap<I, T, heap_info, C, K>* heap;
      HeapIndex index;

      Iterator(IndIntruHeap<I, T, heap_info, C, K>& _heap, HeapIndex _index) :
 heap(&_heap),
 index(_index)
      {

      }

    public:

      Iterator(Iterator&& other) :
 heap(other.heap),
 index(other.index)
      {

      }

      Iterator(const Iterator& other) :
 heap(other.heap),
 index(other.index)
      {

      }

      Iterator& operator=(Iterator&& other) {
 std::swap(heap, other.heap);
 std::swap(index, other.index);
 return *this;
      }

      Iterator& operator=(const Iterator& other) {
 heap = other.heap;
 index = other.index;
      }

      Iterator& operator++() {
 if (index <= heap->count) {
   ++index;
 }
 return *this;
      }

      bool operator==(const Iterator& other) const {
 return heap == other.heap && index == other.index;
      }

      bool operator!=(const Iterator& other) const {
 return !(*this == other);
      }

      T& operator*() {
 return *heap->data[index];
      }

      T* operator->() {
 return &(*heap->data[index]);
      }







    };


    class ConstIterator {
      friend IndIntruHeap<I, T, heap_info, C, K>;

      const IndIntruHeap<I, T, heap_info, C, K>* heap;
      HeapIndex index;

      ConstIterator(const IndIntruHeap<I, T, heap_info, C, K>& _heap,
      HeapIndex _index) :
 heap(&_heap),
 index(_index)
      {

      }

    public:

      ConstIterator(ConstIterator&& other) :
 heap(other.heap),
 index(other.index)
      {

      }

      ConstIterator(const ConstIterator& other) :
 heap(other.heap),
 index(other.index)
      {

      }

      ConstIterator& operator=(ConstIterator&& other) {
 std::swap(heap, other.heap);
 std::swap(index, other.index);
 return *this;
      }

      ConstIterator& operator=(const ConstIterator& other) {
 heap = other.heap;
 index = other.index;
      }

      ConstIterator& operator++() {
 if (index <= heap->count) {
   ++index;
 }
 return *this;
      }

      bool operator==(const ConstIterator& other) const {
 return heap == other.heap && index == other.index;
      }

      bool operator!=(const ConstIterator& other) const {
 return !(*this == other);
      }

      const T& operator*() {
 return *heap->data[index];
      }

      const T* operator->() {
 return &(*heap->data[index]);
      }
    };


  protected:

    std::vector<I> data;
    HeapIndex count;
    C comparator;

  public:

    IndIntruHeap() :
      count(0)
    {

    }

    IndIntruHeap(const IndIntruHeap<I,T,heap_info,C,K>& other) :
      count(other.count)
    {
      for (HeapIndex i = 0; i < other.count; ++i) {
 data.push_back(other.data[i]);
      }
    }

    bool empty() const { return 0 == count; }

    size_t size() const { return (size_t) count; }

    T& top() { return *data[0]; }

    const T& top() const { return *data[0]; }

    I& top_ind() { return data[0]; }

    const I& top_ind() const { return data[0]; }

    void push(I&& item) {
      HeapIndex i = count++;
      intru_data_of(item) = i;
      data.emplace_back(std::move(item));
      sift_up(i);
    }

    void push(const I& item) {
      I copy(item);
      push(std::move(copy));
    }

    void pop() {
      remove(HeapIndex(0));
    }

    void remove(Iterator& i) {
      remove(i.index);
      i = end();
    }

    Iterator find(const I& ind_item) {
      for (HeapIndex i = 0; i < count; ++i) {
 if (data[i] == ind_item) {
   return Iterator(*this, i);
 }
      }
      return end();
    }


    Iterator find(const T& item) {
      for (HeapIndex i = 0; i < count; ++i) {
 if (*data[i] == item) {
   return Iterator(*this, i);
 }
      }
      return end();
    }


    Iterator rfind(const I& ind_item) {


      for (HeapIndex i = count; i > 0; --i) {
 if (data[i-1] == ind_item) {
   return Iterator(*this, i-1);
 }
      }
      return end();
    }


    Iterator rfind(const T& item) {


      for (HeapIndex i = count; i > 0; --i) {
 if (*data[i-1] == item) {
   return Iterator(*this, i-1);
 }
      }
      return end();
    }

    ConstIterator find(const I& ind_item) const {
      for (HeapIndex i = 0; i < count; ++i) {
 if (data[i] == ind_item) {
   return ConstIterator(*this, i);
 }
      }
      return cend();
    }


    ConstIterator find(const T& item) const {
      for (HeapIndex i = 0; i < count; ++i) {
 if (*data[i] == item) {
   return ConstIterator(*this, i);
 }
      }
      return cend();
    }


    ConstIterator rfind(const I& ind_item) const {


      for (HeapIndex i = count; i > 0; --i) {
 if (data[i-1] == ind_item) {
   return ConstIterator(*this, i-1);
 }
      }
      return cend();
    }


    ConstIterator rfind(const T& item) const {


      for (HeapIndex i = count; i > 0; --i) {
 if (*data[i-1] == item) {
   return ConstIterator(*this, i-1);
 }
      }
      return cend();
    }

    Iterator at(const I& ind_item) {
      auto ind = intru_data_of(ind_item);
      if (ind >= count) {
        throw std::out_of_range(
          std::to_string(ind) + " >= " + std::to_string(count));
      }
      
# 353 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h" 3 4
     (static_cast<void> (0))
# 353 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h"
                                  ;
      return Iterator(*this, ind);
    }

    void promote(T& item) {
      sift_up(item.*heap_info);
    }

    void demote(T& item) {
      sift_down(item.*heap_info);
    }

    void adjust(T& item) {
      sift(item.*heap_info);
    }

    Iterator begin() {
      return Iterator(*this, 0);
    }

    Iterator end() {
      return Iterator(*this, count);
    }

    ConstIterator cbegin() const {
      return ConstIterator(*this, 0);
    }

    ConstIterator cend() const {
      return ConstIterator(*this, count);
    }

    friend std::ostream& operator<<(std::ostream& out, const IndIntruHeap& h) {
      auto i = h.data.cbegin();
      if (i != h.data.cend()) {
 out << **i;
 ++i;
 while (i != h.data.cend()) {
   out << ", " << **i;
 }
      }
      return out;
    }



    std::ostream&
    display_sorted(std::ostream& out,
     std::function<bool(const T&)> filter = all_filter) const {
      static_assert(std::is_copy_constructible<I>::value,
      "cannot call display_sorted when class I is not copy"
      " constructible");
      auto compare = [this] (const I first, const I second) -> bool {
 return this->comparator(*first, *second);
      };
      std::vector<I> copy(data);
      std::sort(copy.begin(), copy.end(), compare);

      bool first = true;
      for (auto c = copy.begin(); c != copy.end(); ++c) {
 if (filter(**c)) {
   if (!first) {
     out << ", ";
   } else {
     first = false;
   }
   out << **c;
 }
      }

      return out;
    }


  protected:

    static IndIntruHeapData& intru_data_of(const I& item) {
      return (*item).*heap_info;
    }

    void remove(HeapIndex i) {
      std::swap(data[i], data[--count]);
      intru_data_of(data[i]) = i;
      data.pop_back();






      sift(i);
    }


    static bool all_filter(const T& data) { return true; }


    static inline HeapIndex parent(HeapIndex i) {
      
# 451 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h" 3 4
     (static_cast<void> (0))
# 451 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/indirect_intrusive_heap.h"
                   ;
      return (i - 1) / K;
    }


    static inline HeapIndex lhs(HeapIndex i) { return K*i + 1; }


    static inline HeapIndex rhs(HeapIndex i) { return K*i + K; }

    void sift_up(HeapIndex i) {
      while (i > 0) {
 HeapIndex pi = parent(i);
 if (!comparator(*data[i], *data[pi])) {
   break;
 }

 std::swap(data[i], data[pi]);
 intru_data_of(data[i]) = i;
 intru_data_of(data[pi]) = pi;
 i = pi;
      }
    }




    template<bool EnableBool=true>
    typename std::enable_if<(K>2)&&EnableBool,void>::type sift_down(HeapIndex i) {
      if (i >= count) return;
      while (true) {
 HeapIndex li = lhs(i);

 if (li < count) {
   HeapIndex ri = std::min(rhs(i), count - 1);


   HeapIndex min_i = li;
   for (HeapIndex k = li + 1; k <= ri; ++k) {
     if (comparator(*data[k], *data[min_i])) {
       min_i = k;
     }
   }

   if (comparator(*data[min_i], *data[i])) {
     std::swap(data[i], data[min_i]);
     intru_data_of(data[i]) = i;
     intru_data_of(data[min_i]) = min_i;
     i = min_i;
   } else {

     break;
   }
 } else {

   break;
 }
      }
    }



    template<bool EnableBool=true>
    typename std::enable_if<K==2&&EnableBool,void>::type sift_down(HeapIndex i) {
      if (i >= count) return;
      while (true) {
 const HeapIndex li = lhs(i);
 const HeapIndex ri = 1 + li;

        if (li < count) {
   if (comparator(*data[li], *data[i])) {
     if (ri < count && comparator(*data[ri], *data[li])) {
       std::swap(data[i], data[ri]);
       intru_data_of(data[i]) = i;
       intru_data_of(data[ri]) = ri;
       i = ri;
     } else {
       std::swap(data[i], data[li]);
       intru_data_of(data[i]) = i;
       intru_data_of(data[li]) = li;
       i = li;
            }
   } else if (ri < count && comparator(*data[ri], *data[i])) {
     std::swap(data[i], data[ri]);
            intru_data_of(data[i]) = i;
     intru_data_of(data[ri]) = ri;
     i = ri;
          } else {

            break;
          }
        } else {

          break;
        }
      }
    }

    void sift(HeapIndex i) {
      if (i == 0) {

 sift_down(i);
      } else {
 HeapIndex pi = parent(i);
 if (comparator(*data[i], *data[pi])) {

   sift_up(i);
 } else {

   sift_down(i);
 }
      }
    }
  };

}
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/run_every.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/run_every.h"
       
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/support/src/run_every.h"
namespace crimson {
  using std::chrono::duration_cast;
  using std::chrono::milliseconds;




  class RunEvery {
    using Lock = std::unique_lock<std::mutex>;
    using Guard = std::lock_guard<std::mutex>;
    using TimePoint = std::chrono::steady_clock::time_point;

    bool finishing = false;
    std::chrono::milliseconds wait_period;
    std::function<void()> body;
    std::mutex mtx;
    std::condition_variable cv;



    std::thread thd;

  public:





    template<typename D>
    RunEvery(D _wait_period,
      const std::function<void()>& _body) :
      wait_period(duration_cast<milliseconds>(_wait_period)),
      body(_body)
    {
      thd = std::thread(&RunEvery::run, this);
    }

    RunEvery(const RunEvery& other) = delete;
    RunEvery& operator=(const RunEvery& other) = delete;
    RunEvery(RunEvery&& other) = delete;



    RunEvery& operator=(RunEvery&& other) = delete;


    ~RunEvery();

    void join();

    void try_update(milliseconds _wait_period);

  protected:

    void run();
  };
}
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h"
       



# 1 "/usr/include/assert.h" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h" 2



# 1 "/usr/include/c++/10/cmath" 1 3
# 39 "/usr/include/c++/10/cmath" 3
       
# 40 "/usr/include/c++/10/cmath" 3
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h" 2



namespace crimson {
  namespace dmclock {



    using Time = double;
    static const Time TimeZero = 0.0;
    static const Time TimeMax = std::numeric_limits<Time>::max();
    static const double NaN = nan("");


    inline Time get_time() {

      struct timespec now;
      auto result = clock_gettime(
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h" 3 4
                                 0
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h"
                                               , &now);
      (void) result;
      
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h" 3 4
     (static_cast<void> (0))
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_util.h"
                        ;
      return now.tv_sec + (now.tv_nsec / 1.0e9);







    }

    std::string format_time(const Time& time, uint modulo = 1000);

    void debugger();

  }
}
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_recs.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_recs.h"
       



# 1 "/usr/include/assert.h" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_recs.h" 2


namespace crimson {
  namespace dmclock {
    using Counter = uint64_t;





    using Cost = uint32_t;

    enum class PhaseType : uint8_t { reservation, priority };

    inline std::ostream& operator<<(std::ostream& out, const PhaseType& phase) {
      out << (PhaseType::reservation == phase ? "reservation" : "priority");
      return out;
    }

    struct ReqParams {

      uint32_t delta;


      uint32_t rho;

      ReqParams(uint32_t _delta, uint32_t _rho) :
 delta(_delta),
 rho(_rho)
      {
 
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_recs.h" 3 4
(static_cast<void> (0))
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_recs.h"
                    ;
      }

      ReqParams() :
 ReqParams(0, 0)
      {

      }

      ReqParams(const ReqParams& other) :
 delta(other.delta),
 rho(other.rho)
      {

      }

      friend std::ostream& operator<<(std::ostream& out, const ReqParams& rp) {
 out << "ReqParams{ delta:" << rp.delta <<
   ", rho:" << rp.rho << " }";
 return out;
      }
    };
  }
}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 2






namespace crimson {

  namespace dmclock {

    namespace c = crimson;

    constexpr double max_tag = std::numeric_limits<double>::is_iec559 ?
      std::numeric_limits<double>::infinity() :
      std::numeric_limits<double>::max();
    constexpr double min_tag = std::numeric_limits<double>::is_iec559 ?
      -std::numeric_limits<double>::infinity() :
      std::numeric_limits<double>::lowest();
    constexpr uint tag_modulo = 1000000;

    constexpr auto standard_idle_age = std::chrono::seconds(300);
    constexpr auto standard_erase_age = std::chrono::seconds(600);
    constexpr auto standard_check_time = std::chrono::seconds(60);
    constexpr auto aggressive_check_time = std::chrono::seconds(5);
    constexpr uint standard_erase_max = 2000;

    enum class AtLimit {

      Wait,


      Allow,



      Reject,
    };




    using RejectThreshold = Time;



    using AtLimitParam = boost::variant<AtLimit, RejectThreshold>;

    struct ClientInfo {
      double reservation;
      double weight;
      double limit;



      double reservation_inv;
      double weight_inv;
      double limit_inv;


      ClientInfo(double _reservation, double _weight, double _limit) :
 reservation(_reservation),
 weight(_weight),
 limit(_limit),
 reservation_inv(0.0 == reservation ? 0.0 : 1.0 / reservation),
 weight_inv( 0.0 == weight ? 0.0 : 1.0 / weight),
 limit_inv( 0.0 == limit ? 0.0 : 1.0 / limit)
      {

      }


      friend std::ostream& operator<<(std::ostream& out,
          const ClientInfo& client) {
 out <<
   "{ ClientInfo:: r:" << client.reservation <<
   " w:" << std::fixed << client.weight <<
   " l:" << std::fixed << client.limit <<
   " 1/r:" << std::fixed << client.reservation_inv <<
   " 1/w:" << std::fixed << client.weight_inv <<
   " 1/l:" << std::fixed << client.limit_inv <<
   " }";
 return out;
      }
    };


    struct RequestTag {
      double reservation;
      double proportion;
      double limit;
      uint32_t delta;
      uint32_t rho;
      Cost cost;
      bool ready;
      Time arrival;

      RequestTag(const RequestTag& prev_tag,
   const ClientInfo& client,
   const uint32_t _delta,
   const uint32_t _rho,
   const Time time,
   const Cost _cost = 1u,
   const double anticipation_timeout = 0.0) :
 delta(_delta),
 rho(_rho),
 cost(_cost),
 ready(false),
 arrival(time)
      {
 
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                ;
 Time max_time = time;
 if (time - anticipation_timeout < prev_tag.arrival)
   max_time -= anticipation_timeout;

 reservation = tag_calc(max_time,
          prev_tag.reservation,
          client.reservation_inv,
          rho,
          true,
          cost);
 proportion = tag_calc(max_time,
         prev_tag.proportion,
         client.weight_inv,
         delta,
         true,
         cost);
 limit = tag_calc(max_time,
    prev_tag.limit,
    client.limit_inv,
    delta,
    false,
    cost);

 
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                                                     ;
      }

      RequestTag(const RequestTag& prev_tag,
   const ClientInfo& client,
   const ReqParams req_params,
   const Time time,
   const Cost cost = 1u,
   const double anticipation_timeout = 0.0) :
 RequestTag(prev_tag, client, req_params.delta, req_params.rho, time,
     cost, anticipation_timeout)
      { }

      RequestTag(const double _res, const double _prop, const double _lim,
   const Time _arrival,
   const uint32_t _delta = 0,
   const uint32_t _rho = 0,
   const Cost _cost = 1u) :
 reservation(_res),
 proportion(_prop),
 limit(_lim),
 delta(_delta),
 rho(_rho),
 cost(_cost),
 ready(false),
 arrival(_arrival)
      {
 
# 208 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 208 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                ;
 
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                                                     ;
      }

      RequestTag(const RequestTag& other) :
 reservation(other.reservation),
 proportion(other.proportion),
 limit(other.limit),
 delta(other.delta),
 rho(other.rho),
 cost(other.cost),
 ready(other.ready),
 arrival(other.arrival)
      { }

      static std::string format_tag_change(double before, double after) {
 if (before == after) {
   return std::string("same");
 } else {
   std::stringstream ss;
   ss << format_tag(before) << "=>" << format_tag(after);
   return ss.str();
 }
      }

      static std::string format_tag(double value) {
 if (max_tag == value) {
   return std::string("max");
 } else if (min_tag == value) {
   return std::string("min");
 } else {
   return format_time(value, tag_modulo);
 }
      }

    private:

      static double tag_calc(const Time time,
        const double prev,
        const double increment,
        const uint32_t dist_req_val,
        const bool extreme_is_high,
        const Cost cost) {
 if (0.0 == increment) {
   return extreme_is_high ? max_tag : min_tag;
 } else {

   double tag_increment = increment * (uint64_t(dist_req_val) + cost);
   return std::max(time, prev + tag_increment);
 }
      }

      friend std::ostream& operator<<(std::ostream& out,
          const RequestTag& tag) {
 out <<
   "{ RequestTag:: ready:" << (tag.ready ? "true" : "false") <<
   " r:" << format_tag(tag.reservation) <<
   " p:" << format_tag(tag.proportion) <<
   " l:" << format_tag(tag.limit) <<



   " }";
 return out;
      }
    };
# 282 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
    template<typename C, typename R, bool IsDelayed, bool U1, uint B>
    class PriorityQueueBase {

      friend class dmclock_server_client_idle_erase_Test;


      using TagCalc = std::integral_constant<bool, IsDelayed>;
      using DelayedTagCalc = std::true_type;
      using ImmediateTagCalc = std::false_type;

    public:

      using RequestRef = std::unique_ptr<R>;

    protected:

      using TimePoint = decltype(std::chrono::steady_clock::now());
      using Duration = std::chrono::milliseconds;
      using MarkPoint = std::pair<TimePoint,Counter>;

      enum class ReadyOption {ignore, lowers, raises};


      template<double RequestTag::*, ReadyOption, bool>
      struct ClientCompare;

      class ClientReq {
 friend PriorityQueueBase;

 RequestTag tag;
 C client_id;
 RequestRef request;

      public:

 ClientReq(const RequestTag& _tag,
    const C& _client_id,
    RequestRef&& _request) :
   tag(_tag),
   client_id(_client_id),
   request(std::move(_request))
 {

 }

 friend std::ostream& operator<<(std::ostream& out, const ClientReq& c) {
   out << "{ ClientReq:: tag:" << c.tag << " client:" <<
     c.client_id << " }";
   return out;
 }
      };

      struct RequestMeta {
        C client_id;
        RequestTag tag;

        RequestMeta(const C& _client_id, const RequestTag& _tag) :
          client_id(_client_id),
          tag(_tag)
        {

        }
      };

    public:





      class ClientRec {
 friend PriorityQueueBase<C,R,IsDelayed,U1,B>;

 C client;
 RequestTag prev_tag;
 std::deque<ClientReq> requests;



 double prop_delta = 0.0;

 c::IndIntruHeapData reserv_heap_data {};
 c::IndIntruHeapData lim_heap_data {};
 c::IndIntruHeapData ready_heap_data {};




      public:

 const ClientInfo* info;
 bool idle;
 Counter last_tick;
 uint32_t cur_rho;
 uint32_t cur_delta;

 ClientRec(C _client,
    const ClientInfo* _info,
    Counter current_tick) :
   client(_client),
   prev_tag(0.0, 0.0, 0.0, TimeZero),
   info(_info),
   idle(true),
   last_tick(current_tick),
   cur_rho(1),
   cur_delta(1)
 {

 }

 inline const RequestTag& get_req_tag() const {
   return prev_tag;
 }

 static inline void assign_unpinned_tag(double& lhs, const double rhs) {
   if (rhs != max_tag && rhs != min_tag) {
     lhs = rhs;
   }
 }

 inline void update_req_tag(const RequestTag& _prev,
       const Counter& _tick) {
   assign_unpinned_tag(prev_tag.reservation, _prev.reservation);
   assign_unpinned_tag(prev_tag.limit, _prev.limit);
   assign_unpinned_tag(prev_tag.proportion, _prev.proportion);
   prev_tag.arrival = _prev.arrival;
   last_tick = _tick;
 }

 inline void add_request(const RequestTag& tag, RequestRef&& request) {
   requests.emplace_back(tag, client, std::move(request));
 }

 inline const ClientReq& next_request() const {
   return requests.front();
 }

 inline ClientReq& next_request() {
   return requests.front();
 }

 inline void pop_request() {
   requests.pop_front();
 }

 inline bool has_request() const {
   return !requests.empty();
 }

 inline size_t request_count() const {
   return requests.size();
 }



 bool remove_by_req_filter_fw(std::function<bool(RequestRef&&)> filter_accum) {
   bool any_removed = false;
   for (auto i = requests.begin();
        i != requests.end();
                    ) {
     if (filter_accum(std::move(i->request))) {
       any_removed = true;
       i = requests.erase(i);
     } else {
       ++i;
     }
   }
   return any_removed;
 }



 bool remove_by_req_filter_bw(std::function<bool(RequestRef&&)> filter_accum) {
   bool any_removed = false;
   for (auto i = requests.rbegin();
        i != requests.rend();
                    ) {
     if (filter_accum(std::move(i->request))) {
       any_removed = true;
       i = decltype(i){ requests.erase(std::next(i).base()) };
     } else {
       ++i;
     }
   }
   return any_removed;
 }

 inline bool
 remove_by_req_filter(std::function<bool(RequestRef&&)> filter_accum,
        bool visit_backwards) {
   if (visit_backwards) {
     return remove_by_req_filter_bw(filter_accum);
   } else {
     return remove_by_req_filter_fw(filter_accum);
   }
 }

 friend std::ostream&
 operator<<(std::ostream& out,
     const typename PriorityQueueBase::ClientRec& e) {
   out << "{ ClientRec::" <<
     " client:" << e.client <<
     " prev_tag:" << e.prev_tag <<
     " req_count:" << e.requests.size() <<
     " top_req:";
   if (e.has_request()) {
     out << e.next_request();
   } else {
     out << "none";
   }
   out << " }";

   return out;
 }
      };

      using ClientRecRef = std::shared_ptr<ClientRec>;




      enum class NextReqType { returning, future, none };


      enum class HeapId { reservation, ready };


      struct NextReq {
 NextReqType type;
 union {
   HeapId heap_id;
   Time when_ready;
 };

 inline explicit NextReq() :
   type(NextReqType::none)
 { }

 inline NextReq(HeapId _heap_id) :
   type(NextReqType::returning),
   heap_id(_heap_id)
 { }

 inline NextReq(Time _when_ready) :
   type(NextReqType::future),
   when_ready(_when_ready)
 { }



 static inline NextReq none() {
   return NextReq();
 }
      };



      using ClientInfoFunc = std::function<const ClientInfo*(const C&)>;


      bool empty() const {
 DataGuard g(data_mtx);
 return (resv_heap.empty() || ! resv_heap.top().has_request());
      }


      size_t client_count() const {
 DataGuard g(data_mtx);
 return resv_heap.size();
      }


      size_t request_count() const {
 DataGuard g(data_mtx);
 size_t total = 0;
 for (auto i = resv_heap.cbegin(); i != resv_heap.cend(); ++i) {
   total += i->request_count();
 }
 return total;
      }


      bool remove_by_req_filter(std::function<bool(RequestRef&&)> filter_accum,
    bool visit_backwards = false) {
 bool any_removed = false;
 DataGuard g(data_mtx);
 for (auto i : client_map) {
   bool modified =
     i.second->remove_by_req_filter(filter_accum, visit_backwards);
   if (modified) {
     resv_heap.adjust(*i.second);
     limit_heap.adjust(*i.second);
     ready_heap.adjust(*i.second);



     any_removed = true;
   }
 }
 return any_removed;
      }



      static void request_sink(RequestRef&& req) {

      }


      void remove_by_client(const C& client,
       bool reverse = false,
       std::function<void (RequestRef&&)> accum = request_sink) {
 DataGuard g(data_mtx);

 auto i = client_map.find(client);

 if (i == client_map.end()) return;

 if (reverse) {
   for (auto j = i->second->requests.rbegin();
        j != i->second->requests.rend();
        ++j) {
     accum(std::move(j->request));
   }
 } else {
   for (auto j = i->second->requests.begin();
        j != i->second->requests.end();
        ++j) {
     accum(std::move(j->request));
   }
 }

 i->second->requests.clear();

 resv_heap.adjust(*i->second);
 limit_heap.adjust(*i->second);
 ready_heap.adjust(*i->second);



      }


      uint get_heap_branching_factor() const {
 return B;
      }


      void update_client_info(const C& client_id) {
 DataGuard g(data_mtx);
 auto client_it = client_map.find(client_id);
 if (client_map.end() != client_it) {
   ClientRec& client = (*client_it->second);
   client.info = client_info_f(client_id);
 }
      }


      void update_client_infos() {
 DataGuard g(data_mtx);
 for (auto i : client_map) {
   i.second->info = client_info_f(i.second->client);
 }
      }


      friend std::ostream& operator<<(std::ostream& out,
          const PriorityQueueBase& q) {
 std::lock_guard<decltype(q.data_mtx)> guard(q.data_mtx);

 out << "{ PriorityQueue::";
 for (const auto& c : q.client_map) {
   out << "  { client:" << c.first << ", record:" << *c.second <<
     " }";
 }
 if (!q.resv_heap.empty()) {
   const auto& resv = q.resv_heap.top();
   out << " { reservation_top:" << resv << " }";
   const auto& ready = q.ready_heap.top();
   out << " { ready_top:" << ready << " }";
   const auto& limit = q.limit_heap.top();
   out << " { limit_top:" << limit << " }";
 } else {
   out << " HEAPS-EMPTY";
 }
 out << " }";

 return out;
      }


      void display_queues(std::ostream& out,
     bool show_res = true,
     bool show_lim = true,
     bool show_ready = true,
     bool show_prop = true) const {
 auto filter = [](const ClientRec& e)->bool { return true; };
 DataGuard g(data_mtx);
 if (show_res) {
   resv_heap.display_sorted(out << "RESER:", filter);
 }
 if (show_lim) {
   limit_heap.display_sorted(out << "LIMIT:", filter);
 }
 if (show_ready) {
   ready_heap.display_sorted(out << "READY:", filter);
 }





      }


    protected:
# 719 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
      template<double RequestTag::*tag_field,
        ReadyOption ready_opt,
        bool use_prop_delta>
      struct ClientCompare {
 bool operator()(const ClientRec& n1, const ClientRec& n2) const {
   if (n1.has_request()) {
     if (n2.has_request()) {
       const auto& t1 = n1.next_request().tag;
       const auto& t2 = n2.next_request().tag;
       if (ReadyOption::ignore == ready_opt || t1.ready == t2.ready) {

  if (use_prop_delta) {
    return (t1.*tag_field + n1.prop_delta) <
      (t2.*tag_field + n2.prop_delta);
  } else {
    return t1.*tag_field < t2.*tag_field;
  }
       } else if (ReadyOption::raises == ready_opt) {

  return t1.ready;
       } else {
  return t2.ready;
       }
     } else {

       return true;
     }
   } else if (n2.has_request()) {

     return false;
   } else {

     return false;
   }
 }
      };

      ClientInfoFunc client_info_f;
      static constexpr bool is_dynamic_cli_info_f = U1;

      mutable std::mutex data_mtx;
      using DataGuard = std::lock_guard<decltype(data_mtx)>;


      std::map<C,ClientRecRef> client_map;

      c::IndIntruHeap<ClientRecRef,
        ClientRec,
        &ClientRec::reserv_heap_data,
        ClientCompare<&RequestTag::reservation,
        ReadyOption::ignore,
        false>,
        B> resv_heap;
# 781 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
      c::IndIntruHeap<ClientRecRef,
        ClientRec,
        &ClientRec::lim_heap_data,
        ClientCompare<&RequestTag::limit,
        ReadyOption::lowers,
        false>,
        B> limit_heap;
      c::IndIntruHeap<ClientRecRef,
        ClientRec,
        &ClientRec::ready_heap_data,
        ClientCompare<&RequestTag::proportion,
        ReadyOption::raises,
        true>,
        B> ready_heap;

      AtLimit at_limit;
      RejectThreshold reject_threshold = 0;

      double anticipation_timeout;

      std::atomic_bool finishing;


      Counter tick = 0;


      size_t reserv_sched_count = 0;
      size_t prop_sched_count = 0;
      size_t limit_break_sched_count = 0;

      Duration idle_age;
      Duration erase_age;
      Duration check_time;
      std::deque<MarkPoint> clean_mark_points;

      Counter erase_max;

      Counter last_erase_point = 0;



      std::unique_ptr<RunEvery> cleaning_job;



      template <typename T, typename Variant>
      static T get_or_default(const Variant& param, T default_value) {
 const T *p = boost::get<T>(&param);
 return p ? *p : default_value;
      }



      template<typename Rep, typename Per>
      PriorityQueueBase(ClientInfoFunc _client_info_f,
   std::chrono::duration<Rep,Per> _idle_age,
   std::chrono::duration<Rep,Per> _erase_age,
   std::chrono::duration<Rep,Per> _check_time,
   AtLimitParam at_limit_param,
   double _anticipation_timeout) :
 client_info_f(_client_info_f),
 at_limit(get_or_default(at_limit_param, AtLimit::Reject)),
 reject_threshold(get_or_default(at_limit_param, RejectThreshold{0})),
 anticipation_timeout(_anticipation_timeout),
 finishing(false),
 idle_age(std::chrono::duration_cast<Duration>(_idle_age)),
 erase_age(std::chrono::duration_cast<Duration>(_erase_age)),
 check_time(std::chrono::duration_cast<Duration>(_check_time)),
 erase_max(standard_erase_max)
      {
 
# 851 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 851 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                               ;
 
# 852 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 852 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                               ;

 
# 854 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 854 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                                                 ;
 cleaning_job =
   std::unique_ptr<RunEvery>(
     new RunEvery(check_time,
    std::bind(&PriorityQueueBase::do_clean, this)));
      }


      ~PriorityQueueBase() {
 finishing = true;
      }


      inline const ClientInfo* get_cli_info(ClientRec& client) const {
 if (is_dynamic_cli_info_f) {
   client.info = client_info_f(client.client);
 }
 return client.info;
      }


      RequestTag initial_tag(DelayedTagCalc delayed, ClientRec& client,
        const ReqParams& params, Time time, Cost cost) {
 RequestTag tag(0, 0, 0, time, 0, 0, cost);


 if (!client.has_request()) {
   const ClientInfo* client_info = get_cli_info(client);
   
# 882 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
  (static_cast<void> (0))
# 882 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                     ;
   tag = RequestTag(client.get_req_tag(), *client_info,
      params, time, cost, anticipation_timeout);


   client.update_req_tag(tag, tick);
 }
 return tag;
      }


      RequestTag initial_tag(ImmediateTagCalc imm, ClientRec& client,
        const ReqParams& params, Time time, Cost cost) {

 const ClientInfo* client_info = get_cli_info(client);
 
# 897 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 897 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                   ;
 RequestTag tag(client.get_req_tag(), *client_info,
         params, time, cost, anticipation_timeout);


 client.update_req_tag(tag, tick);
 return tag;
      }





      int do_add_request(RequestRef&& request,
    const C& client_id,
    const ReqParams& req_params,
    const Time time,
    const Cost cost = 1u) {
 ++tick;

        auto insert = client_map.emplace(client_id, ClientRecRef{});
        if (insert.second) {

   const ClientInfo* info = client_info_f(client_id);
   auto client_rec = std::make_shared<ClientRec>(client_id, info, tick);
   resv_heap.push(client_rec);



   limit_heap.push(client_rec);
   ready_heap.push(client_rec);
   insert.first->second = std::move(client_rec);
 }


 ClientRec& client = *insert.first->second;

 if (client.idle) {
# 954 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
   constexpr double lowest_prop_tag_trigger =
     std::numeric_limits<double>::max() / 3.0;

   double lowest_prop_tag = std::numeric_limits<double>::max();
   for (auto const &c : client_map) {


     if (!c.second->idle) {
       double p;

       if (c.second->has_request()) {
  p = c.second->next_request().tag.proportion +
    c.second->prop_delta;
       } else {
         p = c.second->get_req_tag().proportion + c.second->prop_delta;
       }

       if (p < lowest_prop_tag) {
  lowest_prop_tag = p;
       }
     }
   }


   if (lowest_prop_tag < lowest_prop_tag_trigger) {
     client.prop_delta = lowest_prop_tag - time;
   }
   client.idle = false;
 }

 RequestTag tag = initial_tag(TagCalc{}, client, req_params, time, cost);

 if (at_limit == AtLimit::Reject &&
            tag.limit > time + reject_threshold) {

   return 
# 989 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
         11
# 989 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
               ;
 }

 client.add_request(tag, std::move(request));
 if (1 == client.requests.size()) {



   resv_heap.adjust(client);
   limit_heap.adjust(client);
   ready_heap.adjust(client);



 }

 client.cur_rho = req_params.rho;
 client.cur_delta = req_params.delta;

 resv_heap.adjust(client);
 limit_heap.adjust(client);
 ready_heap.adjust(client);



 return 0;
      }


      void update_next_tag(DelayedTagCalc delayed, ClientRec& top,
      const RequestTag& tag) {
 if (top.has_request()) {

   ClientReq& next_first = top.next_request();
   const ClientInfo* client_info = get_cli_info(top);
   
# 1024 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
  (static_cast<void> (0))
# 1024 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                     ;
   next_first.tag = RequestTag(tag, *client_info,
          top.cur_delta, top.cur_rho,
          next_first.tag.arrival,
          next_first.tag.cost,
          anticipation_timeout);

   top.update_req_tag(next_first.tag, tick);
 }
      }

      void update_next_tag(ImmediateTagCalc imm, ClientRec& top,
      const RequestTag& tag) {

      }



      template<typename C1, IndIntruHeapData ClientRec::*C2, typename C3>
      RequestTag pop_process_request(IndIntruHeap<C1, ClientRec, C2, C3, B>& heap,
          std::function<void(const C& client,
        const Cost cost,
        RequestRef& request)> process) {

 ClientRec& top = heap.top();

 Cost request_cost = top.next_request().tag.cost;
 RequestRef request = std::move(top.next_request().request);
 RequestTag tag = top.next_request().tag;


 top.pop_request();

 update_next_tag(TagCalc{}, top, tag);

 resv_heap.demote(top);
 limit_heap.adjust(top);



 ready_heap.demote(top);


 process(top.client, request_cost, request);

 return tag;
      }



      void reduce_reservation_tags(DelayedTagCalc delayed, ClientRec& client,
                                   const RequestTag& tag) {
 if (!client.requests.empty()) {

   auto& r = client.requests.front();
   r.tag.reservation -=
     client.info->reservation_inv * std::max(uint32_t(1), tag.rho);
 }
      }


      void reduce_reservation_tags(ImmediateTagCalc imm, ClientRec& client,
                                   const RequestTag& tag) {
        double res_offset =
          client.info->reservation_inv * std::max(uint32_t(1), tag.rho);
 for (auto& r : client.requests) {
   r.tag.reservation -= res_offset;
 }
      }


      void reduce_reservation_tags(const C& client_id, const RequestTag& tag) {
 auto client_it = client_map.find(client_id);



 
# 1100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
(static_cast<void> (0))
# 1100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                                     ;
 ClientRec& client = *client_it->second;
 reduce_reservation_tags(TagCalc{}, client, tag);


 client.prev_tag.reservation -=
   client.info->reservation_inv * std::max(uint32_t(1), tag.rho);
 resv_heap.promote(client);
      }



      NextReq do_next_request(Time now) {


 if(resv_heap.empty()) {
   return NextReq::none();
 }



 auto& reserv = resv_heap.top();
 if (reserv.has_request() &&
     reserv.next_request().tag.reservation <= now) {
   return NextReq(HeapId::reservation);
 }






 auto limits = &limit_heap.top();
 while (limits->has_request() &&
        !limits->next_request().tag.ready &&
        limits->next_request().tag.limit <= now) {
   limits->next_request().tag.ready = true;
   ready_heap.promote(*limits);
   limit_heap.demote(*limits);

   limits = &limit_heap.top();
 }

 auto& readys = ready_heap.top();
 if (readys.has_request() &&
     readys.next_request().tag.ready &&
     readys.next_request().tag.proportion < max_tag) {
   return NextReq(HeapId::ready);
 }





 if (at_limit == AtLimit::Allow) {
   if (readys.has_request() &&
       readys.next_request().tag.proportion < max_tag) {
     return NextReq(HeapId::ready);
   } else if (reserv.has_request() &&
       reserv.next_request().tag.reservation < max_tag) {
     return NextReq(HeapId::reservation);
   }
 }




 Time next_call = TimeMax;
 if (resv_heap.top().has_request()) {
   next_call =
     min_not_0_time(next_call,
      resv_heap.top().next_request().tag.reservation);
 }
 if (limit_heap.top().has_request()) {
   const auto& next = limit_heap.top().next_request();
   
# 1175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
  (static_cast<void> (0))
# 1175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
                                                           ;
   next_call = min_not_0_time(next_call, next.tag.limit);
 }
 if (next_call < TimeMax) {
   return NextReq(next_call);
 } else {
   return NextReq::none();
 }
      }





      static inline const Time& min_not_0_time(const Time& current,
            const Time& possible) {
 return TimeZero == possible ? current : std::min(current, possible);
      }
# 1203 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
      void do_clean() {
 TimePoint now = std::chrono::steady_clock::now();
 DataGuard g(data_mtx);
 clean_mark_points.emplace_back(MarkPoint(now, tick));



 Counter erase_point = last_erase_point;
 auto point = clean_mark_points.front();
 while (point.first <= now - erase_age) {
   last_erase_point = point.second;
   erase_point = last_erase_point;
   clean_mark_points.pop_front();
   point = clean_mark_points.front();
 }

 Counter idle_point = 0;
 for (auto i : clean_mark_points) {
   if (i.first <= now - idle_age) {
     idle_point = i.second;
   } else {
     break;
   }
 }

 Counter erased_num = 0;
 if (erase_point > 0 || idle_point > 0) {
   for (auto i = client_map.begin(); i != client_map.end(); ) {
     auto i2 = i++;
     if (erase_point &&
         erased_num < erase_max &&
         i2->second->last_tick <= erase_point) {
       delete_from_heaps(i2->second);
       client_map.erase(i2);
       erased_num++;
     } else if (idle_point && i2->second->last_tick <= idle_point) {
       i2->second->idle = true;
     }
   }

   auto wperiod = check_time;
   if (erased_num >= erase_max) {
     wperiod = duration_cast<milliseconds>(aggressive_check_time);
   } else {

     last_erase_point = 0;
   }
   cleaning_job->try_update(wperiod);
 }
      }



      template<IndIntruHeapData ClientRec::*C1,typename C2>
      void delete_from_heap(ClientRecRef& client,
       c::IndIntruHeap<ClientRecRef,ClientRec,C1,C2,B>& heap) {
 auto i = heap.at(client);
 heap.remove(i);
      }



      void delete_from_heaps(ClientRecRef& client) {
 delete_from_heap(client, resv_heap);



 delete_from_heap(client, limit_heap);
 delete_from_heap(client, ready_heap);
      }
    };


    template<typename C, typename R, bool IsDelayed=false, bool U1=false, uint B=2>
    class PullPriorityQueue : public PriorityQueueBase<C,R,IsDelayed,U1,B> {
      using super = PriorityQueueBase<C,R,IsDelayed,U1,B>;

    public:


      struct PullReq {
 struct Retn {
   C client;
   typename super::RequestRef request;
   PhaseType phase;
   Cost cost;
 };

 typename super::NextReqType type;
 boost::variant<Retn,Time> data;

 bool is_none() const { return type == super::NextReqType::none; }

 bool is_retn() const { return type == super::NextReqType::returning; }
 Retn& get_retn() {
   return boost::get<Retn>(data);
 }

 bool is_future() const { return type == super::NextReqType::future; }
 Time getTime() const { return boost::get<Time>(data); }
      };







      template<typename Rep, typename Per>
      PullPriorityQueue(typename super::ClientInfoFunc _client_info_f,
   std::chrono::duration<Rep,Per> _idle_age,
   std::chrono::duration<Rep,Per> _erase_age,
   std::chrono::duration<Rep,Per> _check_time,
   AtLimitParam at_limit_param = AtLimit::Wait,
   double _anticipation_timeout = 0.0) :
 super(_client_info_f,
       _idle_age, _erase_age, _check_time,
       at_limit_param, _anticipation_timeout)
      {

      }



      PullPriorityQueue(typename super::ClientInfoFunc _client_info_f,
   AtLimitParam at_limit_param = AtLimit::Wait,
   double _anticipation_timeout = 0.0) :
 PullPriorityQueue(_client_info_f,
     standard_idle_age,
     standard_erase_age,
     standard_check_time,
     at_limit_param,
     _anticipation_timeout)
      {

      }


      int add_request(R&& request,
        const C& client_id,
        const ReqParams& req_params,
        const Cost cost = 1u) {
 return add_request(typename super::RequestRef(new R(std::move(request))),
      client_id,
      req_params,
      get_time(),
      cost);
      }


      int add_request(R&& request,
        const C& client_id,
        const Cost cost = 1u) {
 static const ReqParams null_req_params;
 return add_request(typename super::RequestRef(new R(std::move(request))),
      client_id,
      null_req_params,
      get_time(),
      cost);
      }


      int add_request_time(R&& request,
      const C& client_id,
      const ReqParams& req_params,
      const Time time,
      const Cost cost = 1u) {
 return add_request(typename super::RequestRef(new R(std::move(request))),
      client_id,
      req_params,
      time,
      cost);
      }


      int add_request(typename super::RequestRef&& request,
        const C& client_id,
        const ReqParams& req_params,
        const Cost cost = 1u) {
 return add_request(request, req_params, client_id, get_time(), cost);
      }


      int add_request(typename super::RequestRef&& request,
        const C& client_id,
        const Cost cost = 1u) {
 static const ReqParams null_req_params;
 return add_request(request, null_req_params, client_id, get_time(), cost);
      }



      int add_request(typename super::RequestRef&& request,
        const C& client_id,
        const ReqParams& req_params,
        const Time time,
        const Cost cost = 1u) {
 typename super::DataGuard g(this->data_mtx);



 int r = super::do_add_request(std::move(request),
          client_id,
          req_params,
          time,
          cost);




 return r;
      }


      inline PullReq pull_request() {
 return pull_request(get_time());
      }


      PullReq pull_request(const Time now) {
 PullReq result;
 typename super::DataGuard g(this->data_mtx);




 typename super::NextReq next = super::do_next_request(now);
 result.type = next.type;
 switch(next.type) {
 case super::NextReqType::none:
   return result;
 case super::NextReqType::future:
   result.data = next.when_ready;
   return result;
 case super::NextReqType::returning:

   break;
 default:
   
# 1441 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
  (static_cast<void> (0))
# 1441 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
               ;
 }



 auto process_f =
   [&] (PullReq& pull_result, PhaseType phase) ->
   std::function<void(const C&,
        uint64_t,
        typename super::RequestRef&)> {
   return [&pull_result, phase](const C& client,
           const Cost request_cost,
           typename super::RequestRef& request) {
     pull_result.data = typename PullReq::Retn{ client,
             std::move(request),
             phase,
             request_cost };
   };
 };

 switch(next.heap_id) {
 case super::HeapId::reservation:
   (void) super::pop_process_request(this->resv_heap,
         process_f(result,
            PhaseType::reservation));
   ++this->reserv_sched_count;
   break;
 case super::HeapId::ready:
   {
     auto tag = super::pop_process_request(this->ready_heap,
         process_f(result, PhaseType::priority));

     auto& retn = boost::get<typename PullReq::Retn>(result.data);
     super::reduce_reservation_tags(retn.client, tag);
   }
   ++this->prop_sched_count;
   break;
 default:
   
# 1479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
  (static_cast<void> (0))
# 1479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
               ;
 }




 return result;
      }


    protected:





      typename super::NextReq next_request() {
 return next_request(get_time());
      }
    };



    template<typename C, typename R, bool IsDelayed=false, bool U1=false, uint B=2>
    class PushPriorityQueue : public PriorityQueueBase<C,R,IsDelayed,U1,B> {

    protected:

      using super = PriorityQueueBase<C,R,IsDelayed,U1,B>;

    public:


      using CanHandleRequestFunc = std::function<bool(void)>;



      using HandleRequestFunc =
 std::function<void(const C&,typename super::RequestRef,PhaseType,uint64_t)>;

    protected:

      CanHandleRequestFunc can_handle_f;
      HandleRequestFunc handle_f;

      std::mutex sched_ahead_mtx;
      std::condition_variable sched_ahead_cv;
      Time sched_ahead_when = TimeZero;
# 1537 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
      std::thread sched_ahead_thd;

    public:


      template<typename Rep, typename Per>
      PushPriorityQueue(typename super::ClientInfoFunc _client_info_f,
   CanHandleRequestFunc _can_handle_f,
   HandleRequestFunc _handle_f,
   std::chrono::duration<Rep,Per> _idle_age,
   std::chrono::duration<Rep,Per> _erase_age,
   std::chrono::duration<Rep,Per> _check_time,
   AtLimitParam at_limit_param = AtLimit::Wait,
   double anticipation_timeout = 0.0) :
 super(_client_info_f,
       _idle_age, _erase_age, _check_time,
       at_limit_param, anticipation_timeout)
      {
 can_handle_f = _can_handle_f;
 handle_f = _handle_f;
 sched_ahead_thd = std::thread(&PushPriorityQueue::run_sched_ahead, this);
      }



      PushPriorityQueue(typename super::ClientInfoFunc _client_info_f,
   CanHandleRequestFunc _can_handle_f,
   HandleRequestFunc _handle_f,
   AtLimitParam at_limit_param = AtLimit::Wait,
   double _anticipation_timeout = 0.0) :
 PushPriorityQueue(_client_info_f,
     _can_handle_f,
     _handle_f,
     standard_idle_age,
     standard_erase_age,
     standard_check_time,
     at_limit_param,
     _anticipation_timeout)
      {

      }


      ~PushPriorityQueue() {
 this->finishing = true;
 sched_ahead_cv.notify_one();
 sched_ahead_thd.join();
      }

    public:

      int add_request(R&& request,
        const C& client_id,
        const ReqParams& req_params,
        const Cost cost = 1u) {
 return add_request(typename super::RequestRef(new R(std::move(request))),
      client_id,
      req_params,
      get_time(),
      cost);
      }


      int add_request(typename super::RequestRef&& request,
        const C& client_id,
        const ReqParams& req_params,
        const Cost cost = 1u) {
 return add_request(request, req_params, client_id, get_time(), cost);
      }


      int add_request_time(const R& request,
      const C& client_id,
      const ReqParams& req_params,
      const Time time,
      const Cost cost = 1u) {
 return add_request(typename super::RequestRef(new R(request)),
      client_id,
      req_params,
      time,
      cost);
      }


      int add_request(typename super::RequestRef&& request,
        const C& client_id,
        const ReqParams& req_params,
        const Time time,
        const Cost cost = 1u) {
 typename super::DataGuard g(this->data_mtx);



 int r = super::do_add_request(std::move(request),
          client_id,
          req_params,
          time,
          cost);
        if (r == 0) {
   schedule_request();
        }



 return r;
      }


      void request_completed() {
 typename super::DataGuard g(this->data_mtx);



 schedule_request();



      }

    protected:
# 1668 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
      template<typename C1,
        IndIntruHeapData super::ClientRec::*C2,
        typename C3,
        uint B4>
      typename super::RequestMeta
      submit_top_request(IndIntruHeap<C1,typename super::ClientRec,C2,C3,B4>& heap,
    PhaseType phase) {
 C client_result;
 RequestTag tag = super::pop_process_request(heap,
       [this, phase, &client_result]
       (const C& client,
        const Cost request_cost,
        typename super::RequestRef& request) {
         client_result = client;
         handle_f(client, std::move(request), phase, request_cost);
       });
 typename super::RequestMeta req(client_result, tag);
 return req;
      }



      void submit_request(typename super::HeapId heap_id) {
 switch(heap_id) {
 case super::HeapId::reservation:

   (void) submit_top_request(this->resv_heap, PhaseType::reservation);


   ++this->reserv_sched_count;
   break;
 case super::HeapId::ready:
   {
     auto req = submit_top_request(this->ready_heap, PhaseType::priority);
     super::reduce_reservation_tags(req.client_id, req.tag);
   }
   ++this->prop_sched_count;
   break;
 default:
   
# 1707 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
  (static_cast<void> (0))
# 1707 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
               ;
 }
      }





      typename super::NextReq next_request() {
 return next_request(get_time());
      }





      typename super::NextReq next_request(Time now) {
 if (!can_handle_f()) {
   typename super::NextReq result;
   result.type = super::NextReqType::none;
   return result;
 } else {
   return super::do_next_request(now);
 }
      }



      void schedule_request() {
 typename super::NextReq next_req = next_request();
 switch (next_req.type) {
 case super::NextReqType::none:
   return;
 case super::NextReqType::future:
   sched_at(next_req.when_ready);
   break;
 case super::NextReqType::returning:
   submit_request(next_req.heap_id);
   break;
 default:
   
# 1747 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h" 3 4
  (static_cast<void> (0))
# 1747 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/dmclock/src/dmclock_server.h"
               ;
 }
      }




      void run_sched_ahead() {
 std::unique_lock<std::mutex> l(sched_ahead_mtx);

 while (!this->finishing) {
   if (TimeZero == sched_ahead_when) {
     sched_ahead_cv.wait(l);
   } else {
     Time now;
     while (!this->finishing && (now = get_time()) < sched_ahead_when) {
       long microseconds_l = long(1 + 1000000 * (sched_ahead_when - now));
       auto microseconds = std::chrono::microseconds(microseconds_l);
       sched_ahead_cv.wait_for(l, microseconds);
     }
     sched_ahead_when = TimeZero;
     if (this->finishing) return;

     l.unlock();
     if (!this->finishing) {
       typename super::DataGuard g(this->data_mtx);
       schedule_request();
     }
     l.lock();
   }
 }
      }


      void sched_at(Time when) {
 std::lock_guard<std::mutex> l(sched_ahead_mtx);
 if (this->finishing) return;
 if (TimeZero == sched_ahead_when || when < sched_ahead_when) {
   sched_ahead_when = when;
   sched_ahead_cv.notify_one();
 }
      }
    };

  }
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_dmclock.h" 2

namespace rgw::dmclock {

enum class client_id {
                      admin,
                      auth,
                      data,
                      metadata,
                      count
};


using crimson::dmclock::Cost;
using crimson::dmclock::ClientInfo;

enum class scheduler_t {
                        none,
                        throttler,
                        dmclock
};

inline scheduler_t get_scheduler_t(CephContext* const cct)
{
  const auto scheduler_type = cct->_conf.get_val<std::string>("rgw_scheduler_type");
  if (scheduler_type == "dmclock")
    return scheduler_t::dmclock;
  else if (scheduler_type == "throttler")
    return scheduler_t::throttler;
  else
    return scheduler_t::none;
}

}
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/admin_socket.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/admin_socket.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/buffer.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/admin_socket.h" 2


class AdminSocket;
class CephContext;

using namespace std::literals;

inline constexpr auto CEPH_ADMIN_SOCK_VERSION = "2"sv;

class AdminSocketHook {
public:
  virtual bool call(std::string_view command, const cmdmap_t& cmdmap,
      std::string_view format, bufferlist& out) = 0;
  virtual ~AdminSocketHook() {}
};

class AdminSocket
{
public:
  AdminSocket(CephContext *cct);
  ~AdminSocket();

  AdminSocket(const AdminSocket&) = delete;
  AdminSocket& operator =(const AdminSocket&) = delete;
  AdminSocket(AdminSocket&&) = delete;
  AdminSocket& operator =(AdminSocket&&) = delete;
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/admin_socket.h"
  int register_command(std::string_view command,
         std::string_view cmddesc,
         AdminSocketHook *hook,
         std::string_view help);
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/admin_socket.h"
  int unregister_command(std::string_view command);




  void unregister_commands(const AdminSocketHook *hook);

  bool init(const std::string& path);

  void chown(uid_t uid, gid_t gid);
  void chmod(mode_t mode);
  int execute_command(const std::string& cmd, ceph::bufferlist& out);

private:

  void shutdown();

  std::string create_shutdown_pipe(int *pipe_rd, int *pipe_wr);
  std::string destroy_shutdown_pipe();
  std::string bind_and_listen(const std::string &sock_path, int *fd);

  std::thread th;
  void entry() noexcept;
  bool do_accept();
  bool validate(const std::string& command,
  const cmdmap_t& cmdmap,
  bufferlist& out) const;

  CephContext *m_cct;
  std::string m_path;
  int m_sock_fd = -1;
  int m_shutdown_rd_fd = -1;
  int m_shutdown_wr_fd = -1;

  bool in_hook = false;
  std::condition_variable in_hook_cond;
  std::mutex lock;
  std::unique_ptr<AdminSocketHook> version_hook;
  std::unique_ptr<AdminSocketHook> help_hook;
  std::unique_ptr<AdminSocketHook> getdescs_hook;

  struct hook_info {
    AdminSocketHook* hook;
    std::string desc;
    std::string help;

    hook_info(AdminSocketHook* hook, std::string_view desc,
       std::string_view help)
      : hook(hook), desc(desc), help(help) {}
  };

  std::map<std::string, hook_info, std::less<>> hooks;

  friend class AdminSocketTest;
  friend class HelpHook;
  friend class GetdescsHook;
};
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RefCountedObj.h" 1
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RefCountedObj.h"
struct RefCountedObject {
private:
  mutable std::atomic<uint64_t> nref;
  CephContext *cct;
public:
  RefCountedObject(CephContext *c = 
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RefCountedObj.h" 3 4
                                   __null
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RefCountedObj.h"
                                       , int n=1) : nref(n), cct(c) {}
  virtual ~RefCountedObject() {
    do { static const ceph::assert_data assert_data_ctx = {"nref == 0", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RefCountedObj.h", 35, __PRETTY_FUNCTION__}; ((nref == 0) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);
  }

  const RefCountedObject *get() const {
    int v = ++nref;
    if (cct)
      do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_refs)>::value || ceph::dout::is_dynamic<decltype(1)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_refs, 1); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_refs, 1>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(1, ceph_subsys_refs); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "RefCountedObject::get " << this << " "
        << (v - 1) << " -> " << v
        << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return this;
  }
  RefCountedObject *get() {
    int v = ++nref;
    if (cct)
      do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_refs)>::value || ceph::dout::is_dynamic<decltype(1)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_refs, 1); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_refs, 1>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(1, ceph_subsys_refs); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "RefCountedObject::get " << this << " "
        << (v - 1) << " -> " << v
        << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return this;
  }
  void put() const {
    CephContext *local_cct = cct;
    int v = --nref;
    if (local_cct)
      do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_refs)>::value || ceph::dout::is_dynamic<decltype(1)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_refs, 1); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_refs, 1>()); } }(local_cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(1, ceph_subsys_refs); static_assert(std::is_convertible<decltype(&*local_cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = local_cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "RefCountedObject::put " << this << " "
       << (v + 1) << " -> " << v
       << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (v == 0) {
      (void)0;
      (void)0;
      delete this;
    } else {
      (void)0;
    }
  }
  void set_cct(CephContext *c) {
    cct = c;
  }

  uint64_t get_nref() const {
    return nref;
  }
};
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RefCountedObj.h"
struct RefCountedCond : public RefCountedObject {
  bool complete;
  ceph::mutex lock = ceph::make_mutex("RefCountedCond::lock");
  ceph::condition_variable cond;
  int rval;

  RefCountedCond() : complete(false), rval(0) {}

  int wait() {
    std::unique_lock l(lock);
    while (!complete) {
      cond.wait(l);
    }
    return rval;
  }

  void done(int r) {
    std::lock_guard l(lock);
    rval = r;
    complete = true;
    cond.notify_all();
  }

  void done() {
    done(0);
  }
};
# 125 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/RefCountedObj.h"
struct RefCountedWaitObject {
  std::atomic<uint64_t> nref = { 1 };
  RefCountedCond *c;

  RefCountedWaitObject() {
    c = new RefCountedCond;
  }
  virtual ~RefCountedWaitObject() {
    c->put();
  }

  RefCountedWaitObject *get() {
    nref++;
    return this;
  }

  bool put() {
    bool ret = false;
    RefCountedCond *cond = c;
    cond->get();
    if (--nref == 0) {
      cond->done();
      delete this;
      ret = true;
    }
    cond->put();
    return ret;
  }

  void put_wait() {
    RefCountedCond *cond = c;

    cond->get();
    if (--nref == 0) {
      cond->done();
      delete this;
    } else {
      cond->wait();
    }
    cond->put();
  }
};



static inline void intrusive_ptr_add_ref(const RefCountedObject *p) {
  p->get();
}
static inline void intrusive_ptr_release(const RefCountedObject *p) {
  p->put();
}

using RefCountedPtr = boost::intrusive_ptr<RefCountedObject>;
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/log/cls_log_types.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/log/cls_log_types.h"
class JSONObj;


struct cls_log_entry {
  string id;
  string section;
  string name;
  utime_t timestamp;
  bufferlist data;

  cls_log_entry() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(section, bl);
    encode(name, bl);
    encode(timestamp, bl);
    encode(data, bl);
    encode(id, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(section, bl);
    decode(name, bl);
    decode(timestamp, bl);
    decode(data, bl);
    if (struct_v >= 2)
      decode(id, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const cls_log_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_log_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_log_header {
  string max_marker;
  utime_t max_time;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(max_marker, bl);
    encode(max_time, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(max_marker, bl);
    decode(max_time, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const cls_log_header &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_log_header &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/timeindex/cls_timeindex_types.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/timeindex/cls_timeindex_types.h"
class JSONObj;

struct cls_timeindex_entry {

  utime_t key_ts;


  string key_ext;

  bufferlist value;

  cls_timeindex_entry() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key_ts, bl);
    encode(key_ext, bl);
    encode(value, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(key_ts, bl);
    decode(key_ext, bl);
    decode(value, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const cls_timeindex_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_timeindex_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/otp/cls_otp_types.h" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/otp/cls_otp_types.h"
class JSONObj;

namespace rados {
  namespace cls {
    namespace otp {

      enum OTPType {
        OTP_UNKNOWN = 0,
        OTP_HOTP = 1,
        OTP_TOTP = 2,
      };

      enum SeedType {
        OTP_SEED_UNKNOWN = 0,
        OTP_SEED_HEX = 1,
        OTP_SEED_BASE32 = 2,
      };

      struct otp_info_t {
        OTPType type{OTP_TOTP};
        string id;
        string seed;
        SeedType seed_type{OTP_SEED_UNKNOWN};
        bufferlist seed_bin;


        int32_t time_ofs{0};
        uint32_t step_size{30};
        uint32_t window{2};

        otp_info_t() {}

        void encode(bufferlist &bl) const {
          __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
          encode((uint8_t)type, bl);


          encode(id, bl);
          encode(seed, bl);
          encode((uint8_t)seed_type, bl);
          encode(seed_bin, bl);
          encode(time_ofs, bl);
          encode(step_size, bl);
          encode(window, bl);
          } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
        }
        void decode(bufferlist::const_iterator &bl) {
          __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
          uint8_t t;
          decode(t, bl);
          type = (OTPType)t;
          decode(id, bl);
          decode(seed, bl);
          uint8_t st;
          decode(st, bl);
          seed_type = (SeedType)st;
          decode(seed_bin, bl);
          decode(time_ofs, bl);
          decode(step_size, bl);
          decode(window, bl);
          } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
        }
        void dump(Formatter *f) const;
        void decode_json(JSONObj *obj);
      };
      inline void encode(const rados::cls::otp::otp_info_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rados::cls::otp::otp_info_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

      enum OTPCheckResult {
        OTP_CHECK_UNKNOWN = 0,
        OTP_CHECK_SUCCESS = 1,
        OTP_CHECK_FAIL = 2,
      };

      struct otp_check_t {
        string token;
        ceph::real_time timestamp;
        OTPCheckResult result{OTP_CHECK_UNKNOWN};

        void encode(bufferlist &bl) const {
          __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
          encode(token, bl);
          encode(timestamp, bl);
          encode((char)result, bl);
          } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
        }
        void decode(bufferlist::const_iterator &bl) {
          __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
          decode(token, bl);
          decode(timestamp, bl);
          uint8_t t;
          decode(t, bl);
          result = (OTPCheckResult)t;
          } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
        }
      };
      inline void encode(const rados::cls::otp::otp_check_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rados::cls::otp::otp_check_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

      struct otp_repo_t {
        map<string, otp_info_t> entries;

        otp_repo_t() {}

        void encode(bufferlist &bl) const {
          __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
          encode(entries, bl);
          } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
        }
        void decode(bufferlist::const_iterator &bl) {
          __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
          decode(entries, bl);
          } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
        }
      };
      inline void encode(const rados::cls::otp::otp_repo_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rados::cls::otp::otp_repo_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
    }
  }
}

inline void encode(const rados::cls::otp::otp_info_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rados::cls::otp::otp_info_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
inline void encode(const rados::cls::otp::otp_check_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rados::cls::otp::otp_check_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
inline void encode(const rados::cls::otp::otp_repo_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rados::cls::otp::otp_repo_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_log.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_log.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/OutputDataSocket.h" 1
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/OutputDataSocket.h"
class CephContext;

class OutputDataSocket : public Thread
{
public:
  OutputDataSocket(CephContext *cct, uint64_t _backlog);
  ~OutputDataSocket() override;

  bool init(const std::string &path);

  void append_output(bufferlist& bl);

protected:
  virtual void init_connection(bufferlist& bl) {}
  void shutdown();

  std::string create_shutdown_pipe(int *pipe_rd, int *pipe_wr);
  std::string bind_and_listen(const std::string &sock_path, int *fd);

  void *entry() override;
  bool do_accept();

  void handle_connection(int fd);
  void close_connection(int fd);

  int dump_data(int fd);

  CephContext *m_cct;
  uint64_t data_max_backlog;
  std::string m_path;
  int m_sock_fd;
  int m_shutdown_rd_fd;
  int m_shutdown_wr_fd;
  bool going_down;

  uint64_t data_size;
  uint32_t skipped;

  std::vector<buffer::list> data;

  ceph::mutex m_lock = ceph::make_mutex("OutputDataSocket::m_lock");
  ceph::condition_variable cond;
  buffer::list delim;
};
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_log.h" 2

class RGWRados;

struct rgw_log_entry {

  using headers_map = boost::container::flat_map<std::string, std::string>;
  using Clock = req_state::Clock;

  rgw_user object_owner;
  rgw_user bucket_owner;
  string bucket;
  Clock::time_point time;
  string remote_addr;
  string user;
  rgw_obj_key obj;
  string op;
  string uri;
  string http_status;
  string error_code;
  uint64_t bytes_sent;
  uint64_t bytes_received;
  uint64_t obj_size;
  Clock::duration total_time;
  string user_agent;
  string referrer;
  string bucket_id;
  headers_map x_headers;

  void encode(bufferlist &bl) const {
    __u8 struct_v = 9; __u8 struct_compat = 5; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(object_owner.id, bl);
    encode(bucket_owner.id, bl);
    encode(bucket, bl);
    encode(time, bl);
    encode(remote_addr, bl);
    encode(user, bl);
    encode(obj.name, bl);
    encode(op, bl);
    encode(uri, bl);
    encode(http_status, bl);
    encode(error_code, bl);
    encode(bytes_sent, bl);
    encode(obj_size, bl);
    encode(total_time, bl);
    encode(user_agent, bl);
    encode(referrer, bl);
    encode(bytes_received, bl);
    encode(bucket_id, bl);
    encode(obj, bl);
    encode(object_owner, bl);
    encode(bucket_owner, bl);
    encode(x_headers, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &p) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, p); if (struct_v >= 5) { __u8 struct_compat; decode(struct_compat, p); if (8 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "8" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 5) { __u32 struct_len; decode(struct_len, p); if (struct_len > p.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = p.get_off() + struct_len; } do {;
    decode(object_owner.id, p);
    if (struct_v > 3)
      decode(bucket_owner.id, p);
    decode(bucket, p);
    decode(time, p);
    decode(remote_addr, p);
    decode(user, p);
    decode(obj.name, p);
    decode(op, p);
    decode(uri, p);
    decode(http_status, p);
    decode(error_code, p);
    decode(bytes_sent, p);
    decode(obj_size, p);
    decode(total_time, p);
    decode(user_agent, p);
    decode(referrer, p);
    if (struct_v >= 2)
      decode(bytes_received, p);
    else
      bytes_received = 0;

    if (struct_v >= 3) {
      if (struct_v <= 5) {
        uint64_t id;
        decode(id, p);
        char buf[32];
        snprintf(buf, sizeof(buf), "%" 
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_log.h" 3 4
                                      "l" "u"
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_log.h"
                                            , id);
        bucket_id = buf;
      } else {
        decode(bucket_id, p);
      }
    } else {
      bucket_id = "";
    }
    if (struct_v >= 7) {
      decode(obj, p);
    }
    if (struct_v >= 8) {
      decode(object_owner, p);
      decode(bucket_owner, p);
    }
    if (struct_v >= 9) {
      decode(x_headers, p);
    }
    } while (false); if (struct_end) { if (p.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (p.get_off() < struct_end) p.advance(struct_end - p.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_log_entry*>& o);
};
inline void encode(const rgw_log_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_log_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class OpsLogSocket : public OutputDataSocket {
  Formatter *formatter;
  Mutex lock;

  void formatter_to_bl(bufferlist& bl);

protected:
  void init_connection(bufferlist& bl) override;

public:
  OpsLogSocket(CephContext *cct, uint64_t _backlog);
  ~OpsLogSocket() override;

  void log(struct rgw_log_entry& entry);
};

class RGWREST;

int rgw_log_op(RGWRados *store, RGWREST* const rest, struct req_state *s,
        const string& op_name, OpsLogSocket *olog);
void rgw_log_usage_init(CephContext *cct, RGWRados *store);
void rgw_log_usage_finalize();
void rgw_format_ops_log_entry(struct rgw_log_entry& entry,
         Formatter *formatter);
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_metadata.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_metadata.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_period_history.h" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_period_history.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 1 3 4
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/avltree_node.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/avltree_node.hpp" 3 4
         


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/avltree_node.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 1 3 4
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
         




# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
namespace boost {
namespace intrusive {



template<class NodeTraits, class F>
struct avltree_node_cloner

   : public detail::ebo_functor_holder<F>
{
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef detail::ebo_functor_holder<F> base_t;

   avltree_node_cloner(F f)
      : base_t(f)
   {}

   node_ptr operator()(const node_ptr & p)
   {
      node_ptr n = base_t::get()(p);
      NodeTraits::set_balance(n, NodeTraits::get_balance(p));
      return n;
   }

   node_ptr operator()(const node_ptr & p) const
   {
      node_ptr n = base_t::get()(p);
      NodeTraits::set_balance(n, NodeTraits::get_balance(p));
      return n;
   }
};

namespace detail {

template<class ValueTraits, class NodePtrCompare, class ExtraChecker>
struct avltree_node_checker
      : public bstree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker>
{
   typedef bstree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker> base_checker_t;
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::const_node_ptr const_node_ptr;

   struct return_type
         : public base_checker_t::return_type
   {
      return_type() : height(0) {}
      int height;
   };

   avltree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker)
      : base_checker_t(comp, extra_checker)
   {}

   void operator () (const const_node_ptr& p,
                     const return_type& check_return_left, const return_type& check_return_right,
                     return_type& check_return)
   {
      const int height_diff = check_return_right.height - check_return_left.height; (void)height_diff;
      (static_cast<void> (0))



       ;
      check_return.height = 1 +
         (check_return_left.height > check_return_right.height ? check_return_left.height : check_return_right.height);
      base_checker_t::operator()(p, check_return_left, check_return_right, check_return);
   }
};

}
# 143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
template<class NodeTraits>
class avltree_algorithms

   : public bstree_algorithms<NodeTraits>

{
   public:
   typedef typename NodeTraits::node node;
   typedef NodeTraits node_traits;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef typename NodeTraits::balance balance;


   private:
   typedef bstree_algorithms<NodeTraits> bstree_algo;



   public:


   typedef typename bstree_algo::insert_commit_data insert_commit_data;
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
   static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
   {
      if(node1 == node2)
         return;

      node_ptr header1(bstree_algo::get_header(node1)), header2(bstree_algo::get_header(node2));
      swap_nodes(node1, header1, node2, header2);
   }


   static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
   {
      if(node1 == node2) return;

      bstree_algo::swap_nodes(node1, header1, node2, header2);

      balance c = NodeTraits::get_balance(node1);
      NodeTraits::set_balance(node1, NodeTraits::get_balance(node2));
      NodeTraits::set_balance(node2, c);
   }


   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
   {
      if(node_to_be_replaced == new_node)
         return;
      replace_node(node_to_be_replaced, bstree_algo::get_header(node_to_be_replaced), new_node);
   }


   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
   {
      bstree_algo::replace_node(node_to_be_replaced, header, new_node);
      NodeTraits::set_balance(new_node, NodeTraits::get_balance(node_to_be_replaced));
   }


   static void unlink(const node_ptr & node)
   {
      node_ptr x = NodeTraits::get_parent(node);
      if(x){
         while(!is_header(x))
            x = NodeTraits::get_parent(x);
         erase(x, node);
      }
   }
# 261 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
   static void init_header(const node_ptr & header)
   {
      bstree_algo::init_header(header);
      NodeTraits::set_balance(header, NodeTraits::zero());
   }


   static node_ptr erase(const node_ptr & header, const node_ptr & z)
   {
      typename bstree_algo::data_for_rebalance info;
      bstree_algo::erase(header, z, info);
      rebalance_after_erasure(header, z, info);
      return z;
   }


   template<class NodePtrCompare>
   static bool transfer_unique
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
   {
      typename bstree_algo::data_for_rebalance info;
      bool const transferred = bstree_algo::transfer_unique(header1, comp, header2, z, info);
      if(transferred){
         rebalance_after_erasure(header2, z, info);
         rebalance_after_insertion(header1, z);
      }
      return transferred;
   }


   template<class NodePtrCompare>
   static void transfer_equal
      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
   {
      typename bstree_algo::data_for_rebalance info;
      bstree_algo::transfer_equal(header1, comp, header2, z, info);
      rebalance_after_erasure(header2, z, info);
      rebalance_after_insertion(header1, z);
   }


   template <class Cloner, class Disposer>
   static void clone
      (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
   {
      avltree_node_cloner<NodeTraits, Cloner> new_cloner(cloner);
      bstree_algo::clone(source_header, target_header, new_cloner, disposer);
   }
# 348 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
   template<class NodePtrCompare>
   static node_ptr insert_equal_upper_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
   {
      bstree_algo::insert_equal_upper_bound(h, new_node, comp);
      rebalance_after_insertion(h, new_node);
      return new_node;
   }


   template<class NodePtrCompare>
   static node_ptr insert_equal_lower_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
   {
      bstree_algo::insert_equal_lower_bound(h, new_node, comp);
      rebalance_after_insertion(h, new_node);
      return new_node;
   }


   template<class NodePtrCompare>
   static node_ptr insert_equal
      (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp)
   {
      bstree_algo::insert_equal(header, hint, new_node, comp);
      rebalance_after_insertion(header, new_node);
      return new_node;
   }


   static node_ptr insert_before
      (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node)
   {
      bstree_algo::insert_before(header, pos, new_node);
      rebalance_after_insertion(header, new_node);
      return new_node;
   }


   static void push_back(const node_ptr & header, const node_ptr & new_node)
   {
      bstree_algo::push_back(header, new_node);
      rebalance_after_insertion(header, new_node);
   }


   static void push_front(const node_ptr & header, const node_ptr & new_node)
   {
      bstree_algo::push_front(header, new_node);
      rebalance_after_insertion(header, new_node);
   }
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
   static void insert_unique_commit
      (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
   {
      bstree_algo::insert_unique_commit(header, new_value, commit_data);
      rebalance_after_insertion(header, new_value);
   }


   static bool is_header(const const_node_ptr & p)
   { return NodeTraits::get_balance(p) == NodeTraits::zero() && bstree_algo::is_header(p); }



   static bool verify(const node_ptr &header)
   {
      std::size_t height;
      std::size_t count;
      return verify_recursion(NodeTraits::get_parent(header), count, height);
   }

   private:

   static bool verify_recursion(node_ptr n, std::size_t &count, std::size_t &height)
   {
      if (!n){
         count = 0;
         height = 0;
         return true;
      }
      std::size_t leftcount, rightcount;
      std::size_t leftheight, rightheight;
      if(!verify_recursion(NodeTraits::get_left (n), leftcount, leftheight) ||
         !verify_recursion(NodeTraits::get_right(n), rightcount, rightheight) ){
         return false;
      }
      count = 1u + leftcount + rightcount;
      height = 1u + (leftheight > rightheight ? leftheight : rightheight);


      if(rightheight == leftheight){
         if(NodeTraits::get_balance(n) != NodeTraits::zero()){
            (static_cast<void> (0));
            return false;
         }
      }

      else if(rightheight > leftheight){
         if(rightheight - leftheight > 1 ){
            (static_cast<void> (0));
            return false;
         }
         else if(NodeTraits::get_balance(n) != NodeTraits::positive()){
            (static_cast<void> (0));
            return false;
         }
      }

      else{
         if(leftheight - rightheight > 1 ){
            (static_cast<void> (0));
            return false;
         }
         else if(NodeTraits::get_balance(n) != NodeTraits::negative()){
            (static_cast<void> (0));
            return false;
         }
      }
      return true;
   }

   static void rebalance_after_erasure
      ( const node_ptr & header, const node_ptr &z, const typename bstree_algo::data_for_rebalance &info)
   {
      if(info.y != z){
         NodeTraits::set_balance(info.y, NodeTraits::get_balance(z));
      }

      rebalance_after_erasure_restore_invariants(header, info.x, info.x_parent);
   }

   static void rebalance_after_erasure_restore_invariants(const node_ptr & header, node_ptr x, node_ptr x_parent)
   {
      for ( node_ptr root = NodeTraits::get_parent(header)
          ; x != root
          ; root = NodeTraits::get_parent(header), x_parent = NodeTraits::get_parent(x)) {
         const balance x_parent_balance = NodeTraits::get_balance(x_parent);


         const node_ptr x_parent_left (NodeTraits::get_left(x_parent));
         const node_ptr x_parent_right(NodeTraits::get_right(x_parent));

         if(x_parent_balance == NodeTraits::zero()){
            NodeTraits::set_balance( x_parent, x == x_parent_right ? NodeTraits::negative() : NodeTraits::positive() );
            break;
         }
         else if(x_parent_balance == NodeTraits::negative()){
            if (x == x_parent_left) {
               NodeTraits::set_balance(x_parent, NodeTraits::zero());
               x = x_parent;
            }
            else {

               (static_cast<void> (0));
               if (NodeTraits::get_balance(x_parent_left) == NodeTraits::positive()) {

                  (static_cast<void> (0));
                  x = avl_rotate_left_right(x_parent, x_parent_left, header);
               }
               else {
                  avl_rotate_right(x_parent, x_parent_left, header);
                  x = x_parent_left;
               }


               if (NodeTraits::get_balance(x) == NodeTraits::positive()){
                  break;
               }
            }
         }
         else if(x_parent_balance == NodeTraits::positive()){
            if (x == x_parent_right) {
               NodeTraits::set_balance(x_parent, NodeTraits::zero());
               x = x_parent;
            }
            else {

               (static_cast<void> (0));
               if (NodeTraits::get_balance(x_parent_right) == NodeTraits::negative()) {

                  (static_cast<void> (0));
                  x = avl_rotate_right_left(x_parent, x_parent_right, header);
               }
               else {
                  avl_rotate_left(x_parent, x_parent_right, header);
                  x = x_parent_right;
               }

               if (NodeTraits::get_balance(x) == NodeTraits::negative()){
                  break;
               }
            }
         }
         else{
            (static_cast<void> (0));
         }
      }
   }

   static void rebalance_after_insertion(const node_ptr & header, node_ptr x)
   {
      NodeTraits::set_balance(x, NodeTraits::zero());

      for(node_ptr root = NodeTraits::get_parent(header); x != root; root = NodeTraits::get_parent(header)){
         node_ptr const x_parent(NodeTraits::get_parent(x));
         node_ptr const x_parent_left(NodeTraits::get_left(x_parent));
         const balance x_parent_balance = NodeTraits::get_balance(x_parent);
         const bool x_is_leftchild(x == x_parent_left);
         if(x_parent_balance == NodeTraits::zero()){


            NodeTraits::set_balance( x_parent, x_is_leftchild ? NodeTraits::negative() : NodeTraits::positive() );
            x = x_parent;
         }
         else if(x_parent_balance == NodeTraits::positive()){

            if (x_is_leftchild)
               NodeTraits::set_balance(x_parent, NodeTraits::zero());
            else{
               if (NodeTraits::get_balance(x) == NodeTraits::negative())
                  avl_rotate_right_left(x_parent, x, header);
               else
                  avl_rotate_left(x_parent, x, header);
            }
            break;
         }
         else if(x_parent_balance == NodeTraits::negative()){

            if (x_is_leftchild) {
               if (NodeTraits::get_balance(x) == NodeTraits::positive())
                  avl_rotate_left_right(x_parent, x, header);
               else
                  avl_rotate_right(x_parent, x, header);
            }
            else
               NodeTraits::set_balance(x_parent, NodeTraits::zero());
            break;
         }
         else{
            (static_cast<void> (0));
         }
      }
   }

   static void left_right_balancing(const node_ptr & a, const node_ptr & b, const node_ptr & c)
   {

      const balance c_balance = NodeTraits::get_balance(c);
      const balance zero_balance = NodeTraits::zero();
      const balance posi_balance = NodeTraits::positive();
      const balance nega_balance = NodeTraits::negative();
      NodeTraits::set_balance(c, zero_balance);
      if(c_balance == nega_balance){
         NodeTraits::set_balance(a, posi_balance);
         NodeTraits::set_balance(b, zero_balance);
      }
      else if(c_balance == zero_balance){
         NodeTraits::set_balance(a, zero_balance);
         NodeTraits::set_balance(b, zero_balance);
      }
      else if(c_balance == posi_balance){
         NodeTraits::set_balance(a, zero_balance);
         NodeTraits::set_balance(b, nega_balance);
      }
      else{
         (static_cast<void> (0));
      }
   }

   static node_ptr avl_rotate_left_right(const node_ptr a, const node_ptr a_oldleft, const node_ptr & hdr)
   {
# 644 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
      const node_ptr c = NodeTraits::get_right(a_oldleft);
      bstree_algo::rotate_left_no_parent_fix(a_oldleft, c);


      bstree_algo::rotate_right(a, c, NodeTraits::get_parent(a), hdr);
      left_right_balancing(a, a_oldleft, c);
      return c;
   }

   static node_ptr avl_rotate_right_left(const node_ptr a, const node_ptr a_oldright, const node_ptr & hdr)
   {
# 664 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 3 4
      const node_ptr c (NodeTraits::get_left(a_oldright));
      bstree_algo::rotate_right_no_parent_fix(a_oldright, c);


      bstree_algo::rotate_left(a, c, NodeTraits::get_parent(a), hdr);
      left_right_balancing(a_oldright, a, c);
      return c;
   }

   static void avl_rotate_left(const node_ptr &x, const node_ptr &x_oldright, const node_ptr & hdr)
   {
      bstree_algo::rotate_left(x, x_oldright, NodeTraits::get_parent(x), hdr);


      if (NodeTraits::get_balance(x_oldright) == NodeTraits::positive()) {
         NodeTraits::set_balance(x, NodeTraits::zero());
         NodeTraits::set_balance(x_oldright, NodeTraits::zero());
      }
      else {
         NodeTraits::set_balance(x, NodeTraits::positive());
         NodeTraits::set_balance(x_oldright, NodeTraits::negative());
      }
   }

   static void avl_rotate_right(const node_ptr &x, const node_ptr &x_oldleft, const node_ptr & hdr)
   {
      bstree_algo::rotate_right(x, x_oldleft, NodeTraits::get_parent(x), hdr);


      if (NodeTraits::get_balance(x_oldleft) == NodeTraits::negative()) {
         NodeTraits::set_balance(x, NodeTraits::zero());
         NodeTraits::set_balance(x_oldleft, NodeTraits::zero());
      }
      else {
         NodeTraits::set_balance(x, NodeTraits::negative());
         NodeTraits::set_balance(x_oldleft, NodeTraits::positive());
      }
   }


};



template<class NodeTraits>
struct get_algo<AvlTreeAlgorithms, NodeTraits>
{
   typedef avltree_algorithms<NodeTraits> type;
};

template <class ValueTraits, class NodePtrCompare, class ExtraChecker>
struct get_node_checker<AvlTreeAlgorithms, ValueTraits, NodePtrCompare, ExtraChecker>
{
   typedef detail::avltree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker> type;
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 726 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree_algorithms.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/avltree_node.hpp" 2 3 4



namespace boost {
namespace intrusive {
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/avltree_node.hpp" 3 4
template<class VoidPointer>
struct compact_avltree_node
{
   typedef typename pointer_rebind<VoidPointer, compact_avltree_node<VoidPointer> >::type node_ptr;
   typedef typename pointer_rebind<VoidPointer, const compact_avltree_node<VoidPointer> >::type const_node_ptr;
   enum balance { negative_t, zero_t, positive_t };
   node_ptr parent_, left_, right_;
};


template<class VoidPointer>
struct avltree_node
{
   typedef typename pointer_rebind<VoidPointer, avltree_node<VoidPointer> >::type node_ptr;
   typedef typename pointer_rebind<VoidPointer, const avltree_node<VoidPointer> >::type const_node_ptr;
   enum balance { negative_t, zero_t, positive_t };
   node_ptr parent_, left_, right_;
   balance balance_;
};



template<class VoidPointer>
struct default_avltree_node_traits_impl
{
   typedef avltree_node<VoidPointer> node;
   typedef typename node::node_ptr node_ptr;
   typedef typename node::const_node_ptr const_node_ptr;

   typedef typename node::balance balance;

   inline static node_ptr get_parent(const const_node_ptr & n)
   { return n->parent_; }

   inline static node_ptr get_parent(const node_ptr & n)
   { return n->parent_; }

   inline static void set_parent(const node_ptr & n, const node_ptr & p)
   { n->parent_ = p; }

   inline static node_ptr get_left(const const_node_ptr & n)
   { return n->left_; }

   inline static node_ptr get_left(const node_ptr & n)
   { return n->left_; }

   inline static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   inline static node_ptr get_right(const const_node_ptr & n)
   { return n->right_; }

   inline static node_ptr get_right(const node_ptr & n)
   { return n->right_; }

   inline static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }

   inline static balance get_balance(const const_node_ptr & n)
   { return n->balance_; }

   inline static balance get_balance(const node_ptr & n)
   { return n->balance_; }

   inline static void set_balance(const node_ptr & n, balance b)
   { n->balance_ = b; }

   inline static balance negative()
   { return node::negative_t; }

   inline static balance zero()
   { return node::zero_t; }

   inline static balance positive()
   { return node::positive_t; }
};



template<class VoidPointer>
struct compact_avltree_node_traits_impl
{
   typedef compact_avltree_node<VoidPointer> node;
   typedef typename node::node_ptr node_ptr;
   typedef typename node::const_node_ptr const_node_ptr;
   typedef typename node::balance balance;

   typedef pointer_plus_bits<node_ptr, 2> ptr_bit;

   inline static node_ptr get_parent(const const_node_ptr & n)
   { return ptr_bit::get_pointer(n->parent_); }

   inline static void set_parent(const node_ptr & n, const node_ptr & p)
   { ptr_bit::set_pointer(n->parent_, p); }

   inline static node_ptr get_left(const const_node_ptr & n)
   { return n->left_; }

   inline static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   inline static node_ptr get_right(const const_node_ptr & n)
   { return n->right_; }

   inline static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }

   inline static balance get_balance(const const_node_ptr & n)
   { return (balance)ptr_bit::get_bits(n->parent_); }

   inline static void set_balance(const node_ptr & n, balance b)
   { ptr_bit::set_bits(n->parent_, (std::size_t)b); }

   inline static balance negative()
   { return node::negative_t; }

   inline static balance zero()
   { return node::zero_t; }

   inline static balance positive()
   { return node::positive_t; }
};


template<class VoidPointer, bool Compact>
struct avltree_node_traits_dispatch
   : public default_avltree_node_traits_impl<VoidPointer>
{};

template<class VoidPointer>
struct avltree_node_traits_dispatch<VoidPointer, true>
   : public compact_avltree_node_traits_impl<VoidPointer>
{};


template<class VoidPointer, bool OptimizeSize = false>
struct avltree_node_traits
   : public avltree_node_traits_dispatch
         < VoidPointer
         , OptimizeSize &&
            max_pointer_plus_bits
            < VoidPointer
            , detail::alignment_of<compact_avltree_node<VoidPointer> >::value
            >::value >= 2u
         >
{};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/avltree_node.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 2 3 4





         


namespace boost {
namespace intrusive {






template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct make_avl_set_base_hook
{

   typedef typename pack_options

      <hook_defaults, O1, O2, O3, O4>



      ::type packed_options;

   typedef generic_hook
   < AvlTreeAlgorithms
   , avltree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
   , typename packed_options::tag
   , packed_options::link_mode
   , AvlTreeBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 3 4
template<class O1, class O2, class O3, class O4>

class avl_set_base_hook
   : public make_avl_set_base_hook

      <O1, O2, O3, O4>



      ::type
{
# 160 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 3 4
};






template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct make_avl_set_member_hook
{

   typedef typename pack_options

      <hook_defaults, O1, O2, O3, O4>



      ::type packed_options;

   typedef generic_hook
   < AvlTreeAlgorithms
   , avltree_node_traits<typename packed_options::void_pointer, packed_options::optimize_size>
   , member_tag
   , packed_options::link_mode
   , NoBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 209 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 3 4
template<class O1, class O2, class O3, class O4>

class avl_set_member_hook
   : public make_avl_set_member_hook

      <O1, O2, O3, O4>



      ::type
{
# 286 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 3 4
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 292 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set_hook.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 3 4
         


namespace boost {
namespace intrusive {



struct default_avltree_hook_applier
{ template <class T> struct apply{ typedef typename T::default_avltree_hook type; }; };

template<>
struct is_default_hook_tag<default_avltree_hook_applier>
{ static const bool value = true; };

struct avltree_defaults
   : bstree_defaults
{
   typedef default_avltree_hook_applier proto_value_traits;
};
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 3 4
template<class ValueTraits, class VoidOrKeyOfValue, class VoidOrKeyComp, class SizeType, bool ConstantTimeSize, typename HeaderHolder>

class avltree_impl

   : public bstree_impl<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>

{
   public:
   typedef ValueTraits value_traits;

   typedef bstree_impl< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, SizeType
                      , ConstantTimeSize, AvlTreeAlgorithms
                      , HeaderHolder> tree_type;
   typedef tree_type implementation_defined;


   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::key_type key_type;
   typedef typename implementation_defined::key_of_value key_of_value;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = implementation_defined::constant_time_size;

   private:


   public: avltree_impl(avltree_impl const &) = delete; avltree_impl& operator=(avltree_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:



   public:

   typedef typename implementation_defined::insert_commit_data insert_commit_data;


   avltree_impl()
      : tree_type()
   {}


   explicit avltree_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : tree_type(cmp, v_traits)
   {}


   template<class Iterator>
   avltree_impl( bool unique, Iterator b, Iterator e
              , const key_compare &cmp = key_compare()
              , const value_traits &v_traits = value_traits())
      : tree_type(unique, b, e, cmp, v_traits)
   {}


   avltree_impl(avltree_impl && x)
      : tree_type(::boost::move((tree_type&)(x)))
   {}


   avltree_impl& operator=(avltree_impl && x)
   { return static_cast<avltree_impl&>(tree_type::operator=(::boost::move((tree_type&)(x)))); }
# 234 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 3 4
   using tree_type::clone_from;




   template <class Cloner, class Disposer>
   void clone_from(avltree_impl && src, Cloner cloner, Disposer disposer)
   { tree_type::clone_from(::boost::move((tree_type&)(src)), cloner, disposer); }
# 461 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 3 4
};







template<class T, class O1 = void, class O2 = void
                , class O3 = void, class O4 = void
                , class O5 = void, class O6 = void>

struct make_avltree
{

   typedef typename pack_options
      < avltree_defaults,

      O1, O2, O3, O4, O5, O6



      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;

   typedef avltree_impl
         < value_traits
         , typename packed_options::key_of_value
         , typename packed_options::compare
         , 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 O1, class O2, class O3, class O4, class O5, class O6>



class avltree
   : public make_avltree<T,

      O1, O2, O3, O4, O5, O6



      >::type
{
   typedef typename make_avltree
      <T,

      O1, O2, O3, O4, O5, O6



      >::type Base;
   public: avltree(avltree const &) = delete; avltree& operator=(avltree 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::key_compare key_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;
   typedef typename Base::reverse_iterator reverse_iterator;
   typedef typename Base::const_reverse_iterator const_reverse_iterator;


   static_assert((detail::is_same<typename value_traits::value_type, T>::value), "(detail::is_same<typename value_traits::value_type, T>::value)");

   avltree()
      : Base()
   {}

   explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   avltree( bool unique, Iterator b, Iterator e
         , const key_compare &cmp = key_compare()
         , const value_traits &v_traits = value_traits())
      : Base(unique, b, e, cmp, v_traits)
   {}

   avltree(avltree && x)
      : Base(::boost::move((Base&)(x)))
   {}

   avltree& operator=(avltree && x)
   { return static_cast<avltree &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   void clone_from(avltree && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   static avltree &container_from_end_iterator(iterator end_iterator)
   { return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator)); }

   static const avltree &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator)); }

   static avltree &container_from_iterator(iterator it)
   { return static_cast<avltree &>(Base::container_from_iterator(it)); }

   static const avltree &container_from_iterator(const_iterator it)
   { return static_cast<const avltree &>(Base::container_from_iterator(it)); }
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avltree.hpp" 2 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 2 3 4





         


namespace boost {
namespace intrusive {


template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>
class avl_multiset_impl;
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>

class avl_set_impl

   : public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>

{

   typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder> tree_type;
   public: avl_set_impl(avl_set_impl const &) = delete; avl_set_impl& operator=(avl_set_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   typedef tree_type implementation_defined;


   public:
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::key_type key_type;
   typedef typename implementation_defined::key_of_value key_of_value;
   typedef typename implementation_defined::value_traits value_traits;
   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::insert_commit_data insert_commit_data;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = tree_type::constant_time_size;

   public:


   avl_set_impl()
      : tree_type()
   {}


   explicit avl_set_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : tree_type(cmp, v_traits)
   {}


   template<class Iterator>
   avl_set_impl( Iterator b, Iterator e
           , const key_compare &cmp = key_compare()
           , const value_traits &v_traits = value_traits())
      : tree_type(true, b, e, cmp, v_traits)
   {}


   avl_set_impl(avl_set_impl && x)
      : tree_type(::boost::move((tree_type&)(x)))
   {}


   avl_set_impl& operator=(avl_set_impl && x)
   { return static_cast<avl_set_impl&>(tree_type::operator=(::boost::move((tree_type&)(x)))); }
# 200 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
   using tree_type::clone_from;




   template <class Cloner, class Disposer>
   void clone_from(avl_set_impl && src, Cloner cloner, Disposer disposer)
   { tree_type::clone_from(::boost::move((tree_type&)(src)), cloner, disposer); }


   std::pair<iterator, bool> insert(reference value)
   { return tree_type::insert_unique(value); }


   iterator insert(const_iterator hint, reference value)
   { return tree_type::insert_unique(hint, value); }


   std::pair<iterator, bool> insert_check
      (const key_type &key, insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(key, commit_data); }


   std::pair<iterator, bool> insert_check
      (const_iterator hint, const key_type &key
      ,insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(hint, key, commit_data); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator, bool> insert_check
      (const KeyType &key, KeyTypeKeyCompare comp, insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(key, comp, commit_data); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator, bool> insert_check
      (const_iterator hint, const KeyType &key
      ,KeyTypeKeyCompare comp, insert_commit_data &commit_data)
   { return tree_type::insert_unique_check(hint, key, comp, commit_data); }


   template<class Iterator>
   void insert(Iterator b, Iterator e)
   { tree_type::insert_unique(b, e); }


   iterator insert_commit(reference value, const insert_commit_data &commit_data)
   { return tree_type::insert_unique_commit(value, commit_data); }
# 299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
   size_type count(const key_type &key) const
   { return static_cast<size_type>(this->tree_type::find(key) != this->tree_type::cend()); }


   template<class KeyType, class KeyTypeKeyCompare>
   size_type count(const KeyType& key, KeyTypeKeyCompare comp) const
   { return static_cast<size_type>(this->tree_type::find(key, comp) != this->tree_type::cend()); }
# 354 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
   std::pair<iterator,iterator> equal_range(const key_type &key)
   { return this->tree_type::lower_bound_range(key); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<iterator,iterator> equal_range(const KeyType& key, KeyTypeKeyCompare comp)
   { return this->tree_type::equal_range(key, comp); }


   std::pair<const_iterator, const_iterator>
      equal_range(const key_type &key) const
   { return this->tree_type::lower_bound_range(key); }


   template<class KeyType, class KeyTypeKeyCompare>
   std::pair<const_iterator, const_iterator>
      equal_range(const KeyType& key, KeyTypeKeyCompare comp) const
   { return this->tree_type::equal_range(key, comp); }
# 427 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
   template<class Compare2>
   void merge(avl_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_unique(source); }


   template<class Compare2>
   void merge(avl_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_unique(source); }


};
# 463 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
template<class T, class O1 = void, class O2 = void
                , class O3 = void, class O4 = void
                , class O5 = void, class O6 = void>

struct make_avl_set
{

   typedef typename pack_options
      < avltree_defaults,

      O1, O2, O3, O4, O5, O6



      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;

   typedef avl_set_impl
         < value_traits
         , typename packed_options::key_of_value
         , typename packed_options::compare
         , 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 O1, class O2, class O3, class O4, class O5, class O6>



class avl_set
   : public make_avl_set<T,

   O1, O2, O3, O4, O5, O6



   >::type
{
   typedef typename make_avl_set
      <T,

      O1, O2, O3, O4, O5, O6



      >::type Base;

   public: avl_set(avl_set const &) = delete; avl_set& operator=(avl_set 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::key_compare key_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   static_assert((detail::is_same<typename value_traits::value_type, T>::value), "(detail::is_same<typename value_traits::value_type, T>::value)");

   avl_set()
      : Base()
   {}

   explicit avl_set( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   avl_set( Iterator b, Iterator e
      , const key_compare &cmp = key_compare()
      , const value_traits &v_traits = value_traits())
      : Base(b, e, cmp, v_traits)
   {}

   avl_set(avl_set && x)
      : Base(::boost::move((Base&)(x)))
   {}

   avl_set& operator=(avl_set && x)
   { return static_cast<avl_set &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   void clone_from(const avl_set &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   void clone_from(avl_set && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   static avl_set &container_from_end_iterator(iterator end_iterator)
   { return static_cast<avl_set &>(Base::container_from_end_iterator(end_iterator)); }

   static const avl_set &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const avl_set &>(Base::container_from_end_iterator(end_iterator)); }

   static avl_set &container_from_iterator(iterator it)
   { return static_cast<avl_set &>(Base::container_from_iterator(it)); }

   static const avl_set &container_from_iterator(const_iterator it)
   { return static_cast<const avl_set &>(Base::container_from_iterator(it)); }
};
# 587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
template<class ValueTraits, class VoidOrKeyOfValue, class Compare, class SizeType, bool ConstantTimeSize, typename HeaderHolder>

class avl_multiset_impl

   : public bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder>

{

   typedef bstree_impl<ValueTraits, VoidOrKeyOfValue, Compare, SizeType, ConstantTimeSize, AvlTreeAlgorithms, HeaderHolder> tree_type;

   public: avl_multiset_impl(avl_multiset_impl const &) = delete; avl_multiset_impl& operator=(avl_multiset_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:
   typedef tree_type implementation_defined;


   public:
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::key_type key_type;
   typedef typename implementation_defined::key_of_value key_of_value;
   typedef typename implementation_defined::value_traits value_traits;
   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::insert_commit_data insert_commit_data;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = tree_type::constant_time_size;

   public:

   avl_multiset_impl()
      : tree_type()
   {}


   explicit avl_multiset_impl( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : tree_type(cmp, v_traits)
   {}


   template<class Iterator>
   avl_multiset_impl( Iterator b, Iterator e
                , const key_compare &cmp = key_compare()
                , const value_traits &v_traits = value_traits())
      : tree_type(false, b, e, cmp, v_traits)
   {}


   avl_multiset_impl(avl_multiset_impl && x)
      : tree_type(::boost::move((tree_type&)(x)))
   {}


   avl_multiset_impl& operator=(avl_multiset_impl && x)
   { return static_cast<avl_multiset_impl&>(tree_type::operator=(::boost::move((tree_type&)(x)))); }
# 737 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
   using tree_type::clone_from;




   template <class Cloner, class Disposer>
   void clone_from(avl_multiset_impl && src, Cloner cloner, Disposer disposer)
   { tree_type::clone_from(::boost::move((tree_type&)(src)), cloner, disposer); }


   iterator insert(reference value)
   { return tree_type::insert_equal(value); }


   iterator insert(const_iterator hint, reference value)
   { return tree_type::insert_equal(hint, value); }


   template<class Iterator>
   void insert(Iterator b, Iterator e)
   { tree_type::insert_equal(b, e); }
# 922 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
   template<class Compare2>
   void merge(avl_multiset_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_equal(source); }

   template<class Compare2>
   void merge(avl_set_impl<ValueTraits, VoidOrKeyOfValue, Compare2, SizeType, ConstantTimeSize, HeaderHolder> &source)
   { return tree_type::merge_equal(source); }


};
# 957 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 3 4
template<class T, class O1 = void, class O2 = void
                , class O3 = void, class O4 = void
                , class O5 = void, class O6 = void>

struct make_avl_multiset
{

   typedef typename pack_options
      < avltree_defaults,

      O1, O2, O3, O4, O5, O6



      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;

   typedef avl_multiset_impl
         < value_traits
         , typename packed_options::key_of_value
         , typename packed_options::compare
         , 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 O1, class O2, class O3, class O4, class O5, class O6>



class avl_multiset
   : public make_avl_multiset<T,

      O1, O2, O3, O4, O5, O6



      >::type
{
   typedef typename make_avl_multiset<T,

      O1, O2, O3, O4, O5, O6



      >::type Base;

   public: avl_multiset(avl_multiset const &) = delete; avl_multiset& operator=(avl_multiset 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::key_compare key_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   static_assert((detail::is_same<typename value_traits::value_type, T>::value), "(detail::is_same<typename value_traits::value_type, T>::value)");

   avl_multiset()
      : Base()
   {}

   explicit avl_multiset( const key_compare &cmp, const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   avl_multiset( Iterator b, Iterator e
           , const key_compare &cmp = key_compare()
           , const value_traits &v_traits = value_traits())
      : Base(b, e, cmp, v_traits)
   {}

   avl_multiset(avl_multiset && x)
      : Base(::boost::move((Base&)(x)))
   {}

   avl_multiset& operator=(avl_multiset && x)
   { return static_cast<avl_multiset &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   void clone_from(const avl_multiset &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   void clone_from(avl_multiset && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   static avl_multiset &container_from_end_iterator(iterator end_iterator)
   { return static_cast<avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }

   static const avl_multiset &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const avl_multiset &>(Base::container_from_end_iterator(end_iterator)); }

   static avl_multiset &container_from_iterator(iterator it)
   { return static_cast<avl_multiset &>(Base::container_from_iterator(it)); }

   static const avl_multiset &container_from_iterator(const_iterator it)
   { return static_cast<const avl_multiset &>(Base::container_from_iterator(it)); }
};



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 1072 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/intrusive/avl_set.hpp" 2 3 4
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_period_history.h" 2




# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_period_history.h"
namespace bi = boost::intrusive;

class RGWPeriod;






class RGWPeriodHistory final {
 private:

  class History;


  friend bool operator<(const History& lhs, const History& rhs);
  friend struct NewestEpochLess;

  class Impl;
  std::unique_ptr<Impl> impl;

 public:




  class Puller {
   public:
    virtual ~Puller() = default;

    virtual int pull(const std::string& period_id, RGWPeriod& period) = 0;
  };

  RGWPeriodHistory(CephContext* cct, Puller* puller,
                   const RGWPeriod& current_period);
  ~RGWPeriodHistory();
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_period_history.h"
  class Cursor final {
   public:
    Cursor() = default;
    explicit Cursor(int error) : error(error) {}

    int get_error() const { return error; }


    operator bool() const { return history != nullptr; }

    epoch_t get_epoch() const { return epoch; }
    const RGWPeriod& get_period() const;

    bool has_prev() const;
    bool has_next() const;

    void prev() { epoch--; }
    void next() { epoch++; }

    friend bool operator==(const Cursor& lhs, const Cursor& rhs);
    friend bool operator!=(const Cursor& lhs, const Cursor& rhs);

   private:

    friend class RGWPeriodHistory::Impl;

    Cursor(const History* history, std::mutex* mutex, epoch_t epoch)
      : history(history), mutex(mutex), epoch(epoch) {}

    int error{0};
    const History* history{nullptr};
    std::mutex* mutex{nullptr};
    epoch_t epoch{0};
  };


  Cursor get_current() const;





  Cursor attach(RGWPeriod&& period);





  Cursor insert(RGWPeriod&& period);



  Cursor lookup(epoch_t realm_epoch);
};
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_metadata.h" 2







class RGWRados;
class RGWCoroutine;
class JSONObj;
struct RGWObjVersionTracker;

struct obj_version;


enum RGWMDLogStatus {
  MDLOG_STATUS_UNKNOWN,
  MDLOG_STATUS_WRITE,
  MDLOG_STATUS_SETATTRS,
  MDLOG_STATUS_REMOVE,
  MDLOG_STATUS_COMPLETE,
  MDLOG_STATUS_ABORT,
};

class RGWMetadataObject {
protected:
  obj_version objv;
  ceph::real_time mtime;

public:
  RGWMetadataObject() {}
  virtual ~RGWMetadataObject() {}
  obj_version& get_version();
  real_time get_mtime() { return mtime; }

  virtual void dump(Formatter *f) const = 0;
};

class RGWMetadataManager;

class RGWMetadataHandler {
  friend class RGWMetadataManager;

public:
  enum sync_type_t {
    APPLY_ALWAYS,
    APPLY_UPDATES,
    APPLY_NEWER
  };
  static bool string_to_sync_type(const string& sync_string,
                                  sync_type_t& type) {
    if (sync_string.compare("update-by-version") == 0)
      type = APPLY_UPDATES;
    else if (sync_string.compare("update-by-timestamp") == 0)
      type = APPLY_NEWER;
    else if (sync_string.compare("always") == 0)
      type = APPLY_ALWAYS;
    else
      return false;
    return true;
  }

  virtual ~RGWMetadataHandler() {}
  virtual string get_type() = 0;

  virtual int get(RGWRados *store, string& entry, RGWMetadataObject **obj) = 0;
  virtual int put(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker,
                  real_time mtime, JSONObj *obj, sync_type_t type) = 0;
  virtual int remove(RGWRados *store, string& entry, RGWObjVersionTracker& objv_tracker) = 0;

  virtual int list_keys_init(RGWRados *store, const string& marker, void **phandle) = 0;
  virtual int list_keys_next(void *handle, int max, list<string>& keys, bool *truncated) = 0;
  virtual void list_keys_complete(void *handle) = 0;

  virtual string get_marker(void *handle) = 0;


  virtual void get_hash_key(const string& section, const string& key, string& hash_key) {
    hash_key = section + ":" + key;
  }

protected:
  virtual void get_pool_and_oid(RGWRados *store, const string& key, rgw_pool& pool, string& oid) = 0;






  static bool check_versions(const obj_version& ondisk, const real_time& ondisk_time,
                             const obj_version& incoming, const real_time& incoming_time,
                             sync_type_t sync_mode) {
    switch (sync_mode) {
    case APPLY_UPDATES:
      if ((ondisk.tag != incoming.tag) ||
   (ondisk.ver >= incoming.ver))
 return false;
      break;
    case APPLY_NEWER:
      if (ondisk_time >= incoming_time)
 return false;
      break;
    case APPLY_ALWAYS:
    default: break;
    }
    return true;
  }




  static void parse_bucket(const string& bucket,
                           string *tenant_name,
                           string *bucket_name,
                           string *bucket_instance = nullptr )
  {
    int pos = bucket.find('/');
    if (pos >= 0) {
      *tenant_name = bucket.substr(0, pos);
    } else {
      tenant_name->clear();
    }
    string bn = bucket.substr(pos + 1);
    pos = bn.find (':');
    if (pos < 0) {
      *bucket_name = std::move(bn);
      return;
    }
    *bucket_name = bn.substr(0, pos);
    if (bucket_instance) {
      *bucket_instance = bn.substr(pos + 1);
    }
  }
};



struct RGWMetadataLogInfo {
  string marker;
  real_time last_update;

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};

class RGWCompletionManager;

class RGWMetadataLogInfoCompletion : public RefCountedObject {
 public:
  using info_callback_t = std::function<void(int, const cls_log_header&)>;
 private:
  cls_log_header header;
  librados::IoCtx io_ctx;
  librados::AioCompletion *completion;
  std::mutex mutex;
  boost::optional<info_callback_t> callback;
 public:
  explicit RGWMetadataLogInfoCompletion(info_callback_t callback);
  ~RGWMetadataLogInfoCompletion() override;

  librados::IoCtx& get_io_ctx() { return io_ctx; }
  cls_log_header& get_header() { return header; }
  librados::AioCompletion* get_completion() { return completion; }

  void finish(librados::completion_t cb) {
    std::lock_guard<std::mutex> lock(mutex);
    if (callback) {
      (*callback)(completion->get_return_value(), header);
    }
  }
  void cancel() {
    std::lock_guard<std::mutex> lock(mutex);
    callback = boost::none;
  }
};

class RGWMetadataLog {
  CephContext *cct;
  RGWRados *store;
  const string prefix;

  static std::string make_prefix(const std::string& period) {
    if (period.empty())
      return "meta.log.";
    return "meta.log." + period + ".";
  }

  RWLock lock;
  set<int> modified_shards;

  void mark_modified(int shard_id);
public:
  RGWMetadataLog(CephContext *_cct, RGWRados *_store, const std::string& period)
    : cct(_cct), store(_store),
      prefix(make_prefix(period)),
      lock("RGWMetaLog::lock") {}

  void get_shard_oid(int id, string& oid) const {
    char buf[16];
    snprintf(buf, sizeof(buf), "%d", id);
    oid = prefix + buf;
  }

  int add_entry(RGWMetadataHandler *handler, const string& section, const string& key, bufferlist& bl);
  int store_entries_in_shard(list<cls_log_entry>& entries, int shard_id, librados::AioCompletion *completion);

  struct LogListCtx {
    int cur_shard;
    string marker;
    real_time from_time;
    real_time end_time;

    string cur_oid;

    bool done;

    LogListCtx() : cur_shard(0), done(false) {}
  };

  void init_list_entries(int shard_id, const real_time& from_time, const real_time& end_time, string& marker, void **handle);
  void complete_list_entries(void *handle);
  int list_entries(void *handle,
                   int max_entries,
                   list<cls_log_entry>& entries,
     string *out_marker,
     bool *truncated);

  int trim(int shard_id, const real_time& from_time, const real_time& end_time, const string& start_marker, const string& end_marker);
  int get_info(int shard_id, RGWMetadataLogInfo *info);
  int get_info_async(int shard_id, RGWMetadataLogInfoCompletion *completion);
  int lock_exclusive(int shard_id, timespan duration, string&zone_id, string& owner_id);
  int unlock(int shard_id, string& zone_id, string& owner_id);

  int update_shards(list<int>& shards);

  void read_clear_modified(set<int> &modified);
};

struct LogStatusDump {
  RGWMDLogStatus status;

  explicit LogStatusDump(RGWMDLogStatus _status) : status(_status) {}
  void dump(Formatter *f) const;
};

struct RGWMetadataLogData {
  obj_version read_version;
  obj_version write_version;
  RGWMDLogStatus status;

  RGWMetadataLogData() : status(MDLOG_STATUS_UNKNOWN) {}

  void encode(bufferlist& bl) const;
  void decode(bufferlist::const_iterator& bl);
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const RGWMetadataLogData &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWMetadataLogData &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWMetadataLogHistory {
  epoch_t oldest_realm_epoch;
  std::string oldest_period_id;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(oldest_realm_epoch, bl);
    encode(oldest_period_id, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& p) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, p); decode(struct_compat, p); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, p); if (struct_len > p.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = p.get_off() + struct_len; do {;
    decode(oldest_realm_epoch, p);
    decode(oldest_period_id, p);
    } while (false); if (struct_end) { if (p.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (p.get_off() < struct_end) p.advance(struct_end - p.get_off()); };
  }

  static const std::string oid;
};
inline void encode(const RGWMetadataLogHistory &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWMetadataLogHistory &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWMetadataManager {
  map<string, RGWMetadataHandler *> handlers;
  CephContext *cct;
  RGWRados *store;


  std::map<std::string, RGWMetadataLog> md_logs;

  RGWMetadataLog* current_log = nullptr;

  int find_handler(const string& metadata_key, RGWMetadataHandler **handler, string& entry);
  int pre_modify(RGWMetadataHandler *handler, string& section, const string& key,
                 RGWMetadataLogData& log_data, RGWObjVersionTracker *objv_tracker,
                 RGWMDLogStatus op_type);
  int post_modify(RGWMetadataHandler *handler, const string& section, const string& key, RGWMetadataLogData& log_data,
                 RGWObjVersionTracker *objv_tracker, int ret);

  string heap_oid(RGWMetadataHandler *handler, const string& key, const obj_version& objv);
  int store_in_heap(RGWMetadataHandler *handler, const string& key, bufferlist& bl,
                    RGWObjVersionTracker *objv_tracker, real_time mtime,
                    map<string, bufferlist> *pattrs);
  int remove_from_heap(RGWMetadataHandler *handler, const string& key, RGWObjVersionTracker *objv_tracker);
  int prepare_mutate(RGWRados *store, rgw_pool& pool, const string& oid,
                     const real_time& mtime,
                     RGWObjVersionTracker *objv_tracker,
                     RGWMetadataHandler::sync_type_t sync_mode);

public:
  RGWMetadataManager(CephContext *_cct, RGWRados *_store);
  ~RGWMetadataManager();

  RGWRados* get_store() { return store; }

  int init(const std::string& current_period);



  RGWPeriodHistory::Cursor init_oldest_log_period();



  RGWPeriodHistory::Cursor read_oldest_log_period() const;



  RGWCoroutine* read_oldest_log_period_cr(RGWPeriodHistory::Cursor *period,
                                          RGWObjVersionTracker *objv) const;



  RGWCoroutine* trim_log_period_cr(RGWPeriodHistory::Cursor period,
                                   RGWObjVersionTracker *objv) const;


  RGWMetadataLog* get_log(const std::string& period);

  int register_handler(RGWMetadataHandler *handler);

  template <typename F>
  int mutate(RGWMetadataHandler *handler, const string& key,
             const ceph::real_time& mtime, RGWObjVersionTracker *objv_tracker,
             RGWMDLogStatus op_type,
             RGWMetadataHandler::sync_type_t sync_mode,
             F&& f);

  RGWMetadataHandler *get_handler(const string& type);

  int put_entry(RGWMetadataHandler *handler, const string& key, bufferlist& bl, bool exclusive,
                RGWObjVersionTracker *objv_tracker, real_time mtime, map<string, bufferlist> *pattrs = 
# 362 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_metadata.h" 3 4
                                                                                                      __null
# 362 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_metadata.h"
                                                                                                          );
  int remove_entry(RGWMetadataHandler *handler,
     const string& key,
     RGWObjVersionTracker *objv_tracker);
  int get(string& metadata_key, Formatter *f);
  int put(string& metadata_key, bufferlist& bl,
          RGWMetadataHandler::sync_type_t sync_mode,
          obj_version *existing_version = 
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_metadata.h" 3 4
                                         __null
# 369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_metadata.h"
                                             );
  int remove(string& metadata_key);

  int list_keys_init(const string& section, void **phandle);
  int list_keys_init(const string& section, const string& marker, void **phandle);
  int list_keys_next(void *handle, int max, list<string>& keys, bool *truncated);
  void list_keys_complete(void *handle);

  string get_marker(void *handle);

  void dump_log_entry(cls_log_entry& entry, Formatter *f);

  void get_sections(list<string>& sections);
  int lock_exclusive(string& metadata_key, timespan duration, string& owner_id);
  int unlock(string& metadata_key, string& owner_id);

  int get_log_shard_id(const string& section, const string& key, int *shard_id);

  void parse_metadata_key(const string& metadata_key, string& type, string& entry);
};

template <typename F>
int RGWMetadataManager::mutate(RGWMetadataHandler *handler, const string& key,
                               const ceph::real_time& mtime, RGWObjVersionTracker *objv_tracker,
                               RGWMDLogStatus op_type,
                               RGWMetadataHandler::sync_type_t sync_mode,
                               F&& f)
{
  string oid;
  rgw_pool pool;

  handler->get_pool_and_oid(store, key, pool, oid);

  int ret = prepare_mutate(store, pool, oid, mtime, objv_tracker, sync_mode);
  if (ret < 0 ||
      ret == 1905) {
    return ret;
  }

  string section;
  RGWMetadataLogData log_data;
  ret = pre_modify(handler, section, key, log_data, objv_tracker, MDLOG_STATUS_WRITE);
  if (ret < 0) {
    return ret;
  }

  ret = std::forward<F>(f)();



  ret = post_modify(handler, section, key, log_data, objv_tracker, ret);
  if (ret < 0)
    return ret;

  return 0;
}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_meta_sync_status.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_meta_sync_status.h"
struct rgw_meta_sync_info {
  enum SyncState {
    StateInit = 0,
    StateBuildingFullSyncMaps = 1,
    StateSync = 2,
  };

  uint16_t state;
  uint32_t num_shards;
  std::string period;
  epoch_t realm_epoch = 0;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(state, bl);
    encode(num_shards, bl);
    encode(period, bl);
    encode(realm_epoch, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(state, bl);
    decode(num_shards, bl);
    if (struct_v >= 2) {
      decode(period, bl);
      decode(realm_epoch, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_json(JSONObj *obj);
  void dump(Formatter *f) const;
  static void generate_test_instances(std::list<rgw_meta_sync_info*>& ls);

  rgw_meta_sync_info() : state((int)StateInit), num_shards(0) {}
};
inline void encode(const rgw_meta_sync_info &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_meta_sync_info &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_meta_sync_marker {
  enum SyncState {
    FullSync = 0,
    IncrementalSync = 1,
  };
  uint16_t state;
  string marker;
  string next_step_marker;
  uint64_t total_entries;
  uint64_t pos;
  real_time timestamp;
  epoch_t realm_epoch{0};

  rgw_meta_sync_marker() : state(FullSync), total_entries(0), pos(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(state, bl);
    encode(marker, bl);
    encode(next_step_marker, bl);
    encode(total_entries, bl);
    encode(pos, bl);
    encode(timestamp, bl);
    encode(realm_epoch, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(state, bl);
    decode(marker, bl);
    decode(next_step_marker, bl);
    decode(total_entries, bl);
    decode(pos, bl);
    decode(timestamp, bl);
    if (struct_v >= 2) {
      decode(realm_epoch, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_json(JSONObj *obj);
  void dump(Formatter *f) const;
  static void generate_test_instances(std::list<rgw_meta_sync_marker*>& ls);
};
inline void encode(const rgw_meta_sync_marker &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_meta_sync_marker &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_meta_sync_status {
  rgw_meta_sync_info sync_info;
  map<uint32_t, rgw_meta_sync_marker> sync_markers;

  rgw_meta_sync_status() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(sync_info, bl);
    encode(sync_markers, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(sync_info, bl);
     decode(sync_markers, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
  static void generate_test_instances(std::list<rgw_meta_sync_status*>& ls);
};
inline void encode(const rgw_meta_sync_status &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_meta_sync_status &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_period_puller.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_period_puller.h"
class RGWRados;
class RGWPeriod;

class RGWPeriodPuller : public RGWPeriodHistory::Puller {
  RGWRados *const store;
 public:
  explicit RGWPeriodPuller(RGWRados* store) : store(store) {}

  int pull(const std::string& period_id, RGWPeriod& period) override;
};
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_module.h" 1







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
       


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 2 3 4


# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 3 4
namespace boost {
namespace asio {


namespace detail
{

  template <typename IoObjectService>
  class service_has_move
  {
  private:
    typedef IoObjectService service_type;
    typedef typename service_type::implementation_type implementation_type;

    template <typename T, typename U>
    static auto asio_service_has_move_eval(T* t, U* u)
      -> decltype(t->move_construct(*u, *u), char());
    static char (&asio_service_has_move_eval(...))[2];

  public:
    static const bool value =
      sizeof(asio_service_has_move_eval(
        static_cast<service_type*>(0),
        static_cast<implementation_type*>(0))) == 1;
  };
}
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 3 4
template <typename IoObjectService,
    bool Movable = detail::service_has_move<IoObjectService>::value>

class basic_io_object
{
public:

  typedef IoObjectService service_type;


  typedef typename service_type::implementation_type implementation_type;
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return service_.get_io_context();
  }
# 95 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return service_.get_io_context();
  }



  typedef boost::asio::io_context::executor_type executor_type;


  executor_type get_executor() noexcept
  {
    return service_.get_io_context().get_executor();
  }

protected:





  explicit basic_io_object(boost::asio::io_context& io_context)
    : service_(boost::asio::use_service<IoObjectService>(io_context))
  {
    service_.construct(implementation_);
  }
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 3 4
  ~basic_io_object()
  {
    service_.destroy(implementation_);
  }


  service_type& get_service()
  {
    return service_;
  }


  const service_type& get_service() const
  {
    return service_;
  }


  implementation_type& get_implementation()
  {
    return implementation_;
  }


  const implementation_type& get_implementation() const
  {
    return implementation_;
  }

private:
  basic_io_object(const basic_io_object&);
  basic_io_object& operator=(const basic_io_object&);


  service_type& service_;


  implementation_type implementation_;
};



template <typename IoObjectService>
class basic_io_object<IoObjectService, true>
{
public:
  typedef IoObjectService service_type;
  typedef typename service_type::implementation_type implementation_type;


  boost::asio::io_context& get_io_context()
  {
    return service_->get_io_context();
  }

  boost::asio::io_context& get_io_service()
  {
    return service_->get_io_context();
  }


  typedef boost::asio::io_context::executor_type executor_type;

  executor_type get_executor() noexcept
  {
    return service_->get_io_context().get_executor();
  }

protected:
  explicit basic_io_object(boost::asio::io_context& io_context)
    : service_(&boost::asio::use_service<IoObjectService>(io_context))
  {
    service_->construct(implementation_);
  }

  basic_io_object(basic_io_object&& other)
    : service_(&other.get_service())
  {
    service_->move_construct(implementation_, other.implementation_);
  }

  template <typename IoObjectService1>
  basic_io_object(IoObjectService1& other_service,
      typename IoObjectService1::implementation_type& other_implementation)
    : service_(&boost::asio::use_service<IoObjectService>(
          other_service.get_io_context()))
  {
    service_->converting_move_construct(implementation_,
        other_service, other_implementation);
  }

  ~basic_io_object()
  {
    service_->destroy(implementation_);
  }

  basic_io_object& operator=(basic_io_object&& other)
  {
    service_->move_assign(implementation_,
        *other.service_, other.implementation_);
    service_ = other.service_;
    return *this;
  }

  service_type& get_service()
  {
    return *service_;
  }

  const service_type& get_service() const
  {
    return *service_;
  }

  implementation_type& get_implementation()
  {
    return implementation_;
  }

  const implementation_type& get_implementation() const
  {
    return implementation_;
  }

private:
  basic_io_object(const basic_io_object&);
  void operator=(const basic_io_object&);

  IoObjectService* service_;
  implementation_type implementation_;
};


}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 291 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_io_object.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/post.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/post.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/post.hpp" 2 3 4

namespace boost {
namespace asio {
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/post.hpp" 3 4
template <typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
    CompletionToken&& token);
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/post.hpp" 3 4
template <typename Executor, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
    const Executor& ex, CompletionToken&& token,
    typename enable_if<is_executor<Executor>::value>::type* = 0);





template <typename ExecutionContext, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
    ExecutionContext& ctx, CompletionToken&& token,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type* = 0);

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/post.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/post.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/post.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/work_dispatcher.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/work_dispatcher.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/work_dispatcher.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler>
class work_dispatcher
{
public:
  work_dispatcher(Handler& handler)
    : work_((get_associated_executor)(handler)),
      handler_(static_cast<Handler&&>(handler))
  {
  }


  work_dispatcher(const work_dispatcher& other)
    : work_(other.work_),
      handler_(other.handler_)
  {
  }

  work_dispatcher(work_dispatcher&& other)
    : work_(static_cast<executor_work_guard< typename associated_executor<Handler>::type>&&>
                                                     (other.work_)),
      handler_(static_cast<Handler&&>(other.handler_))
  {
  }


  void operator()()
  {
    typename associated_allocator<Handler>::type alloc(
        (get_associated_allocator)(handler_));
    work_.get_executor().dispatch(
        static_cast<Handler&&>(handler_), alloc);
    work_.reset();
  }

private:
  executor_work_guard<typename associated_executor<Handler>::type> work_;
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/work_dispatcher.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/post.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/post.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
    CompletionToken&& token)
{
  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;

  async_completion<CompletionToken, void()> init(token);

  typename associated_executor<handler>::type ex(
      (get_associated_executor)(init.completion_handler));

  typename associated_allocator<handler>::type alloc(
      (get_associated_allocator)(init.completion_handler));

  ex.post(static_cast<handler&&>(init.completion_handler), alloc);

  return init.result.get();
}

template <typename Executor, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
    const Executor& ex, CompletionToken&& token,
    typename enable_if<is_executor<Executor>::value>::type*)
{
  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;

  async_completion<CompletionToken, void()> init(token);

  typename associated_allocator<handler>::type alloc(
      (get_associated_allocator)(init.completion_handler));

  ex.post(detail::work_dispatcher<handler>(init.completion_handler), alloc);

  return init.result.get();
}

template <typename ExecutionContext, typename CompletionToken>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
    ExecutionContext& ctx, CompletionToken&& token,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type*)
{
  return (post)(ctx.get_executor(),
      static_cast<CompletionToken&&>(token));
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/post.hpp" 2 3 4
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/post.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/io_control.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/io_control.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/io_control.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
namespace io_control {


class bytes_readable
{
public:

  bytes_readable()
    : value_(0)
  {
  }


  bytes_readable(std::size_t value)
    : value_(static_cast<detail::ioctl_arg_type>(value))
  {
  }


  int name() const
  {
    return static_cast<int>(0x541B);
  }


  void set(std::size_t value)
  {
    value_ = static_cast<detail::ioctl_arg_type>(value);
  }


  std::size_t get() const
  {
    return static_cast<std::size_t>(value_);
  }


  detail::ioctl_arg_type* data()
  {
    return &value_;
  }


  const detail::ioctl_arg_type* data() const
  {
    return &value_;
  }

private:
  detail::ioctl_arg_type value_;
};

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/io_control.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_option.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_option.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_option.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
namespace socket_option {


template <int Level, int Name>
class boolean
{
public:

  boolean()
    : value_(0)
  {
  }


  explicit boolean(bool v)
    : value_(v ? 1 : 0)
  {
  }


  boolean& operator=(bool v)
  {
    value_ = v ? 1 : 0;
    return *this;
  }


  bool value() const
  {
    return !!value_;
  }


  operator bool() const
  {
    return !!value_;
  }


  bool operator!() const
  {
    return !value_;
  }


  template <typename Protocol>
  int level(const Protocol&) const
  {
    return Level;
  }


  template <typename Protocol>
  int name(const Protocol&) const
  {
    return Name;
  }


  template <typename Protocol>
  int* data(const Protocol&)
  {
    return &value_;
  }


  template <typename Protocol>
  const int* data(const Protocol&) const
  {
    return &value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol&) const
  {
    return sizeof(value_);
  }


  template <typename Protocol>
  void resize(const Protocol&, std::size_t s)
  {



    switch (s)
    {
    case sizeof(char):
      value_ = *reinterpret_cast<char*>(&value_) ? 1 : 0;
      break;
    case sizeof(value_):
      break;
    default:
      {
        std::length_error ex("boolean socket option resize");
        boost::asio::detail::throw_exception(ex);
      }
    }
  }

private:
  int value_;
};


template <int Level, int Name>
class integer
{
public:

  integer()
    : value_(0)
  {
  }


  explicit integer(int v)
    : value_(v)
  {
  }


  integer& operator=(int v)
  {
    value_ = v;
    return *this;
  }


  int value() const
  {
    return value_;
  }


  template <typename Protocol>
  int level(const Protocol&) const
  {
    return Level;
  }


  template <typename Protocol>
  int name(const Protocol&) const
  {
    return Name;
  }


  template <typename Protocol>
  int* data(const Protocol&)
  {
    return &value_;
  }


  template <typename Protocol>
  const int* data(const Protocol&) const
  {
    return &value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol&) const
  {
    return sizeof(value_);
  }


  template <typename Protocol>
  void resize(const Protocol&, std::size_t s)
  {
    if (s != sizeof(value_))
    {
      std::length_error ex("integer socket option resize");
      boost::asio::detail::throw_exception(ex);
    }
  }

private:
  int value_;
};


template <int Level, int Name>
class linger
{
public:

  linger()
  {
    value_.l_onoff = 0;
    value_.l_linger = 0;
  }


  linger(bool e, int t)
  {
    enabled(e);
    timeout (t);
  }


  void enabled(bool value)
  {
    value_.l_onoff = value ? 1 : 0;
  }


  bool enabled() const
  {
    return value_.l_onoff != 0;
  }


  void timeout (int value)
  {



    value_.l_linger = value;

  }


  int timeout () const
  {
    return static_cast<int>(value_.l_linger);
  }


  template <typename Protocol>
  int level(const Protocol&) const
  {
    return Level;
  }


  template <typename Protocol>
  int name(const Protocol&) const
  {
    return Name;
  }


  template <typename Protocol>
  detail::linger_type* data(const Protocol&)
  {
    return &value_;
  }


  template <typename Protocol>
  const detail::linger_type* data(const Protocol&) const
  {
    return &value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol&) const
  {
    return sizeof(value_);
  }


  template <typename Protocol>
  void resize(const Protocol&, std::size_t s)
  {
    if (s != sizeof(value_))
    {
      std::length_error ex("linger socket option resize");
      boost::asio::detail::throw_exception(ex);
    }
  }

private:
  detail::linger_type value_;
};

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_option.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 2 3 4

namespace boost {
namespace asio {




class socket_base
{
public:

  enum shutdown_type
  {
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
    shutdown_receive = SHUT_RD,
    shutdown_send = SHUT_WR,
    shutdown_both = SHUT_RDWR

  };


  typedef int message_flags;
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  static const int message_peek = MSG_PEEK
                                                 ;
  static const int message_out_of_band = MSG_OOB
                                                       ;
  static const int message_do_not_route = MSG_DONTROUTE
                                                              ;
  static const int message_end_of_record = MSG_EOR
                                                         ;






  enum wait_type
  {

    wait_read,


    wait_write,


    wait_error
  };
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    1, 6>
      broadcast;
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    1, 1> debug;
# 191 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    1, 5>
      do_not_route;
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    1, 9> keep_alive;
# 258 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::integer<
    1, 7>
      send_buffer_size;
# 292 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::integer<
    1, 19>
      send_low_watermark;
# 326 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::integer<
    1, 8>
      receive_buffer_size;
# 360 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::integer<
    1, 18>
      receive_low_watermark;
# 395 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    1, 2>
      reuse_address;
# 431 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::linger<
    1, 13>
      linger;
# 465 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    1, 10>
      out_of_band_inline;
# 501 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    boost::asio::detail::custom_socket_option_level,
    boost::asio::detail::enable_connection_aborted_option>
    enable_connection_aborted;
# 527 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  typedef boost::asio::detail::io_control::bytes_readable bytes_readable;






  static const int max_listen_connections = 4096
                                     ;
# 544 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 3 4
  static const int max_connections = 4096
                                     ;



protected:

  ~socket_base()
  {
  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 560 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_base.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/array_fwd.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/array_fwd.hpp" 3 4
namespace boost {

template<class T, std::size_t N>
class array;

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_buffer_sequence.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_buffer_sequence.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_buffer_sequence.hpp" 2 3 4

namespace boost {
namespace asio {

class mutable_buffer;
class const_buffer;

namespace detail {

struct buffer_sequence_memfns_base
{
  void begin();
  void end();
  void size();
  void max_size();
  void capacity();
  void data();
  void prepare();
  void commit();
  void consume();
};

template <typename T>
struct buffer_sequence_memfns_derived
  : T, buffer_sequence_memfns_base
{
};

template <typename T, T>
struct buffer_sequence_memfns_check
{
};

template <typename>
char (&begin_memfn_helper(...))[2];

template <typename T>
char begin_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::begin>*);

template <typename>
char (&end_memfn_helper(...))[2];

template <typename T>
char end_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::end>*);

template <typename>
char (&size_memfn_helper(...))[2];

template <typename T>
char size_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::size>*);

template <typename>
char (&max_size_memfn_helper(...))[2];

template <typename T>
char max_size_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::max_size>*);

template <typename>
char (&capacity_memfn_helper(...))[2];

template <typename T>
char capacity_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::capacity>*);

template <typename>
char (&data_memfn_helper(...))[2];

template <typename T>
char data_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::data>*);

template <typename>
char (&prepare_memfn_helper(...))[2];

template <typename T>
char prepare_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::prepare>*);

template <typename>
char (&commit_memfn_helper(...))[2];

template <typename T>
char commit_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::commit>*);

template <typename>
char (&consume_memfn_helper(...))[2];

template <typename T>
char consume_memfn_helper(
    buffer_sequence_memfns_check<
      void (buffer_sequence_memfns_base::*)(),
      &buffer_sequence_memfns_derived<T>::consume>*);

template <typename, typename>
char (&buffer_element_type_helper(...))[2];
# 149 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_buffer_sequence.hpp" 3 4
template <typename T, typename Buffer>
char buffer_element_type_helper(
    typename T::const_iterator*,
    typename enable_if<is_convertible<
      typename T::value_type, Buffer>::value>::type*);



template <typename>
char (&const_buffers_type_typedef_helper(...))[2];

template <typename T>
char const_buffers_type_typedef_helper(
    typename T::const_buffers_type*);

template <typename>
char (&mutable_buffers_type_typedef_helper(...))[2];

template <typename T>
char mutable_buffers_type_typedef_helper(
    typename T::mutable_buffers_type*);

template <typename T, typename Buffer>
struct is_buffer_sequence_class
  : integral_constant<bool,
      sizeof(begin_memfn_helper<T>(0)) != 1 &&
      sizeof(end_memfn_helper<T>(0)) != 1 &&
      sizeof(buffer_element_type_helper<T, Buffer>(0, 0)) == 1>
{
};

template <typename T, typename Buffer>
struct is_buffer_sequence
  : conditional<is_class<T>::value,
      is_buffer_sequence_class<T, Buffer>,
      false_type>::type
{
};

template <>
struct is_buffer_sequence<mutable_buffer, mutable_buffer>
  : true_type
{
};

template <>
struct is_buffer_sequence<mutable_buffer, const_buffer>
  : true_type
{
};

template <>
struct is_buffer_sequence<const_buffer, const_buffer>
  : true_type
{
};

template <>
struct is_buffer_sequence<const_buffer, mutable_buffer>
  : false_type
{
};

template <typename T>
struct is_dynamic_buffer_class
  : integral_constant<bool,
      sizeof(size_memfn_helper<T>(0)) != 1 &&
      sizeof(max_size_memfn_helper<T>(0)) != 1 &&
      sizeof(capacity_memfn_helper<T>(0)) != 1 &&
      sizeof(data_memfn_helper<T>(0)) != 1 &&
      sizeof(consume_memfn_helper<T>(0)) != 1 &&
      sizeof(prepare_memfn_helper<T>(0)) != 1 &&
      sizeof(commit_memfn_helper<T>(0)) != 1 &&
      sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
      sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
{
};

template <typename T>
struct is_dynamic_buffer
  : conditional<is_class<T>::value,
      is_dynamic_buffer_class<T>,
      false_type>::type
{
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 240 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/is_buffer_sequence.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/string_view.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/string_view.hpp" 3 4
namespace boost {
namespace asio {


using std::basic_string_view;
using std::string_view;





}
}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 2 3 4
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 2 3 4

namespace boost {
namespace asio {

class mutable_buffer;
class const_buffer;
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
class mutable_buffer
{
public:

  mutable_buffer() noexcept
    : data_(0),
      size_(0)
  {
  }


  mutable_buffer(void* data, std::size_t size) noexcept
    : data_(data),
      size_(size)
  {
  }
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  void* data() const noexcept
  {




    return data_;
  }


  std::size_t size() const noexcept
  {
    return size_;
  }


  mutable_buffer& operator+=(std::size_t n) noexcept
  {
    std::size_t offset = n < size_ ? n : size_;
    data_ = static_cast<char*>(data_) + offset;
    size_ -= offset;
    return *this;
  }

private:
  void* data_;
  std::size_t size_;




};





class mutable_buffers_1
  : public mutable_buffer
{
public:

  typedef mutable_buffer value_type;


  typedef const mutable_buffer* const_iterator;


  mutable_buffers_1(void* data, std::size_t size) noexcept
    : mutable_buffer(data, size)
  {
  }
# 186 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  explicit mutable_buffers_1(const mutable_buffer& b) noexcept
    : mutable_buffer(b)
  {
  }


  const_iterator begin() const noexcept
  {
    return this;
  }


  const_iterator end() const noexcept
  {
    return begin() + 1;
  }
};
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
class const_buffer
{
public:

  const_buffer() noexcept
    : data_(0),
      size_(0)
  {
  }


  const_buffer(const void* data, std::size_t size) noexcept
    : data_(data),
      size_(size)
  {
  }


  const_buffer(const mutable_buffer& b) noexcept
    : data_(b.data()),
      size_(b.size())



  {
  }
# 268 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  const void* data() const noexcept
  {




    return data_;
  }


  std::size_t size() const noexcept
  {
    return size_;
  }


  const_buffer& operator+=(std::size_t n) noexcept
  {
    std::size_t offset = n < size_ ? n : size_;
    data_ = static_cast<const char*>(data_) + offset;
    size_ -= offset;
    return *this;
  }

private:
  const void* data_;
  std::size_t size_;




};





class const_buffers_1
  : public const_buffer
{
public:

  typedef const_buffer value_type;


  typedef const const_buffer* const_iterator;


  const_buffers_1(const void* data, std::size_t size) noexcept
    : const_buffer(data, size)
  {
  }
# 330 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  explicit const_buffers_1(const const_buffer& b) noexcept
    : const_buffer(b)
  {
  }


  const_iterator begin() const noexcept
  {
    return this;
  }


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





template <typename T>
struct is_mutable_buffer_sequence



  : boost::asio::detail::is_buffer_sequence<T, mutable_buffer>

{
};



template <typename T>
struct is_const_buffer_sequence



  : boost::asio::detail::is_buffer_sequence<T, const_buffer>

{
};


template <typename T>
struct is_dynamic_buffer



  : boost::asio::detail::is_dynamic_buffer<T>

{
};




class null_buffers
{
public:

  typedef mutable_buffer value_type;


  typedef const mutable_buffer* const_iterator;


  const_iterator begin() const noexcept
  {
    return &buf_;
  }


  const_iterator end() const noexcept
  {
    return &buf_;
  }

private:
  mutable_buffer buf_;
};
# 421 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
inline const mutable_buffer* buffer_sequence_begin(const mutable_buffer& b)
{
  return &b;
}


inline const const_buffer* buffer_sequence_begin(const const_buffer& b)
{
  return &b;
}




template <typename C>
inline auto buffer_sequence_begin(C& c) -> decltype(c.begin())
{
  return c.begin();
}


template <typename C>
inline auto buffer_sequence_begin(const C& c) -> decltype(c.begin())
{
  return c.begin();
}
# 474 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
inline const mutable_buffer* buffer_sequence_end(const mutable_buffer& b)
{
  return &b + 1;
}


inline const const_buffer* buffer_sequence_end(const const_buffer& b)
{
  return &b + 1;
}




template <typename C>
inline auto buffer_sequence_end(C& c) -> decltype(c.end())
{
  return c.end();
}


template <typename C>
inline auto buffer_sequence_end(const C& c) -> decltype(c.end())
{
  return c.end();
}
# 519 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
namespace detail {


struct one_buffer {};
struct multiple_buffers {};


template <typename BufferSequence>
struct buffer_sequence_cardinality :
  conditional<
    is_same<BufferSequence, mutable_buffer>::value

      || is_same<BufferSequence, mutable_buffers_1>::value
      || is_same<BufferSequence, const_buffers_1>::value

      || is_same<BufferSequence, const_buffer>::value,
    one_buffer, multiple_buffers>::type {};

template <typename Iterator>
inline std::size_t buffer_size(one_buffer,
    Iterator begin, Iterator) noexcept
{
  return const_buffer(*begin).size();
}

template <typename Iterator>
inline std::size_t buffer_size(multiple_buffers,
    Iterator begin, Iterator end) noexcept
{
  std::size_t total_buffer_size = 0;

  Iterator iter = begin;
  for (; iter != end; ++iter)
  {
    const_buffer b(*iter);
    total_buffer_size += b.size();
  }

  return total_buffer_size;
}

}
# 580 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename BufferSequence>
inline std::size_t buffer_size(const BufferSequence& b) noexcept
{
  return detail::buffer_size(
      detail::buffer_sequence_cardinality<BufferSequence>(),
      boost::asio::buffer_sequence_begin(b),
      boost::asio::buffer_sequence_end(b));
}
# 615 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PointerToPodType>
inline PointerToPodType buffer_cast(const mutable_buffer& b) noexcept
{
  return static_cast<PointerToPodType>(b.data());
}


template <typename PointerToPodType>
inline PointerToPodType buffer_cast(const const_buffer& b) noexcept
{
  return static_cast<PointerToPodType>(b.data());
}
# 636 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
inline mutable_buffer operator+(const mutable_buffer& b,
    std::size_t n) noexcept
{
  std::size_t offset = n < b.size() ? n : b.size();
  char* new_data = static_cast<char*>(b.data()) + offset;
  std::size_t new_size = b.size() - offset;
  return mutable_buffer(new_data, new_size



      );
}





inline mutable_buffer operator+(std::size_t n,
    const mutable_buffer& b) noexcept
{
  return b + n;
}





inline const_buffer operator+(const const_buffer& b,
    std::size_t n) noexcept
{
  std::size_t offset = n < b.size() ? n : b.size();
  const char* new_data = static_cast<const char*>(b.data()) + offset;
  std::size_t new_size = b.size() - offset;
  return const_buffer(new_data, new_size



      );
}





inline const_buffer operator+(std::size_t n,
    const const_buffer& b) noexcept
{
  return b + n;
}
# 895 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
inline mutable_buffers_1 buffer(
    const mutable_buffer& b) noexcept
{
  return mutable_buffers_1(b);
}
# 908 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
inline mutable_buffers_1 buffer(const mutable_buffer& b,
    std::size_t max_size_in_bytes) noexcept
{
  return mutable_buffers_1(
      mutable_buffer(b.data(),
        b.size() < max_size_in_bytes
        ? b.size() : max_size_in_bytes



        ));
}





inline const_buffers_1 buffer(
    const const_buffer& b) noexcept
{
  return const_buffers_1(b);
}
# 938 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
inline const_buffers_1 buffer(const const_buffer& b,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(b.data(),
      b.size() < max_size_in_bytes
      ? b.size() : max_size_in_bytes



      );
}





inline mutable_buffers_1 buffer(void* data,
    std::size_t size_in_bytes) noexcept
{
  return mutable_buffers_1(data, size_in_bytes);
}





inline const_buffers_1 buffer(const void* data,
    std::size_t size_in_bytes) noexcept
{
  return const_buffers_1(data, size_in_bytes);
}
# 977 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline mutable_buffers_1 buffer(PodType (&data)[N]) noexcept
{
  return mutable_buffers_1(data, N * sizeof(PodType));
}
# 990 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline mutable_buffers_1 buffer(PodType (&data)[N],
    std::size_t max_size_in_bytes) noexcept
{
  return mutable_buffers_1(data,
      N * sizeof(PodType) < max_size_in_bytes
      ? N * sizeof(PodType) : max_size_in_bytes);
}
# 1006 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(
    const PodType (&data)[N]) noexcept
{
  return const_buffers_1(data, N * sizeof(PodType));
}
# 1020 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(const PodType (&data)[N],
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data,
      N * sizeof(PodType) < max_size_in_bytes
      ? N * sizeof(PodType) : max_size_in_bytes);
}
# 1106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline mutable_buffers_1 buffer(
    boost::array<PodType, N>& data) noexcept
{
  return mutable_buffers_1(
      data.c_array(), data.size() * sizeof(PodType));
}
# 1121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline mutable_buffers_1 buffer(boost::array<PodType, N>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return mutable_buffers_1(data.c_array(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}
# 1137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(
    boost::array<const PodType, N>& data) noexcept
{
  return const_buffers_1(data.data(), data.size() * sizeof(PodType));
}
# 1151 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(boost::array<const PodType, N>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}
# 1169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(
    const boost::array<PodType, N>& data) noexcept
{
  return const_buffers_1(data.data(), data.size() * sizeof(PodType));
}
# 1183 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(const boost::array<PodType, N>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}
# 1201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline mutable_buffers_1 buffer(
    std::array<PodType, N>& data) noexcept
{
  return mutable_buffers_1(data.data(), data.size() * sizeof(PodType));
}
# 1215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline mutable_buffers_1 buffer(std::array<PodType, N>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return mutable_buffers_1(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}
# 1231 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(
    std::array<const PodType, N>& data) noexcept
{
  return const_buffers_1(data.data(), data.size() * sizeof(PodType));
}
# 1245 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(std::array<const PodType, N>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}
# 1261 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(
    const std::array<PodType, N>& data) noexcept
{
  return const_buffers_1(data.data(), data.size() * sizeof(PodType));
}
# 1275 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, std::size_t N>
inline const_buffers_1 buffer(const std::array<PodType, N>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data.data(),
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes);
}
# 1296 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, typename Allocator>
inline mutable_buffers_1 buffer(
    std::vector<PodType, Allocator>& data) noexcept
{
  return mutable_buffers_1(
      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)





      );
}
# 1320 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, typename Allocator>
inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return mutable_buffers_1(data.size() ? &data[0] : 0,
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes





      );
}
# 1345 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, typename Allocator>
inline const_buffers_1 buffer(
    const std::vector<PodType, Allocator>& data) noexcept
{
  return const_buffers_1(
      data.size() ? &data[0] : 0, data.size() * sizeof(PodType)





      );
}
# 1369 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename PodType, typename Allocator>
inline const_buffers_1 buffer(
    const std::vector<PodType, Allocator>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data.size() ? &data[0] : 0,
      data.size() * sizeof(PodType) < max_size_in_bytes
      ? data.size() * sizeof(PodType) : max_size_in_bytes





      );
}
# 1393 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits, typename Allocator>
inline mutable_buffers_1 buffer(
    std::basic_string<Elem, Traits, Allocator>& data) noexcept
{
  return mutable_buffers_1(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem)





      );
}
# 1417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits, typename Allocator>
inline mutable_buffers_1 buffer(
    std::basic_string<Elem, Traits, Allocator>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return mutable_buffers_1(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem) < max_size_in_bytes
      ? data.size() * sizeof(Elem) : max_size_in_bytes





      );
}
# 1440 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits, typename Allocator>
inline const_buffers_1 buffer(
    const std::basic_string<Elem, Traits, Allocator>& data) noexcept
{
  return const_buffers_1(data.data(), data.size() * sizeof(Elem)





      );
}
# 1463 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits, typename Allocator>
inline const_buffers_1 buffer(
    const std::basic_string<Elem, Traits, Allocator>& data,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data.data(),
      data.size() * sizeof(Elem) < max_size_in_bytes
      ? data.size() * sizeof(Elem) : max_size_in_bytes





      );
}
# 1487 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits>
inline const_buffers_1 buffer(
    basic_string_view<Elem, Traits> data) noexcept
{
  return const_buffers_1(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem)





      );
}
# 1508 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits>
inline const_buffers_1 buffer(
    basic_string_view<Elem, Traits> data,
    std::size_t max_size_in_bytes) noexcept
{
  return const_buffers_1(data.size() ? &data[0] : 0,
      data.size() * sizeof(Elem) < max_size_in_bytes
      ? data.size() * sizeof(Elem) : max_size_in_bytes





      );
}
# 1533 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits, typename Allocator>
class dynamic_string_buffer
{
public:

  typedef const_buffers_1 const_buffers_type;


  typedef mutable_buffers_1 mutable_buffers_type;
# 1553 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  explicit dynamic_string_buffer(std::basic_string<Elem, Traits, Allocator>& s,
      std::size_t maximum_size =
        (std::numeric_limits<std::size_t>::max)()) noexcept
    : string_(s),
      size_(string_.size()),
      max_size_(maximum_size)
  {
  }



  dynamic_string_buffer(dynamic_string_buffer&& other) noexcept
    : string_(other.string_),
      size_(other.size_),
      max_size_(other.max_size_)
  {
  }



  std::size_t size() const noexcept
  {
    return size_;
  }






  std::size_t max_size() const noexcept
  {
    return max_size_;
  }






  std::size_t capacity() const noexcept
  {
    return string_.capacity();
  }
# 1608 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  const_buffers_type data() const noexcept
  {
    return const_buffers_type(boost::asio::buffer(string_, size_));
  }
# 1629 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  mutable_buffers_type prepare(std::size_t n)
  {
    if (size () > max_size() || max_size() - size() < n)
    {
      std::length_error ex("dynamic_string_buffer too long");
      boost::asio::detail::throw_exception(ex);
    }

    string_.resize(size_ + n);

    return boost::asio::buffer(boost::asio::buffer(string_) + size_, n);
  }
# 1654 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  void commit(std::size_t n)
  {
    size_ += (std::min)(n, string_.size() - size_);
    string_.resize(size_);
  }
# 1667 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  void consume(std::size_t n)
  {
    std::size_t consume_length = (std::min)(n, size_);
    string_.erase(0, consume_length);
    size_ -= consume_length;
  }

private:
  std::basic_string<Elem, Traits, Allocator>& string_;
  std::size_t size_;
  const std::size_t max_size_;
};





template <typename Elem, typename Allocator>
class dynamic_vector_buffer
{
public:

  typedef const_buffers_1 const_buffers_type;


  typedef mutable_buffers_1 mutable_buffers_type;
# 1704 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  explicit dynamic_vector_buffer(std::vector<Elem, Allocator>& v,
      std::size_t maximum_size =
        (std::numeric_limits<std::size_t>::max)()) noexcept
    : vector_(v),
      size_(vector_.size()),
      max_size_(maximum_size)
  {
  }



  dynamic_vector_buffer(dynamic_vector_buffer&& other) noexcept
    : vector_(other.vector_),
      size_(other.size_),
      max_size_(other.max_size_)
  {
  }



  std::size_t size() const noexcept
  {
    return size_;
  }






  std::size_t max_size() const noexcept
  {
    return max_size_;
  }






  std::size_t capacity() const noexcept
  {
    return vector_.capacity();
  }
# 1759 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  const_buffers_type data() const noexcept
  {
    return const_buffers_type(boost::asio::buffer(vector_, size_));
  }
# 1780 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  mutable_buffers_type prepare(std::size_t n)
  {
    if (size () > max_size() || max_size() - size() < n)
    {
      std::length_error ex("dynamic_vector_buffer too long");
      boost::asio::detail::throw_exception(ex);
    }

    vector_.resize(size_ + n);

    return boost::asio::buffer(boost::asio::buffer(vector_) + size_, n);
  }
# 1805 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  void commit(std::size_t n)
  {
    size_ += (std::min)(n, vector_.size() - size_);
    vector_.resize(size_);
  }
# 1818 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
  void consume(std::size_t n)
  {
    std::size_t consume_length = (std::min)(n, size_);
    vector_.erase(vector_.begin(), vector_.begin() + consume_length);
    size_ -= consume_length;
  }

private:
  std::vector<Elem, Allocator>& vector_;
  std::size_t size_;
  const std::size_t max_size_;
};
# 1842 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename Elem, typename Traits, typename Allocator>
inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
    std::basic_string<Elem, Traits, Allocator>& data) noexcept
{
  return dynamic_string_buffer<Elem, Traits, Allocator>(data);
}






template <typename Elem, typename Traits, typename Allocator>
inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
    std::basic_string<Elem, Traits, Allocator>& data,
    std::size_t max_size) noexcept
{
  return dynamic_string_buffer<Elem, Traits, Allocator>(data, max_size);
}





template <typename Elem, typename Allocator>
inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
    std::vector<Elem, Allocator>& data) noexcept
{
  return dynamic_vector_buffer<Elem, Allocator>(data);
}





template <typename Elem, typename Allocator>
inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
    std::vector<Elem, Allocator>& data,
    std::size_t max_size) noexcept
{
  return dynamic_vector_buffer<Elem, Allocator>(data, max_size);
}
# 1915 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
namespace detail {

inline std::size_t buffer_copy_1(const mutable_buffer& target,
    const const_buffer& source)
{
  using namespace std;
  std::size_t target_size = target.size();
  std::size_t source_size = source.size();
  std::size_t n = target_size < source_size ? target_size : source_size;
  if (n > 0)
    memcpy(target.data(), source.data(), n);
  return n;
}

template <typename TargetIterator, typename SourceIterator>
inline std::size_t buffer_copy(one_buffer, one_buffer,
    TargetIterator target_begin, TargetIterator,
    SourceIterator source_begin, SourceIterator) noexcept
{
  return (buffer_copy_1)(*target_begin, *source_begin);
}

template <typename TargetIterator, typename SourceIterator>
inline std::size_t buffer_copy(one_buffer, one_buffer,
    TargetIterator target_begin, TargetIterator,
    SourceIterator source_begin, SourceIterator,
    std::size_t max_bytes_to_copy) noexcept
{
  return (buffer_copy_1)(*target_begin,
      boost::asio::buffer(*source_begin, max_bytes_to_copy));
}

template <typename TargetIterator, typename SourceIterator>
std::size_t buffer_copy(one_buffer, multiple_buffers,
    TargetIterator target_begin, TargetIterator,
    SourceIterator source_begin, SourceIterator source_end,
    std::size_t max_bytes_to_copy
      = (std::numeric_limits<std::size_t>::max)()) noexcept
{
  std::size_t total_bytes_copied = 0;
  SourceIterator source_iter = source_begin;

  for (mutable_buffer target_buffer(
        boost::asio::buffer(*target_begin, max_bytes_to_copy));
      target_buffer.size() && source_iter != source_end; ++source_iter)
  {
    const_buffer source_buffer(*source_iter);
    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
    total_bytes_copied += bytes_copied;
    target_buffer += bytes_copied;
  }

  return total_bytes_copied;
}

template <typename TargetIterator, typename SourceIterator>
std::size_t buffer_copy(multiple_buffers, one_buffer,
    TargetIterator target_begin, TargetIterator target_end,
    SourceIterator source_begin, SourceIterator,
    std::size_t max_bytes_to_copy
      = (std::numeric_limits<std::size_t>::max)()) noexcept
{
  std::size_t total_bytes_copied = 0;
  TargetIterator target_iter = target_begin;

  for (const_buffer source_buffer(
        boost::asio::buffer(*source_begin, max_bytes_to_copy));
      source_buffer.size() && target_iter != target_end; ++target_iter)
  {
    mutable_buffer target_buffer(*target_iter);
    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
    total_bytes_copied += bytes_copied;
    source_buffer += bytes_copied;
  }

  return total_bytes_copied;
}

template <typename TargetIterator, typename SourceIterator>
std::size_t buffer_copy(multiple_buffers, multiple_buffers,
    TargetIterator target_begin, TargetIterator target_end,
    SourceIterator source_begin, SourceIterator source_end) noexcept
{
  std::size_t total_bytes_copied = 0;

  TargetIterator target_iter = target_begin;
  std::size_t target_buffer_offset = 0;

  SourceIterator source_iter = source_begin;
  std::size_t source_buffer_offset = 0;

  while (target_iter != target_end && source_iter != source_end)
  {
    mutable_buffer target_buffer =
      mutable_buffer(*target_iter) + target_buffer_offset;

    const_buffer source_buffer =
      const_buffer(*source_iter) + source_buffer_offset;

    std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
    total_bytes_copied += bytes_copied;

    if (bytes_copied == target_buffer.size())
    {
      ++target_iter;
      target_buffer_offset = 0;
    }
    else
      target_buffer_offset += bytes_copied;

    if (bytes_copied == source_buffer.size())
    {
      ++source_iter;
      source_buffer_offset = 0;
    }
    else
      source_buffer_offset += bytes_copied;
  }

  return total_bytes_copied;
}

template <typename TargetIterator, typename SourceIterator>
std::size_t buffer_copy(multiple_buffers, multiple_buffers,
    TargetIterator target_begin, TargetIterator target_end,
    SourceIterator source_begin, SourceIterator source_end,
    std::size_t max_bytes_to_copy) noexcept
{
  std::size_t total_bytes_copied = 0;

  TargetIterator target_iter = target_begin;
  std::size_t target_buffer_offset = 0;

  SourceIterator source_iter = source_begin;
  std::size_t source_buffer_offset = 0;

  while (total_bytes_copied != max_bytes_to_copy
      && target_iter != target_end && source_iter != source_end)
  {
    mutable_buffer target_buffer =
      mutable_buffer(*target_iter) + target_buffer_offset;

    const_buffer source_buffer =
      const_buffer(*source_iter) + source_buffer_offset;

    std::size_t bytes_copied = (buffer_copy_1)(
        target_buffer, boost::asio::buffer(source_buffer,
          max_bytes_to_copy - total_bytes_copied));
    total_bytes_copied += bytes_copied;

    if (bytes_copied == target_buffer.size())
    {
      ++target_iter;
      target_buffer_offset = 0;
    }
    else
      target_buffer_offset += bytes_copied;

    if (bytes_copied == source_buffer.size())
    {
      ++source_iter;
      source_buffer_offset = 0;
    }
    else
      source_buffer_offset += bytes_copied;
  }

  return total_bytes_copied;
}

}
# 2106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename MutableBufferSequence, typename ConstBufferSequence>
inline std::size_t buffer_copy(const MutableBufferSequence& target,
    const ConstBufferSequence& source) noexcept
{
  return detail::buffer_copy(
      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
      boost::asio::buffer_sequence_begin(target),
      boost::asio::buffer_sequence_end(target),
      boost::asio::buffer_sequence_begin(source),
      boost::asio::buffer_sequence_end(source));
}
# 2143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 3 4
template <typename MutableBufferSequence, typename ConstBufferSequence>
inline std::size_t buffer_copy(const MutableBufferSequence& target,
    const ConstBufferSequence& source,
    std::size_t max_bytes_to_copy) noexcept
{
  return detail::buffer_copy(
      detail::buffer_sequence_cardinality<MutableBufferSequence>(),
      detail::buffer_sequence_cardinality<ConstBufferSequence>(),
      boost::asio::buffer_sequence_begin(target),
      boost::asio::buffer_sequence_end(target),
      boost::asio::buffer_sequence_begin(source),
      boost::asio::buffer_sequence_end(source), max_bytes_to_copy);
}



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 2163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffer.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_sequence_adapter.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_sequence_adapter.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class buffer_sequence_adapter_base
{
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_sequence_adapter.hpp" 3 4
public:

  enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };

protected:
  typedef iovec native_buffer_type;

  static void init_iov_base(void*& base, void* addr)
  {
    base = addr;
  }

  template <typename T>
  static void init_iov_base(T& base, void* addr)
  {
    base = static_cast<T>(addr);
  }

  static void init_native_buffer(iovec& iov,
      const boost::asio::mutable_buffer& buffer)
  {
    init_iov_base(iov.iov_base, buffer.data());
    iov.iov_len = buffer.size();
  }

  static void init_native_buffer(iovec& iov,
      const boost::asio::const_buffer& buffer)
  {
    init_iov_base(iov.iov_base, const_cast<void*>(buffer.data()));
    iov.iov_len = buffer.size();
  }

};


template <typename Buffer, typename Buffers>
class buffer_sequence_adapter
  : buffer_sequence_adapter_base
{
public:
  explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
    : count_(0), total_buffer_size_(0)
  {
    buffer_sequence_adapter::init(
        boost::asio::buffer_sequence_begin(buffer_sequence),
        boost::asio::buffer_sequence_end(buffer_sequence));
  }

  native_buffer_type* buffers()
  {
    return buffers_;
  }

  std::size_t count() const
  {
    return count_;
  }

  std::size_t total_size() const
  {
    return total_buffer_size_;
  }

  bool all_empty() const
  {
    return total_buffer_size_ == 0;
  }

  static bool all_empty(const Buffers& buffer_sequence)
  {
    return buffer_sequence_adapter::all_empty(
        boost::asio::buffer_sequence_begin(buffer_sequence),
        boost::asio::buffer_sequence_end(buffer_sequence));
  }

  static void validate(const Buffers& buffer_sequence)
  {
    buffer_sequence_adapter::validate(
        boost::asio::buffer_sequence_begin(buffer_sequence),
        boost::asio::buffer_sequence_end(buffer_sequence));
  }

  static Buffer first(const Buffers& buffer_sequence)
  {
    return buffer_sequence_adapter::first(
        boost::asio::buffer_sequence_begin(buffer_sequence),
        boost::asio::buffer_sequence_end(buffer_sequence));
  }

private:
  template <typename Iterator>
  void init(Iterator begin, Iterator end)
  {
    Iterator iter = begin;
    for (; iter != end && count_ < max_buffers; ++iter, ++count_)
    {
      Buffer buffer(*iter);
      init_native_buffer(buffers_[count_], buffer);
      total_buffer_size_ += buffer.size();
    }
  }

  template <typename Iterator>
  static bool all_empty(Iterator begin, Iterator end)
  {
    Iterator iter = begin;
    std::size_t i = 0;
    for (; iter != end && i < max_buffers; ++iter, ++i)
      if (Buffer(*iter).size() > 0)
        return false;
    return true;
  }

  template <typename Iterator>
  static void validate(Iterator begin, Iterator end)
  {
    Iterator iter = begin;
    for (; iter != end; ++iter)
    {
      Buffer buffer(*iter);
      buffer.data();
    }
  }

  template <typename Iterator>
  static Buffer first(Iterator begin, Iterator end)
  {
    Iterator iter = begin;
    for (; iter != end; ++iter)
    {
      Buffer buffer(*iter);
      if (buffer.size() != 0)
        return buffer;
    }
    return Buffer();
  }

  native_buffer_type buffers_[max_buffers];
  std::size_t count_;
  std::size_t total_buffer_size_;
};

template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffer>
  : buffer_sequence_adapter_base
{
public:
  explicit buffer_sequence_adapter(
      const boost::asio::mutable_buffer& buffer_sequence)
  {
    init_native_buffer(buffer_, Buffer(buffer_sequence));
    total_buffer_size_ = buffer_sequence.size();
  }

  native_buffer_type* buffers()
  {
    return &buffer_;
  }

  std::size_t count() const
  {
    return 1;
  }

  std::size_t total_size() const
  {
    return total_buffer_size_;
  }

  bool all_empty() const
  {
    return total_buffer_size_ == 0;
  }

  static bool all_empty(const boost::asio::mutable_buffer& buffer_sequence)
  {
    return buffer_sequence.size() == 0;
  }

  static void validate(const boost::asio::mutable_buffer& buffer_sequence)
  {
    buffer_sequence.data();
  }

  static Buffer first(const boost::asio::mutable_buffer& buffer_sequence)
  {
    return Buffer(buffer_sequence);
  }

private:
  native_buffer_type buffer_;
  std::size_t total_buffer_size_;
};

template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::const_buffer>
  : buffer_sequence_adapter_base
{
public:
  explicit buffer_sequence_adapter(
      const boost::asio::const_buffer& buffer_sequence)
  {
    init_native_buffer(buffer_, Buffer(buffer_sequence));
    total_buffer_size_ = buffer_sequence.size();
  }

  native_buffer_type* buffers()
  {
    return &buffer_;
  }

  std::size_t count() const
  {
    return 1;
  }

  std::size_t total_size() const
  {
    return total_buffer_size_;
  }

  bool all_empty() const
  {
    return total_buffer_size_ == 0;
  }

  static bool all_empty(const boost::asio::const_buffer& buffer_sequence)
  {
    return buffer_sequence.size() == 0;
  }

  static void validate(const boost::asio::const_buffer& buffer_sequence)
  {
    buffer_sequence.data();
  }

  static Buffer first(const boost::asio::const_buffer& buffer_sequence)
  {
    return Buffer(buffer_sequence);
  }

private:
  native_buffer_type buffer_;
  std::size_t total_buffer_size_;
};



template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
  : buffer_sequence_adapter_base
{
public:
  explicit buffer_sequence_adapter(
      const boost::asio::mutable_buffers_1& buffer_sequence)
  {
    init_native_buffer(buffer_, Buffer(buffer_sequence));
    total_buffer_size_ = buffer_sequence.size();
  }

  native_buffer_type* buffers()
  {
    return &buffer_;
  }

  std::size_t count() const
  {
    return 1;
  }

  std::size_t total_size() const
  {
    return total_buffer_size_;
  }

  bool all_empty() const
  {
    return total_buffer_size_ == 0;
  }

  static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
  {
    return buffer_sequence.size() == 0;
  }

  static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
  {
    buffer_sequence.data();
  }

  static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
  {
    return Buffer(buffer_sequence);
  }

private:
  native_buffer_type buffer_;
  std::size_t total_buffer_size_;
};

template <typename Buffer>
class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
  : buffer_sequence_adapter_base
{
public:
  explicit buffer_sequence_adapter(
      const boost::asio::const_buffers_1& buffer_sequence)
  {
    init_native_buffer(buffer_, Buffer(buffer_sequence));
    total_buffer_size_ = buffer_sequence.size();
  }

  native_buffer_type* buffers()
  {
    return &buffer_;
  }

  std::size_t count() const
  {
    return 1;
  }

  std::size_t total_size() const
  {
    return total_buffer_size_;
  }

  bool all_empty() const
  {
    return total_buffer_size_ == 0;
  }

  static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
  {
    return buffer_sequence.size() == 0;
  }

  static void validate(const boost::asio::const_buffers_1& buffer_sequence)
  {
    buffer_sequence.data();
  }

  static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
  {
    return Buffer(buffer_sequence);
  }

private:
  native_buffer_type buffer_;
  std::size_t total_buffer_size_;
};



template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
  : buffer_sequence_adapter_base
{
public:
  explicit buffer_sequence_adapter(
      const boost::array<Elem, 2>& buffer_sequence)
  {
    init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
    init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
    total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
  }

  native_buffer_type* buffers()
  {
    return buffers_;
  }

  std::size_t count() const
  {
    return 2;
  }

  std::size_t total_size() const
  {
    return total_buffer_size_;
  }

  bool all_empty() const
  {
    return total_buffer_size_ == 0;
  }

  static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
  {
    return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
  }

  static void validate(const boost::array<Elem, 2>& buffer_sequence)
  {
    buffer_sequence[0].data();
    buffer_sequence[1].data();
  }

  static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
  {
    return Buffer(buffer_sequence[0].size() != 0
        ? buffer_sequence[0] : buffer_sequence[1]);
  }

private:
  native_buffer_type buffers_[2];
  std::size_t total_buffer_size_;
};



template <typename Buffer, typename Elem>
class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
  : buffer_sequence_adapter_base
{
public:
  explicit buffer_sequence_adapter(
      const std::array<Elem, 2>& buffer_sequence)
  {
    init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
    init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
    total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
  }

  native_buffer_type* buffers()
  {
    return buffers_;
  }

  std::size_t count() const
  {
    return 2;
  }

  std::size_t total_size() const
  {
    return total_buffer_size_;
  }

  bool all_empty() const
  {
    return total_buffer_size_ == 0;
  }

  static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
  {
    return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
  }

  static void validate(const std::array<Elem, 2>& buffer_sequence)
  {
    buffer_sequence[0].data();
    buffer_sequence[1].data();
  }

  static Buffer first(const std::array<Elem, 2>& buffer_sequence)
  {
    return Buffer(buffer_sequence[0].size() != 0
        ? buffer_sequence[0] : buffer_sequence[1]);
  }

private:
  native_buffer_type buffers_[2];
  std::size_t total_buffer_size_;
};



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 541 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/buffer_sequence_adapter.ipp" 1 3 4
# 544 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_null_buffers_op.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_null_buffers_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_null_buffers_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler>
class reactive_null_buffers_op : public reactor_op
{
public:
  struct ptr { Handler* h; reactive_null_buffers_op* v; reactive_null_buffers_op* p; ~ptr() { reset(); } static reactive_null_buffers_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_null_buffers_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_null_buffers_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_null_buffers_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_null_buffers_op*>(v), 1); v = 0; } } };

  reactive_null_buffers_op(Handler& handler)
    : reactor_op(&reactive_null_buffers_op::do_perform,
        &reactive_null_buffers_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static status do_perform(reactor_op*)
  {
    return done;
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_null_buffers_op.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_accept_op.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_accept_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_holder.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_holder.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {


enum
{

  user_set_non_blocking = 1,


  internal_non_blocking = 2,


  non_blocking = user_set_non_blocking | internal_non_blocking,


  enable_connection_aborted = 4,


  user_set_linger = 8,


  stream_oriented = 16,


  datagram_oriented = 32,


  possible_dup = 64
};

typedef unsigned char state_type;

struct noop_deleter { void operator()(void*) {} };
typedef shared_ptr<void> shared_cancel_token_type;
typedef weak_ptr<void> weak_cancel_token_type;



inline socket_type accept(socket_type s, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec);

inline socket_type sync_accept(socket_type s,
    state_type state, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec);
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 3 4
inline bool non_blocking_accept(socket_type s,
    state_type state, socket_addr_type* addr, std::size_t* addrlen,
    boost::system::error_code& ec, socket_type& new_socket);



inline int bind(socket_type s, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec);

inline int close(socket_type s, state_type& state,
    bool destruction, boost::system::error_code& ec);

inline bool set_user_non_blocking(socket_type s,
    state_type& state, bool value, boost::system::error_code& ec);

inline bool set_internal_non_blocking(socket_type s,
    state_type& state, bool value, boost::system::error_code& ec);

inline int shutdown(socket_type s,
    int what, boost::system::error_code& ec);

inline int connect(socket_type s, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec);

inline void sync_connect(socket_type s, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec);
# 117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 3 4
inline bool non_blocking_connect(socket_type s,
    boost::system::error_code& ec);

inline int socketpair(int af, int type, int protocol,
    socket_type sv[2], boost::system::error_code& ec);

inline bool sockatmark(socket_type s, boost::system::error_code& ec);

inline size_t available(socket_type s, boost::system::error_code& ec);

inline int listen(socket_type s,
    int backlog, boost::system::error_code& ec);




typedef iovec buf;


inline void init_buf(buf& b, void* data, size_t size);

inline void init_buf(buf& b, const void* data, size_t size);

inline signed_size_type recv(socket_type s, buf* bufs,
    size_t count, int flags, boost::system::error_code& ec);

inline size_t sync_recv(socket_type s, state_type state, buf* bufs,
    size_t count, int flags, bool all_empty, boost::system::error_code& ec);
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 3 4
inline bool non_blocking_recv(socket_type s,
    buf* bufs, size_t count, int flags, bool is_stream,
    boost::system::error_code& ec, size_t& bytes_transferred);



inline signed_size_type recvfrom(socket_type s, buf* bufs,
    size_t count, int flags, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec);

inline size_t sync_recvfrom(socket_type s, state_type state,
    buf* bufs, size_t count, int flags, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec);
# 176 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 3 4
inline bool non_blocking_recvfrom(socket_type s,
    buf* bufs, size_t count, int flags,
    socket_addr_type* addr, std::size_t* addrlen,
    boost::system::error_code& ec, size_t& bytes_transferred);



inline signed_size_type recvmsg(socket_type s, buf* bufs,
    size_t count, int in_flags, int& out_flags,
    boost::system::error_code& ec);

inline size_t sync_recvmsg(socket_type s, state_type state,
    buf* bufs, size_t count, int in_flags, int& out_flags,
    boost::system::error_code& ec);
# 199 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 3 4
inline bool non_blocking_recvmsg(socket_type s,
    buf* bufs, size_t count, int in_flags, int& out_flags,
    boost::system::error_code& ec, size_t& bytes_transferred);



inline signed_size_type send(socket_type s, const buf* bufs,
    size_t count, int flags, boost::system::error_code& ec);

inline size_t sync_send(socket_type s, state_type state,
    const buf* bufs, size_t count, int flags,
    bool all_empty, boost::system::error_code& ec);
# 220 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 3 4
inline bool non_blocking_send(socket_type s,
    const buf* bufs, size_t count, int flags,
    boost::system::error_code& ec, size_t& bytes_transferred);



inline signed_size_type sendto(socket_type s, const buf* bufs,
    size_t count, int flags, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec);

inline size_t sync_sendto(socket_type s, state_type state,
    const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec);



inline bool non_blocking_sendto(socket_type s,
    const buf* bufs, size_t count, int flags,
    const socket_addr_type* addr, std::size_t addrlen,
    boost::system::error_code& ec, size_t& bytes_transferred);



inline socket_type socket(int af, int type, int protocol,
    boost::system::error_code& ec);

inline int setsockopt(socket_type s, state_type& state,
    int level, int optname, const void* optval,
    std::size_t optlen, boost::system::error_code& ec);

inline int getsockopt(socket_type s, state_type state,
    int level, int optname, void* optval,
    size_t* optlen, boost::system::error_code& ec);

inline int getpeername(socket_type s, socket_addr_type* addr,
    std::size_t* addrlen, bool cached, boost::system::error_code& ec);

inline int getsockname(socket_type s, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec);

inline int ioctl(socket_type s, state_type& state,
    int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);

inline int select(int nfds, fd_set* readfds, fd_set* writefds,
    fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);

inline int poll_read(socket_type s,
    state_type state, int msec, boost::system::error_code& ec);

inline int poll_write(socket_type s,
    state_type state, int msec, boost::system::error_code& ec);

inline int poll_error(socket_type s,
    state_type state, int msec, boost::system::error_code& ec);

inline int poll_connect(socket_type s,
    int msec, boost::system::error_code& ec);



inline const char* inet_ntop(int af, const void* src, char* dest,
    size_t length, unsigned long scope_id, boost::system::error_code& ec);

inline int inet_pton(int af, const char* src, void* dest,
    unsigned long* scope_id, boost::system::error_code& ec);

inline int gethostname(char* name,
    int namelen, boost::system::error_code& ec);



inline boost::system::error_code getaddrinfo(const char* host,
    const char* service, const addrinfo_type& hints,
    addrinfo_type** result, boost::system::error_code& ec);

inline boost::system::error_code background_getaddrinfo(
    const weak_cancel_token_type& cancel_token, const char* host,
    const char* service, const addrinfo_type& hints,
    addrinfo_type** result, boost::system::error_code& ec);

inline void freeaddrinfo(addrinfo_type* ai);

inline boost::system::error_code getnameinfo(
    const socket_addr_type* addr, std::size_t addrlen,
    char* host, std::size_t hostlen, char* serv,
    std::size_t servlen, int flags, boost::system::error_code& ec);

inline boost::system::error_code sync_getnameinfo(
    const socket_addr_type* addr, std::size_t addrlen,
    char* host, std::size_t hostlen, char* serv,
    std::size_t servlen, int sock_type, boost::system::error_code& ec);

inline boost::system::error_code background_getnameinfo(
    const weak_cancel_token_type& cancel_token,
    const socket_addr_type* addr, std::size_t addrlen,
    char* host, std::size_t hostlen, char* serv,
    std::size_t servlen, int sock_type, boost::system::error_code& ec);



inline u_long_type network_to_host_long(u_long_type value);

inline u_long_type host_to_network_long(u_long_type value);

inline u_short_type network_to_host_short(u_short_type value);

inline u_short_type host_to_network_short(u_short_type value);

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
# 1 "/usr/include/c++/10/cctype" 1 3 4
# 39 "/usr/include/c++/10/cctype" 3 4
       
# 40 "/usr/include/c++/10/cctype" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
# 1 "/usr/include/c++/10/cstdio" 1 3 4
# 39 "/usr/include/c++/10/cstdio" 3 4
       
# 40 "/usr/include/c++/10/cstdio" 3
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
# 1 "/usr/include/c++/10/cstdlib" 1 3 4
# 39 "/usr/include/c++/10/cstdlib" 3 4
       
# 40 "/usr/include/c++/10/cstdlib" 3
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
# 1 "/usr/include/c++/10/cerrno" 1 3 4
# 39 "/usr/include/c++/10/cerrno" 3 4
       
# 40 "/usr/include/c++/10/cerrno" 3
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
namespace socket_ops {
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
inline void clear_last_error()
{



  (*__errno_location ()) = 0;

}



template <typename ReturnType>
inline ReturnType error_wrapper(ReturnType return_value,
    boost::system::error_code& ec)
{




  ec = boost::system::error_code((*__errno_location ()),
      boost::asio::error::get_system_category());

  return return_value;
}

template <typename SockLenType>
inline socket_type call_accept(SockLenType msghdr::*,
    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
{
  SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
  socket_type result = ::accept(s, addr, addrlen ? &tmp_addrlen : 0);
  if (addrlen)
    *addrlen = (std::size_t)tmp_addrlen;
  return result;
}

socket_type accept(socket_type s, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return invalid_socket;
  }

  clear_last_error();

  socket_type new_s = error_wrapper(call_accept(
        &msghdr::msg_namelen, s, addr, addrlen), ec);
  if (new_s == invalid_socket)
    return new_s;
# 129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  ec = boost::system::error_code();
  return new_s;
}

socket_type sync_accept(socket_type s, state_type state,
    socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec)
{

  for (;;)
  {

    socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);


    if (new_socket != invalid_socket)
      return new_socket;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
    {
      if (state & user_set_non_blocking)
        return invalid_socket;

    }
    else if (ec == boost::asio::error::connection_aborted)
    {
      if (state & enable_connection_aborted)
        return invalid_socket;

    }

    else if (ec.value() == 71)
    {
      if (state & enable_connection_aborted)
        return invalid_socket;

    }

    else
      return invalid_socket;


    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
      return invalid_socket;
  }
}
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
bool non_blocking_accept(socket_type s,
    state_type state, socket_addr_type* addr, std::size_t* addrlen,
    boost::system::error_code& ec, socket_type& new_socket)
{
  for (;;)
  {

    new_socket = socket_ops::accept(s, addr, addrlen, ec);


    if (new_socket != invalid_socket)
      return true;


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
    {

    }
    else if (ec == boost::asio::error::connection_aborted)
    {
      if (state & enable_connection_aborted)
        return true;

    }

    else if (ec.value() == 71)
    {
      if (state & enable_connection_aborted)
        return true;

    }

    else
      return true;

    return false;
  }
}



template <typename SockLenType>
inline int call_bind(SockLenType msghdr::*,
    socket_type s, const socket_addr_type* addr, std::size_t addrlen)
{
  return ::bind(s, addr, (SockLenType)addrlen);
}

int bind(socket_type s, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  clear_last_error();
  int result = error_wrapper(call_bind(
        &msghdr::msg_namelen, s, addr, addrlen), ec);
  if (result == 0)
    ec = boost::system::error_code();
  return result;
}

int close(socket_type s, state_type& state,
    bool destruction, boost::system::error_code& ec)
{
  int result = 0;
  if (s != invalid_socket)
  {



    if (destruction && (state & user_set_linger))
    {
      ::linger opt;
      opt.l_onoff = 0;
      opt.l_linger = 0;
      boost::system::error_code ignored_ec;
      socket_ops::setsockopt(s, state, 1,
          13, &opt, sizeof(opt), ignored_ec);
    }

    clear_last_error();



    result = error_wrapper(::close(s), ec);


    if (result != 0
        && (ec == boost::asio::error::would_block
          || ec == boost::asio::error::try_again))
    {
# 339 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
      ioctl_arg_type arg = 0;
      ::ioctl(s, 0x5421, &arg);


      state &= ~non_blocking;

      clear_last_error();



      result = error_wrapper(::close(s), ec);

    }
  }

  if (result == 0)
    ec = boost::system::error_code();
  return result;
}

bool set_user_non_blocking(socket_type s,
    state_type& state, bool value, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return false;
  }

  clear_last_error();
# 381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  ioctl_arg_type arg = (value ? 1 : 0);
  int result = error_wrapper(::ioctl(s, 0x5421, &arg), ec);


  if (result >= 0)
  {
    ec = boost::system::error_code();
    if (value)
      state |= user_set_non_blocking;
    else
    {



      state &= ~(user_set_non_blocking | internal_non_blocking);
    }
    return true;
  }

  return false;
}

bool set_internal_non_blocking(socket_type s,
    state_type& state, bool value, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return false;
  }

  if (!value && (state & user_set_non_blocking))
  {



    ec = boost::asio::error::invalid_argument;
    return false;
  }

  clear_last_error();
# 434 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  ioctl_arg_type arg = (value ? 1 : 0);
  int result = error_wrapper(::ioctl(s, 0x5421, &arg), ec);


  if (result >= 0)
  {
    ec = boost::system::error_code();
    if (value)
      state |= internal_non_blocking;
    else
      state &= ~internal_non_blocking;
    return true;
  }

  return false;
}

int shutdown(socket_type s, int what, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  clear_last_error();
  int result = error_wrapper(::shutdown(s, what), ec);
  if (result == 0)
    ec = boost::system::error_code();
  return result;
}

template <typename SockLenType>
inline int call_connect(SockLenType msghdr::*,
    socket_type s, const socket_addr_type* addr, std::size_t addrlen)
{
  return ::connect(s, addr, (SockLenType)addrlen);
}

int connect(socket_type s, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  clear_last_error();
  int result = error_wrapper(call_connect(
        &msghdr::msg_namelen, s, addr, addrlen), ec);
  if (result == 0)
    ec = boost::system::error_code();

  else if (ec == boost::asio::error::try_again)
    ec = boost::asio::error::no_buffer_space;

  return result;
}

void sync_connect(socket_type s, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec)
{

  socket_ops::connect(s, addr, addrlen, ec);
  if (ec != boost::asio::error::in_progress
      && ec != boost::asio::error::would_block)
  {

    return;
  }


  if (socket_ops::poll_connect(s, -1, ec) < 0)
    return;


  int connect_error = 0;
  size_t connect_error_len = sizeof(connect_error);
  if (socket_ops::getsockopt(s, 0, 1, 4,
        &connect_error, &connect_error_len, ec) == socket_error_retval)
    return;


  ec = boost::system::error_code(connect_error,
      boost::asio::error::get_system_category());
}
# 558 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
{
# 578 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  pollfd fds;
  fds.fd = s;
  fds.events = 0x004;
  fds.revents = 0;
  int ready = ::poll(&fds, 1, 0);



  if (ready == 0)
  {

    return false;
  }


  int connect_error = 0;
  size_t connect_error_len = sizeof(connect_error);
  if (socket_ops::getsockopt(s, 0, 1, 4,
        &connect_error, &connect_error_len, ec) == 0)
  {
    if (connect_error)
    {
      ec = boost::system::error_code(connect_error,
          boost::asio::error::get_system_category());
    }
    else
      ec = boost::system::error_code();
  }

  return true;
}

int socketpair(int af, int type, int protocol,
    socket_type sv[2], boost::system::error_code& ec)
{
# 621 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  clear_last_error();
  int result = error_wrapper(::socketpair(af, type, protocol, sv), ec);
  if (result == 0)
    ec = boost::system::error_code();
  return result;

}

bool sockatmark(socket_type s, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return false;
  }


  ioctl_arg_type value = 0;



  int result = error_wrapper(::ioctl(s, 0x8905, &value), ec);

  if (result == 0)
    ec = boost::system::error_code();

  if (ec.value() == 25)
    ec = boost::asio::error::not_socket;







  return ec ? false : value != 0;
}

size_t available(socket_type s, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }

  ioctl_arg_type value = 0;



  int result = error_wrapper(::ioctl(s, 0x541B, &value), ec);

  if (result == 0)
    ec = boost::system::error_code();

  if (ec.value() == 25)
    ec = boost::asio::error::not_socket;


  return ec ? static_cast<size_t>(0) : static_cast<size_t>(value);
}

int listen(socket_type s, int backlog, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  clear_last_error();
  int result = error_wrapper(::listen(s, backlog), ec);
  if (result == 0)
    ec = boost::system::error_code();
  return result;
}

inline void init_buf_iov_base(void*& base, void* addr)
{
  base = addr;
}

template <typename T>
inline void init_buf_iov_base(T& base, void* addr)
{
  base = static_cast<T>(addr);
}




typedef iovec buf;


void init_buf(buf& b, void* data, size_t size)
{




  init_buf_iov_base(b.iov_base, data);
  b.iov_len = size;

}

void init_buf(buf& b, const void* data, size_t size)
{




  init_buf_iov_base(b.iov_base, const_cast<void*>(data));
  b.iov_len = size;

}

inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
{
  name = addr;
}

inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
{
  name = const_cast<socket_addr_type*>(addr);
}

template <typename T>
inline void init_msghdr_msg_name(T& name, socket_addr_type* addr)
{
  name = reinterpret_cast<T>(addr);
}

template <typename T>
inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
{
  name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr));
}

signed_size_type recv(socket_type s, buf* bufs, size_t count,
    int flags, boost::system::error_code& ec)
{
  clear_last_error();
# 781 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  msghdr msg = msghdr();
  msg.msg_iov = bufs;
  msg.msg_iovlen = static_cast<int>(count);
  signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
  if (result >= 0)
    ec = boost::system::error_code();
  return result;

}

size_t sync_recv(socket_type s, state_type state, buf* bufs,
    size_t count, int flags, bool all_empty, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }


  if (all_empty && (state & stream_oriented))
  {
    ec = boost::system::error_code();
    return 0;
  }


  for (;;)
  {

    signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);


    if (bytes > 0)
      return bytes;


    if ((state & stream_oriented) && bytes == 0)
    {
      ec = boost::asio::error::eof;
      return 0;
    }


    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;


    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
      return 0;
  }
}
# 870 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
bool non_blocking_recv(socket_type s,
    buf* bufs, size_t count, int flags, bool is_stream,
    boost::system::error_code& ec, size_t& bytes_transferred)
{
  for (;;)
  {

    signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);


    if (is_stream && bytes == 0)
    {
      ec = boost::asio::error::eof;
      return true;
    }


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
      return false;


    if (bytes >= 0)
    {
      ec = boost::system::error_code();
      bytes_transferred = bytes;
    }
    else
      bytes_transferred = 0;

    return true;
  }
}



signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
    int flags, socket_addr_type* addr, std::size_t* addrlen,
    boost::system::error_code& ec)
{
  clear_last_error();
# 935 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  msghdr msg = msghdr();
  init_msghdr_msg_name(msg.msg_name, addr);
  msg.msg_namelen = static_cast<int>(*addrlen);
  msg.msg_iov = bufs;
  msg.msg_iovlen = static_cast<int>(count);
  signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
  *addrlen = msg.msg_namelen;
  if (result >= 0)
    ec = boost::system::error_code();
  return result;

}

size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
    size_t count, int flags, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }


  for (;;)
  {

    signed_size_type bytes = socket_ops::recvfrom(
        s, bufs, count, flags, addr, addrlen, ec);


    if (bytes >= 0)
      return bytes;


    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;


    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
      return 0;
  }
}
# 1007 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
bool non_blocking_recvfrom(socket_type s,
    buf* bufs, size_t count, int flags,
    socket_addr_type* addr, std::size_t* addrlen,
    boost::system::error_code& ec, size_t& bytes_transferred)
{
  for (;;)
  {

    signed_size_type bytes = socket_ops::recvfrom(
        s, bufs, count, flags, addr, addrlen, ec);


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
      return false;


    if (bytes >= 0)
    {
      ec = boost::system::error_code();
      bytes_transferred = bytes;
    }
    else
      bytes_transferred = 0;

    return true;
  }
}



signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
    int in_flags, int& out_flags, boost::system::error_code& ec)
{
  clear_last_error();




  msghdr msg = msghdr();
  msg.msg_iov = bufs;
  msg.msg_iovlen = static_cast<int>(count);
  signed_size_type result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
  if (result >= 0)
  {
    ec = boost::system::error_code();
    out_flags = msg.msg_flags;
  }
  else
    out_flags = 0;
  return result;

}

size_t sync_recvmsg(socket_type s, state_type state,
    buf* bufs, size_t count, int in_flags, int& out_flags,
    boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }


  for (;;)
  {

    signed_size_type bytes = socket_ops::recvmsg(
        s, bufs, count, in_flags, out_flags, ec);


    if (bytes >= 0)
      return bytes;


    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;


    if (socket_ops::poll_read(s, 0, -1, ec) < 0)
      return 0;
  }
}
# 1124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
bool non_blocking_recvmsg(socket_type s,
    buf* bufs, size_t count, int in_flags, int& out_flags,
    boost::system::error_code& ec, size_t& bytes_transferred)
{
  for (;;)
  {

    signed_size_type bytes = socket_ops::recvmsg(
        s, bufs, count, in_flags, out_flags, ec);


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
      return false;


    if (bytes >= 0)
    {
      ec = boost::system::error_code();
      bytes_transferred = bytes;
    }
    else
      bytes_transferred = 0;

    return true;
  }
}



signed_size_type send(socket_type s, const buf* bufs, size_t count,
    int flags, boost::system::error_code& ec)
{
  clear_last_error();
# 1178 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  msghdr msg = msghdr();
  msg.msg_iov = const_cast<buf*>(bufs);
  msg.msg_iovlen = static_cast<int>(count);

  flags |= MSG_NOSIGNAL;

  signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
  if (result >= 0)
    ec = boost::system::error_code();
  return result;

}

size_t sync_send(socket_type s, state_type state, const buf* bufs,
    size_t count, int flags, bool all_empty, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }


  if (all_empty && (state & stream_oriented))
  {
    ec = boost::system::error_code();
    return 0;
  }


  for (;;)
  {

    signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);


    if (bytes >= 0)
      return bytes;


    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;


    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
      return 0;
  }
}
# 1251 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
bool non_blocking_send(socket_type s,
    const buf* bufs, size_t count, int flags,
    boost::system::error_code& ec, size_t& bytes_transferred)
{
  for (;;)
  {

    signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
      return false;


    if (bytes >= 0)
    {
      ec = boost::system::error_code();
      bytes_transferred = bytes;
    }
    else
      bytes_transferred = 0;

    return true;
  }
}



signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
    int flags, const socket_addr_type* addr, std::size_t addrlen,
    boost::system::error_code& ec)
{
  clear_last_error();
# 1305 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  msghdr msg = msghdr();
  init_msghdr_msg_name(msg.msg_name, addr);
  msg.msg_namelen = static_cast<int>(addrlen);
  msg.msg_iov = const_cast<buf*>(bufs);
  msg.msg_iovlen = static_cast<int>(count);

  flags |= MSG_NOSIGNAL;

  signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
  if (result >= 0)
    ec = boost::system::error_code();
  return result;

}

size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
    size_t count, int flags, const socket_addr_type* addr,
    std::size_t addrlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }


  for (;;)
  {

    signed_size_type bytes = socket_ops::sendto(
        s, bufs, count, flags, addr, addrlen, ec);


    if (bytes >= 0)
      return bytes;


    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;


    if (socket_ops::poll_write(s, 0, -1, ec) < 0)
      return 0;
  }
}



bool non_blocking_sendto(socket_type s,
    const buf* bufs, size_t count, int flags,
    const socket_addr_type* addr, std::size_t addrlen,
    boost::system::error_code& ec, size_t& bytes_transferred)
{
  for (;;)
  {

    signed_size_type bytes = socket_ops::sendto(
        s, bufs, count, flags, addr, addrlen, ec);


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
      return false;


    if (bytes >= 0)
    {
      ec = boost::system::error_code();
      bytes_transferred = bytes;
    }
    else
      bytes_transferred = 0;

    return true;
  }
}



socket_type socket(int af, int type, int protocol,
    boost::system::error_code& ec)
{
  clear_last_error();
# 1429 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  int s = error_wrapper(::socket(af, type, protocol), ec);
  if (s >= 0)
    ec = boost::system::error_code();
  return s;

}

template <typename SockLenType>
inline int call_setsockopt(SockLenType msghdr::*,
    socket_type s, int level, int optname,
    const void* optval, std::size_t optlen)
{
  return ::setsockopt(s, level, optname,
      (const char*)optval, (SockLenType)optlen);
}

int setsockopt(socket_type s, state_type& state, int level, int optname,
    const void* optval, std::size_t optlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  if (level == custom_socket_option_level && optname == always_fail_option)
  {
    ec = boost::asio::error::invalid_argument;
    return socket_error_retval;
  }

  if (level == custom_socket_option_level
      && optname == enable_connection_aborted_option)
  {
    if (optlen != sizeof(int))
    {
      ec = boost::asio::error::invalid_argument;
      return socket_error_retval;
    }

    if (*static_cast<const int*>(optval))
      state |= enable_connection_aborted;
    else
      state &= ~enable_connection_aborted;
    ec = boost::system::error_code();
    return 0;
  }

  if (level == 1 && optname == 13)
    state |= user_set_linger;
# 1498 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  clear_last_error();
  int result = error_wrapper(call_setsockopt(&msghdr::msg_namelen,
        s, level, optname, optval, optlen), ec);
  if (result == 0)
  {
    ec = boost::system::error_code();
# 1516 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  }

  return result;

}

template <typename SockLenType>
inline int call_getsockopt(SockLenType msghdr::*,
    socket_type s, int level, int optname,
    void* optval, std::size_t* optlen)
{
  SockLenType tmp_optlen = (SockLenType)*optlen;
  int result = ::getsockopt(s, level, optname, (char*)optval, &tmp_optlen);
  *optlen = (std::size_t)tmp_optlen;
  return result;
}

int getsockopt(socket_type s, state_type state, int level, int optname,
    void* optval, size_t* optlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  if (level == custom_socket_option_level && optname == always_fail_option)
  {
    ec = boost::asio::error::invalid_argument;
    return socket_error_retval;
  }

  if (level == custom_socket_option_level
      && optname == enable_connection_aborted_option)
  {
    if (*optlen != sizeof(int))
    {
      ec = boost::asio::error::invalid_argument;
      return socket_error_retval;
    }

    *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
    ec = boost::system::error_code();
    return 0;
  }
# 1611 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  clear_last_error();
  int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
        s, level, optname, optval, optlen), ec);

  if (result == 0 && level == 1 && *optlen == sizeof(int)
      && (optname == 7 || optname == 8))
  {





    *static_cast<int*>(optval) /= 2;
  }

  if (result == 0)
    ec = boost::system::error_code();
  return result;

}

template <typename SockLenType>
inline int call_getpeername(SockLenType msghdr::*,
    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
{
  SockLenType tmp_addrlen = (SockLenType)*addrlen;
  int result = ::getpeername(s, addr, &tmp_addrlen);
  *addrlen = (std::size_t)tmp_addrlen;
  return result;
}

int getpeername(socket_type s, socket_addr_type* addr,
    std::size_t* addrlen, bool cached, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }
# 1675 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  (void)cached;



  clear_last_error();
  int result = error_wrapper(call_getpeername(
        &msghdr::msg_namelen, s, addr, addrlen), ec);
  if (result == 0)
    ec = boost::system::error_code();
  return result;
}

template <typename SockLenType>
inline int call_getsockname(SockLenType msghdr::*,
    socket_type s, socket_addr_type* addr, std::size_t* addrlen)
{
  SockLenType tmp_addrlen = (SockLenType)*addrlen;
  int result = ::getsockname(s, addr, &tmp_addrlen);
  *addrlen = (std::size_t)tmp_addrlen;
  return result;
}

int getsockname(socket_type s, socket_addr_type* addr,
    std::size_t* addrlen, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  clear_last_error();
  int result = error_wrapper(call_getsockname(
        &msghdr::msg_namelen, s, addr, addrlen), ec);
  if (result == 0)
    ec = boost::system::error_code();
  return result;
}

int ioctl(socket_type s, state_type& state, int cmd,
    ioctl_arg_type* arg, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }

  clear_last_error();







  int result = error_wrapper(::ioctl(s, cmd, arg), ec);

  if (result >= 0)
  {
    ec = boost::system::error_code();






    if (cmd == static_cast<int>(0x5421))
    {
      if (*arg)
      {
        state |= user_set_non_blocking;
      }
      else
      {



        state &= ~(user_set_non_blocking | internal_non_blocking);
      }
    }
  }

  return result;
}

int select(int nfds, fd_set* readfds, fd_set* writefds,
    fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
{
  clear_last_error();
# 1794 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  int result = error_wrapper(::select(nfds, readfds,
        writefds, exceptfds, timeout), ec);
  if (result >= 0)
    ec = boost::system::error_code();
  return result;

}

int poll_read(socket_type s, state_type state,
    int msec, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }
# 1838 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  pollfd fds;
  fds.fd = s;
  fds.events = 0x001;
  fds.revents = 0;
  int timeout = (state & user_set_non_blocking) ? 0 : msec;
  clear_last_error();
  int result = error_wrapper(::poll(&fds, 1, timeout), ec);



  if (result == 0)
    ec = (state & user_set_non_blocking)
      ? boost::asio::error::would_block : boost::system::error_code();
  else if (result > 0)
    ec = boost::system::error_code();
  return result;
}

int poll_write(socket_type s, state_type state,
    int msec, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }
# 1892 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  pollfd fds;
  fds.fd = s;
  fds.events = 0x004;
  fds.revents = 0;
  int timeout = (state & user_set_non_blocking) ? 0 : msec;
  clear_last_error();
  int result = error_wrapper(::poll(&fds, 1, timeout), ec);



  if (result == 0)
    ec = (state & user_set_non_blocking)
      ? boost::asio::error::would_block : boost::system::error_code();
  else if (result > 0)
    ec = boost::system::error_code();
  return result;
}

int poll_error(socket_type s, state_type state,
    int msec, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }
# 1946 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  pollfd fds;
  fds.fd = s;
  fds.events = 0x002 | 0x008 | 0x010;
  fds.revents = 0;
  int timeout = (state & user_set_non_blocking) ? 0 : msec;
  clear_last_error();
  int result = error_wrapper(::poll(&fds, 1, timeout), ec);



  if (result == 0)
    ec = (state & user_set_non_blocking)
      ? boost::asio::error::would_block : boost::system::error_code();
  else if (result > 0)
    ec = boost::system::error_code();
  return result;
}

int poll_connect(socket_type s, int msec, boost::system::error_code& ec)
{
  if (s == invalid_socket)
  {
    ec = boost::asio::error::bad_descriptor;
    return socket_error_retval;
  }
# 2000 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  pollfd fds;
  fds.fd = s;
  fds.events = 0x004;
  fds.revents = 0;
  clear_last_error();
  int result = error_wrapper(::poll(&fds, 1, msec), ec);
  if (result >= 0)
    ec = boost::system::error_code();
  return result;



}



const char* inet_ntop(int af, const void* src, char* dest, size_t length,
    unsigned long scope_id, boost::system::error_code& ec)
{
  clear_last_error();
# 2111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  const char* result = error_wrapper(::inet_ntop(
        af, src, dest, static_cast<int>(length)), ec);
  if (result == 0 && !ec)
    ec = boost::asio::error::invalid_argument;
  if (result != 0 && af == 10 && scope_id != 0)
  {
    using namespace std;
    char if_name[16 + 1] = "%";
    const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
    bool is_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xfe)
        && ((ipv6_address->__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
    bool is_multicast_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xff)
        && ((ipv6_address->__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
    if ((!is_link_local && !is_multicast_link_local)
        || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
      sprintf(if_name + 1, "%lu", scope_id);
    strcat(dest, if_name);
  }
  return result;

}

int inet_pton(int af, const char* src, void* dest,
    unsigned long* scope_id, boost::system::error_code& ec)
{
  clear_last_error();
# 2342 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  using namespace std;



  const bool is_v6 = (af == 10);
  const char* if_name = is_v6 ? strchr(src, '%') : 0;
  char src_buf[max_addr_v6_str_len + 1];
  const char* src_ptr = src;
  if (if_name != 0)
  {
    if (if_name - src > max_addr_v6_str_len)
    {
      ec = boost::asio::error::invalid_argument;
      return 0;
    }
    memcpy(src_buf, src, if_name - src);
    src_buf[if_name - src] = 0;
    src_ptr = src_buf;
  }

  int result = error_wrapper(::inet_pton(af, src_ptr, dest), ec);
  if (result <= 0 && !ec)
    ec = boost::asio::error::invalid_argument;
  if (result > 0 && is_v6 && scope_id)
  {
    using namespace std;
    *scope_id = 0;
    if (if_name != 0)
    {
      in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
      bool is_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xfe)
          && ((ipv6_address->__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
      bool is_multicast_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xff)
          && ((ipv6_address->__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
      if (is_link_local || is_multicast_link_local)
        *scope_id = if_nametoindex(if_name + 1);
      if (*scope_id == 0)
        *scope_id = atoi(if_name + 1);
    }
  }
  return result;

}

int gethostname(char* name, int namelen, boost::system::error_code& ec)
{
  clear_last_error();
# 2419 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  int result = error_wrapper(::gethostname(name, namelen), ec);




  return result;

}
# 3274 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
inline boost::system::error_code translate_addrinfo_error(int error)
{
  switch (error)
  {
  case 0:
    return boost::system::error_code();
  case -3:
    return boost::asio::error::host_not_found_try_again;
  case -1:
    return boost::asio::error::invalid_argument;
  case -4:
    return boost::asio::error::no_recovery;
  case -6:
    return boost::asio::error::address_family_not_supported;
  case -10:
    return boost::asio::error::no_memory;
  case -2:

  case -9:


  case -5:

    return boost::asio::error::host_not_found;
  case -8:
    return boost::asio::error::service_not_found;
  case -7:
    return boost::asio::error::socket_type_not_supported;
  default:




    return boost::system::error_code(
        (*__errno_location ()), boost::asio::error::get_system_category());

  }
}

boost::system::error_code getaddrinfo(const char* host,
    const char* service, const addrinfo_type& hints,
    addrinfo_type** result, boost::system::error_code& ec)
{
  host = (host && *host) ? host : 0;
  service = (service && *service) ? service : 0;
  clear_last_error();
# 3344 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  int error = ::getaddrinfo(host, service, &hints, result);
# 3376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  return ec = translate_addrinfo_error(error);

}

boost::system::error_code background_getaddrinfo(
    const weak_cancel_token_type& cancel_token, const char* host,
    const char* service, const addrinfo_type& hints,
    addrinfo_type** result, boost::system::error_code& ec)
{
  if (cancel_token.expired())
    ec = boost::asio::error::operation_aborted;
  else
    socket_ops::getaddrinfo(host, service, hints, result, ec);
  return ec;
}

void freeaddrinfo(addrinfo_type* ai)
{
# 3414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  ::freeaddrinfo(ai);

}

boost::system::error_code getnameinfo(const socket_addr_type* addr,
    std::size_t addrlen, char* host, std::size_t hostlen,
    char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
{
# 3458 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  clear_last_error();
  int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
  return ec = translate_addrinfo_error(error);

}

boost::system::error_code sync_getnameinfo(
    const socket_addr_type* addr, std::size_t addrlen,
    char* host, std::size_t hostlen, char* serv,
    std::size_t servlen, int sock_type, boost::system::error_code& ec)
{


  int flags = (sock_type == SOCK_DGRAM) ? 16 : 0;
  socket_ops::getnameinfo(addr, addrlen, host,
      hostlen, serv, servlen, flags, ec);
  if (ec)
  {
    socket_ops::getnameinfo(addr, addrlen, host, hostlen,
        serv, servlen, flags | 2, ec);
  }

  return ec;
}

boost::system::error_code background_getnameinfo(
    const weak_cancel_token_type& cancel_token,
    const socket_addr_type* addr, std::size_t addrlen,
    char* host, std::size_t hostlen, char* serv,
    std::size_t servlen, int sock_type, boost::system::error_code& ec)
{
  if (cancel_token.expired())
  {
    ec = boost::asio::error::operation_aborted;
  }
  else
  {


    int flags = (sock_type == SOCK_DGRAM) ? 16 : 0;
    socket_ops::getnameinfo(addr, addrlen, host,
        hostlen, serv, servlen, flags, ec);
    if (ec)
    {
      socket_ops::getnameinfo(addr, addrlen, host, hostlen,
          serv, servlen, flags | 2, ec);
    }
  }

  return ec;
}



u_long_type network_to_host_long(u_long_type value)
{
# 3522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  return __bswap_32 (value);

}

u_long_type host_to_network_long(u_long_type value)
{
# 3537 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
  return __bswap_32 (value);

}

u_short_type network_to_host_short(u_short_type value)
{






  return __bswap_16 (value);

}

u_short_type host_to_network_short(u_short_type value)
{







  return __bswap_16 (value);

}

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 3572 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
# 337 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_ops.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_holder.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_holder.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


class socket_holder
  : private noncopyable
{
public:

  socket_holder()
    : socket_(invalid_socket)
  {
  }


  explicit socket_holder(socket_type s)
    : socket_(s)
  {
  }


  ~socket_holder()
  {
    if (socket_ != invalid_socket)
    {
      boost::system::error_code ec;
      socket_ops::state_type state = 0;
      socket_ops::close(socket_, state, true, ec);
    }
  }


  socket_type get() const
  {
    return socket_;
  }


  void reset()
  {
    if (socket_ != invalid_socket)
    {
      boost::system::error_code ec;
      socket_ops::state_type state = 0;
      socket_ops::close(socket_, state, true, ec);
      socket_ = invalid_socket;
    }
  }


  void reset(socket_type s)
  {
    reset();
    socket_ = s;
  }


  socket_type release()
  {
    socket_type tmp = socket_;
    socket_ = invalid_socket;
    return tmp;
  }

private:

  socket_type socket_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/socket_holder.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Socket, typename Protocol>
class reactive_socket_accept_op_base : public reactor_op
{
public:
  reactive_socket_accept_op_base(socket_type socket,
      socket_ops::state_type state, Socket& peer, const Protocol& protocol,
      typename Protocol::endpoint* peer_endpoint, func_type complete_func)
    : reactor_op(&reactive_socket_accept_op_base::do_perform, complete_func),
      socket_(socket),
      state_(state),
      peer_(peer),
      protocol_(protocol),
      peer_endpoint_(peer_endpoint),
      addrlen_(peer_endpoint ? peer_endpoint->capacity() : 0)
  {
  }

  static status do_perform(reactor_op* base)
  {
    reactive_socket_accept_op_base* o(
        static_cast<reactive_socket_accept_op_base*>(base));

    socket_type new_socket = invalid_socket;
    status result = socket_ops::non_blocking_accept(o->socket_,
        o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
        o->peer_endpoint_ ? &o->addrlen_ : 0, o->ec_, new_socket)
    ? done : not_done;
    o->new_socket_.reset(new_socket);

    (void)0;

    return result;
  }

  void do_assign()
  {
    if (new_socket_.get() != invalid_socket)
    {
      if (peer_endpoint_)
        peer_endpoint_->resize(addrlen_);
      peer_.assign(protocol_, new_socket_.get(), ec_);
      if (!ec_)
        new_socket_.release();
    }
  }

private:
  socket_type socket_;
  socket_ops::state_type state_;
  socket_holder new_socket_;
  Socket& peer_;
  Protocol protocol_;
  typename Protocol::endpoint* peer_endpoint_;
  std::size_t addrlen_;
};

template <typename Socket, typename Protocol, typename Handler>
class reactive_socket_accept_op :
  public reactive_socket_accept_op_base<Socket, Protocol>
{
public:
  struct ptr { Handler* h; reactive_socket_accept_op* v; reactive_socket_accept_op* p; ~ptr() { reset(); } static reactive_socket_accept_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_accept_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_accept_op*>(v), 1); v = 0; } } };

  reactive_socket_accept_op(socket_type socket,
      socket_ops::state_type state, Socket& peer, const Protocol& protocol,
      typename Protocol::endpoint* peer_endpoint, Handler& handler)
    : reactive_socket_accept_op_base<Socket, Protocol>(socket, state, peer,
        protocol, peer_endpoint, &reactive_socket_accept_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);


    if (owner)
      o->do_assign();

    (void)0;







    detail::binder1<Handler, boost::system::error_code>
      handler(o->handler_, o->ec_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};



template <typename Protocol, typename Handler>
class reactive_socket_move_accept_op :
  private Protocol::socket,
  public reactive_socket_accept_op_base<typename Protocol::socket, Protocol>
{
public:
  struct ptr { Handler* h; reactive_socket_move_accept_op* v; reactive_socket_move_accept_op* p; ~ptr() { reset(); } static reactive_socket_move_accept_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_move_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_move_accept_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_move_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_move_accept_op*>(v), 1); v = 0; } } };

  reactive_socket_move_accept_op(io_context& ioc, socket_type socket,
      socket_ops::state_type state, const Protocol& protocol,
      typename Protocol::endpoint* peer_endpoint, Handler& handler)
    : Protocol::socket(ioc),
      reactive_socket_accept_op_base<typename Protocol::socket, Protocol>(
        socket, state, *this, protocol, peer_endpoint,
        &reactive_socket_move_accept_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_move_accept_op* o(
        static_cast<reactive_socket_move_accept_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);


    if (owner)
      o->do_assign();

    (void)0;







    detail::move_binder2<Handler,
      boost::system::error_code, typename Protocol::socket>
        handler(0, static_cast<Handler&&>(o->handler_), o->ec_,
          static_cast<typename Protocol::socket&&>(*o));
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 218 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_connect_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_connect_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_connect_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class reactive_socket_connect_op_base : public reactor_op
{
public:
  reactive_socket_connect_op_base(socket_type socket, func_type complete_func)
    : reactor_op(&reactive_socket_connect_op_base::do_perform, complete_func),
      socket_(socket)
  {
  }

  static status do_perform(reactor_op* base)
  {
    reactive_socket_connect_op_base* o(
        static_cast<reactive_socket_connect_op_base*>(base));

    status result = socket_ops::non_blocking_connect(
        o->socket_, o->ec_) ? done : not_done;

    (void)0;

    return result;
  }

private:
  socket_type socket_;
};

template <typename Handler>
class reactive_socket_connect_op : public reactive_socket_connect_op_base
{
public:
  struct ptr { Handler* h; reactive_socket_connect_op* v; reactive_socket_connect_op* p; ~ptr() { reset(); } static reactive_socket_connect_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_connect_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_connect_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_connect_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_connect_op*>(v), 1); v = 0; } } };

  reactive_socket_connect_op(socket_type socket, Handler& handler)
    : reactive_socket_connect_op_base(socket,
        &reactive_socket_connect_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_connect_op* o
      (static_cast<reactive_socket_connect_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder1<Handler, boost::system::error_code>
      handler(o->handler_, o->ec_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_connect_op.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename MutableBufferSequence, typename Endpoint>
class reactive_socket_recvfrom_op_base : public reactor_op
{
public:
  reactive_socket_recvfrom_op_base(socket_type socket, int protocol_type,
      const MutableBufferSequence& buffers, Endpoint& endpoint,
      socket_base::message_flags flags, func_type complete_func)
    : reactor_op(&reactive_socket_recvfrom_op_base::do_perform, complete_func),
      socket_(socket),
      protocol_type_(protocol_type),
      buffers_(buffers),
      sender_endpoint_(endpoint),
      flags_(flags)
  {
  }

  static status do_perform(reactor_op* base)
  {
    reactive_socket_recvfrom_op_base* o(
        static_cast<reactive_socket_recvfrom_op_base*>(base));

    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(o->buffers_);

    std::size_t addr_len = o->sender_endpoint_.capacity();
    status result = socket_ops::non_blocking_recvfrom(o->socket_,
        bufs.buffers(), bufs.count(), o->flags_,
        o->sender_endpoint_.data(), &addr_len,
        o->ec_, o->bytes_transferred_) ? done : not_done;

    if (result && !o->ec_)
      o->sender_endpoint_.resize(addr_len);

    (void)0
                                         ;

    return result;
  }

private:
  socket_type socket_;
  int protocol_type_;
  MutableBufferSequence buffers_;
  Endpoint& sender_endpoint_;
  socket_base::message_flags flags_;
};

template <typename MutableBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_recvfrom_op :
  public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
{
public:
  struct ptr { Handler* h; reactive_socket_recvfrom_op* v; reactive_socket_recvfrom_op* p; ~ptr() { reset(); } static reactive_socket_recvfrom_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvfrom_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_recvfrom_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvfrom_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_recvfrom_op*>(v), 1); v = 0; } } };

  reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
      const MutableBufferSequence& buffers, Endpoint& endpoint,
      socket_base::message_flags flags, Handler& handler)
    : reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
        socket, protocol_type, buffers, endpoint, flags,
        &reactive_socket_recvfrom_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_recvfrom_op* o(
        static_cast<reactive_socket_recvfrom_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename ConstBufferSequence, typename Endpoint>
class reactive_socket_sendto_op_base : public reactor_op
{
public:
  reactive_socket_sendto_op_base(socket_type socket,
      const ConstBufferSequence& buffers, const Endpoint& endpoint,
      socket_base::message_flags flags, func_type complete_func)
    : reactor_op(&reactive_socket_sendto_op_base::do_perform, complete_func),
      socket_(socket),
      buffers_(buffers),
      destination_(endpoint),
      flags_(flags)
  {
  }

  static status do_perform(reactor_op* base)
  {
    reactive_socket_sendto_op_base* o(
        static_cast<reactive_socket_sendto_op_base*>(base));

    buffer_sequence_adapter<boost::asio::const_buffer,
        ConstBufferSequence> bufs(o->buffers_);

    status result = socket_ops::non_blocking_sendto(o->socket_,
          bufs.buffers(), bufs.count(), o->flags_,
          o->destination_.data(), o->destination_.size(),
          o->ec_, o->bytes_transferred_) ? done : not_done;

    (void)0
                                         ;

    return result;
  }

private:
  socket_type socket_;
  ConstBufferSequence buffers_;
  Endpoint destination_;
  socket_base::message_flags flags_;
};

template <typename ConstBufferSequence, typename Endpoint, typename Handler>
class reactive_socket_sendto_op :
  public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
{
public:
  struct ptr { Handler* h; reactive_socket_sendto_op* v; reactive_socket_sendto_op* p; ~ptr() { reset(); } static reactive_socket_sendto_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_sendto_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_sendto_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_sendto_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_sendto_op*>(v), 1); v = 0; } } };

  reactive_socket_sendto_op(socket_type socket,
      const ConstBufferSequence& buffers, const Endpoint& endpoint,
      socket_base::message_flags flags, Handler& handler)
    : reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>(socket,
        buffers, endpoint, flags, &reactive_socket_sendto_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 131 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recv_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recv_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recv_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename MutableBufferSequence>
class reactive_socket_recv_op_base : public reactor_op
{
public:
  reactive_socket_recv_op_base(socket_type socket,
      socket_ops::state_type state, const MutableBufferSequence& buffers,
      socket_base::message_flags flags, func_type complete_func)
    : reactor_op(&reactive_socket_recv_op_base::do_perform, complete_func),
      socket_(socket),
      state_(state),
      buffers_(buffers),
      flags_(flags)
  {
  }

  static status do_perform(reactor_op* base)
  {
    reactive_socket_recv_op_base* o(
        static_cast<reactive_socket_recv_op_base*>(base));

    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(o->buffers_);

    status result = socket_ops::non_blocking_recv(o->socket_,
        bufs.buffers(), bufs.count(), o->flags_,
        (o->state_ & socket_ops::stream_oriented) != 0,
        o->ec_, o->bytes_transferred_) ? done : not_done;

    if (result == done)
      if ((o->state_ & socket_ops::stream_oriented) != 0)
        if (o->bytes_transferred_ == 0)
          result = done_and_exhausted;

    (void)0
                                         ;

    return result;
  }

private:
  socket_type socket_;
  socket_ops::state_type state_;
  MutableBufferSequence buffers_;
  socket_base::message_flags flags_;
};

template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recv_op :
  public reactive_socket_recv_op_base<MutableBufferSequence>
{
public:
  struct ptr { Handler* h; reactive_socket_recv_op* v; reactive_socket_recv_op* p; ~ptr() { reset(); } static reactive_socket_recv_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recv_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_recv_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recv_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_recv_op*>(v), 1); v = 0; } } };

  reactive_socket_recv_op(socket_type socket,
      socket_ops::state_type state, const MutableBufferSequence& buffers,
      socket_base::message_flags flags, Handler& handler)
    : reactive_socket_recv_op_base<MutableBufferSequence>(socket, state,
        buffers, flags, &reactive_socket_recv_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recv_op.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename MutableBufferSequence>
class reactive_socket_recvmsg_op_base : public reactor_op
{
public:
  reactive_socket_recvmsg_op_base(socket_type socket,
      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags, func_type complete_func)
    : reactor_op(&reactive_socket_recvmsg_op_base::do_perform, complete_func),
      socket_(socket),
      buffers_(buffers),
      in_flags_(in_flags),
      out_flags_(out_flags)
  {
  }

  static status do_perform(reactor_op* base)
  {
    reactive_socket_recvmsg_op_base* o(
        static_cast<reactive_socket_recvmsg_op_base*>(base));

    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(o->buffers_);

    status result = socket_ops::non_blocking_recvmsg(o->socket_,
        bufs.buffers(), bufs.count(),
        o->in_flags_, o->out_flags_,
        o->ec_, o->bytes_transferred_) ? done : not_done;

    (void)0
                                         ;

    return result;
  }

private:
  socket_type socket_;
  MutableBufferSequence buffers_;
  socket_base::message_flags in_flags_;
  socket_base::message_flags& out_flags_;
};

template <typename MutableBufferSequence, typename Handler>
class reactive_socket_recvmsg_op :
  public reactive_socket_recvmsg_op_base<MutableBufferSequence>
{
public:
  struct ptr { Handler* h; reactive_socket_recvmsg_op* v; reactive_socket_recvmsg_op* p; ~ptr() { reset(); } static reactive_socket_recvmsg_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvmsg_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_recvmsg_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvmsg_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_recvmsg_op*>(v), 1); v = 0; } } };

  reactive_socket_recvmsg_op(socket_type socket,
      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags, Handler& handler)
    : reactive_socket_recvmsg_op_base<MutableBufferSequence>(socket, buffers,
        in_flags, out_flags, &reactive_socket_recvmsg_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_recvmsg_op* o(
        static_cast<reactive_socket_recvmsg_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_send_op.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_send_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_send_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename ConstBufferSequence>
class reactive_socket_send_op_base : public reactor_op
{
public:
  reactive_socket_send_op_base(socket_type socket,
      socket_ops::state_type state, const ConstBufferSequence& buffers,
      socket_base::message_flags flags, func_type complete_func)
    : reactor_op(&reactive_socket_send_op_base::do_perform, complete_func),
      socket_(socket),
      state_(state),
      buffers_(buffers),
      flags_(flags)
  {
  }

  static status do_perform(reactor_op* base)
  {
    reactive_socket_send_op_base* o(
        static_cast<reactive_socket_send_op_base*>(base));

    buffer_sequence_adapter<boost::asio::const_buffer,
        ConstBufferSequence> bufs(o->buffers_);

    status result = socket_ops::non_blocking_send(o->socket_,
          bufs.buffers(), bufs.count(), o->flags_,
          o->ec_, o->bytes_transferred_) ? done : not_done;

    if (result == done)
      if ((o->state_ & socket_ops::stream_oriented) != 0)
        if (o->bytes_transferred_ < bufs.total_size())
          result = done_and_exhausted;

    (void)0
                                         ;

    return result;
  }

private:
  socket_type socket_;
  socket_ops::state_type state_;
  ConstBufferSequence buffers_;
  socket_base::message_flags flags_;
};

template <typename ConstBufferSequence, typename Handler>
class reactive_socket_send_op :
  public reactive_socket_send_op_base<ConstBufferSequence>
{
public:
  struct ptr { Handler* h; reactive_socket_send_op* v; reactive_socket_send_op* p; ~ptr() { reset(); } static reactive_socket_send_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_send_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_send_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_send_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_send_op*>(v), 1); v = 0; } } };

  reactive_socket_send_op(socket_type socket,
      socket_ops::state_type state, const ConstBufferSequence& buffers,
      socket_base::message_flags flags, Handler& handler)
    : reactive_socket_send_op_base<ConstBufferSequence>(socket,
        state, buffers, flags, &reactive_socket_send_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_send_op.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_wait_op.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_wait_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_wait_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler>
class reactive_wait_op : public reactor_op
{
public:
  struct ptr { Handler* h; reactive_wait_op* v; reactive_wait_op* p; ~ptr() { reset(); } static reactive_wait_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_wait_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_wait_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_wait_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_wait_op*>(v), 1); v = 0; } } };

  reactive_wait_op(Handler& handler)
    : reactor_op(&reactive_wait_op::do_perform,
        &reactive_wait_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static status do_perform(reactor_op*)
  {
    return done;
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    reactive_wait_op* o(static_cast<reactive_wait_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder1<Handler, boost::system::error_code>
      handler(o->handler_, o->ec_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_wait_op.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class reactive_socket_service_base
{
public:

  typedef socket_type native_handle_type;


  struct base_implementation_type
  {

    socket_type socket_;


    socket_ops::state_type state_;


    reactor::per_descriptor_data reactor_data_;
  };


  inline reactive_socket_service_base(
      boost::asio::io_context& io_context);


  inline void base_shutdown();


  inline void construct(base_implementation_type& impl);


  inline void base_move_construct(base_implementation_type& impl,
      base_implementation_type& other_impl);


  inline void base_move_assign(base_implementation_type& impl,
      reactive_socket_service_base& other_service,
      base_implementation_type& other_impl);


  inline void destroy(base_implementation_type& impl);


  bool is_open(const base_implementation_type& impl) const
  {
    return impl.socket_ != invalid_socket;
  }


  inline boost::system::error_code close(
      base_implementation_type& impl, boost::system::error_code& ec);


  inline socket_type release(
      base_implementation_type& impl, boost::system::error_code& ec);


  native_handle_type native_handle(base_implementation_type& impl)
  {
    return impl.socket_;
  }


  inline boost::system::error_code cancel(
      base_implementation_type& impl, boost::system::error_code& ec);


  bool at_mark(const base_implementation_type& impl,
      boost::system::error_code& ec) const
  {
    return socket_ops::sockatmark(impl.socket_, ec);
  }


  std::size_t available(const base_implementation_type& impl,
      boost::system::error_code& ec) const
  {
    return socket_ops::available(impl.socket_, ec);
  }


  boost::system::error_code listen(base_implementation_type& impl,
      int backlog, boost::system::error_code& ec)
  {
    socket_ops::listen(impl.socket_, backlog, ec);
    return ec;
  }


  template <typename IO_Control_Command>
  boost::system::error_code io_control(base_implementation_type& impl,
      IO_Control_Command& command, boost::system::error_code& ec)
  {
    socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
        static_cast<ioctl_arg_type*>(command.data()), ec);
    return ec;
  }


  bool non_blocking(const base_implementation_type& impl) const
  {
    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
  }


  boost::system::error_code non_blocking(base_implementation_type& impl,
      bool mode, boost::system::error_code& ec)
  {
    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
    return ec;
  }


  bool native_non_blocking(const base_implementation_type& impl) const
  {
    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
  }


  boost::system::error_code native_non_blocking(base_implementation_type& impl,
      bool mode, boost::system::error_code& ec)
  {
    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
    return ec;
  }



  boost::system::error_code wait(base_implementation_type& impl,
      socket_base::wait_type w, boost::system::error_code& ec)
  {
    switch (w)
    {
    case socket_base::wait_read:
      socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
      break;
    case socket_base::wait_write:
      socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
      break;
    case socket_base::wait_error:
      socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
      break;
    default:
      ec = boost::asio::error::invalid_argument;
      break;
    }

    return ec;
  }



  template <typename Handler>
  void async_wait(base_implementation_type& impl,
      socket_base::wait_type w, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_wait_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                             ;

    int op_type;
    switch (w)
    {
      case socket_base::wait_read:
        op_type = reactor::read_op;
        break;
      case socket_base::wait_write:
        op_type = reactor::write_op;
        break;
      case socket_base::wait_error:
        op_type = reactor::except_op;
        break;
      default:
        p.p->ec_ = boost::asio::error::invalid_argument;
        reactor_.post_immediate_completion(p.p, is_continuation);
        p.v = p.p = 0;
        return;
    }

    start_op(impl, op_type, p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }


  template <typename ConstBufferSequence>
  size_t send(base_implementation_type& impl,
      const ConstBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    buffer_sequence_adapter<boost::asio::const_buffer,
        ConstBufferSequence> bufs(buffers);

    return socket_ops::sync_send(impl.socket_, impl.state_,
        bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
  }


  size_t send(base_implementation_type& impl, const null_buffers&,
      socket_base::message_flags, boost::system::error_code& ec)
  {

    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);

    return 0;
  }



  template <typename ConstBufferSequence, typename Handler>
  void async_send(base_implementation_type& impl,
      const ConstBufferSequence& buffers,
      socket_base::message_flags flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_send_op<ConstBufferSequence, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);

    (void)0
                                             ;

    start_op(impl, reactor::write_op, p.p, is_continuation, true,
        ((impl.state_ & socket_ops::stream_oriented)
          && buffer_sequence_adapter<boost::asio::const_buffer,
            ConstBufferSequence>::all_empty(buffers)));
    p.v = p.p = 0;
  }


  template <typename Handler>
  void async_send(base_implementation_type& impl, const null_buffers&,
      socket_base::message_flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_null_buffers_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                           ;

    start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }


  template <typename MutableBufferSequence>
  size_t receive(base_implementation_type& impl,
      const MutableBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(buffers);

    return socket_ops::sync_recv(impl.socket_, impl.state_,
        bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
  }


  size_t receive(base_implementation_type& impl, const null_buffers&,
      socket_base::message_flags, boost::system::error_code& ec)
  {

    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);

    return 0;
  }



  template <typename MutableBufferSequence, typename Handler>
  void async_receive(base_implementation_type& impl,
      const MutableBufferSequence& buffers,
      socket_base::message_flags flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);

    (void)0
                                                ;

    start_op(impl,
        (flags & socket_base::message_out_of_band)
          ? reactor::except_op : reactor::read_op,
        p.p, is_continuation,
        (flags & socket_base::message_out_of_band) == 0,
        ((impl.state_ & socket_ops::stream_oriented)
          && buffer_sequence_adapter<boost::asio::mutable_buffer,
            MutableBufferSequence>::all_empty(buffers)));
    p.v = p.p = 0;
  }


  template <typename Handler>
  void async_receive(base_implementation_type& impl, const null_buffers&,
      socket_base::message_flags flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_null_buffers_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                              ;

    start_op(impl,
        (flags & socket_base::message_out_of_band)
          ? reactor::except_op : reactor::read_op,
        p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }



  template <typename MutableBufferSequence>
  size_t receive_with_flags(base_implementation_type& impl,
      const MutableBufferSequence& buffers,
      socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags, boost::system::error_code& ec)
  {
    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(buffers);

    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
  }


  size_t receive_with_flags(base_implementation_type& impl,
      const null_buffers&, socket_base::message_flags,
      socket_base::message_flags& out_flags, boost::system::error_code& ec)
  {

    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);



    out_flags = 0;

    return 0;
  }



  template <typename MutableBufferSequence, typename Handler>
  void async_receive_with_flags(base_implementation_type& impl,
      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_recvmsg_op<MutableBufferSequence, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, buffers, in_flags, out_flags, handler);

    (void)0
                                                           ;

    start_op(impl,
        (in_flags & socket_base::message_out_of_band)
          ? reactor::except_op : reactor::read_op,
        p.p, is_continuation,
        (in_flags & socket_base::message_out_of_band) == 0, false);
    p.v = p.p = 0;
  }


  template <typename Handler>
  void async_receive_with_flags(base_implementation_type& impl,
      const null_buffers&, socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_null_buffers_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                                         ;



    out_flags = 0;

    start_op(impl,
        (in_flags & socket_base::message_out_of_band)
          ? reactor::except_op : reactor::read_op,
        p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }

protected:

  inline boost::system::error_code do_open(
      base_implementation_type& impl, int af,
      int type, int protocol, boost::system::error_code& ec);


  inline boost::system::error_code do_assign(
      base_implementation_type& impl, int type,
      const native_handle_type& native_socket, boost::system::error_code& ec);


  inline void start_op(base_implementation_type& impl, int op_type,
      reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);


  inline void start_accept_op(base_implementation_type& impl,
      reactor_op* op, bool is_continuation, bool peer_is_open);


  inline void start_connect_op(base_implementation_type& impl,
      reactor_op* op, bool is_continuation,
      const socket_addr_type* addr, size_t addrlen);


  io_context& io_context_;


  reactor& reactor_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 505 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

reactive_socket_service_base::reactive_socket_service_base(
    boost::asio::io_context& io_context)
  : io_context_(io_context),
    reactor_(use_service<reactor>(io_context))
{
  reactor_.init_task();
}

void reactive_socket_service_base::base_shutdown()
{
}

void reactive_socket_service_base::construct(
    reactive_socket_service_base::base_implementation_type& impl)
{
  impl.socket_ = invalid_socket;
  impl.state_ = 0;
}

void reactive_socket_service_base::base_move_construct(
    reactive_socket_service_base::base_implementation_type& impl,
    reactive_socket_service_base::base_implementation_type& other_impl)
{
  impl.socket_ = other_impl.socket_;
  other_impl.socket_ = invalid_socket;

  impl.state_ = other_impl.state_;
  other_impl.state_ = 0;

  reactor_.move_descriptor(impl.socket_,
      impl.reactor_data_, other_impl.reactor_data_);
}

void reactive_socket_service_base::base_move_assign(
    reactive_socket_service_base::base_implementation_type& impl,
    reactive_socket_service_base& other_service,
    reactive_socket_service_base::base_implementation_type& other_impl)
{
  destroy(impl);

  impl.socket_ = other_impl.socket_;
  other_impl.socket_ = invalid_socket;

  impl.state_ = other_impl.state_;
  other_impl.state_ = 0;

  other_service.reactor_.move_descriptor(impl.socket_,
      impl.reactor_data_, other_impl.reactor_data_);
}

void reactive_socket_service_base::destroy(
    reactive_socket_service_base::base_implementation_type& impl)
{
  if (impl.socket_ != invalid_socket)
  {
    (void)0
                                                  ;

    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
        (impl.state_ & socket_ops::possible_dup) == 0);

    boost::system::error_code ignored_ec;
    socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);

    reactor_.cleanup_descriptor_data(impl.reactor_data_);
  }
}

boost::system::error_code reactive_socket_service_base::close(
    reactive_socket_service_base::base_implementation_type& impl,
    boost::system::error_code& ec)
{
  if (is_open(impl))
  {
    (void)0
                                                  ;

    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
        (impl.state_ & socket_ops::possible_dup) == 0);

    socket_ops::close(impl.socket_, impl.state_, false, ec);

    reactor_.cleanup_descriptor_data(impl.reactor_data_);
  }
  else
  {
    ec = boost::system::error_code();
  }
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 3 4
  construct(impl);

  return ec;
}

socket_type reactive_socket_service_base::release(
    reactive_socket_service_base::base_implementation_type& impl,
    boost::system::error_code& ec)
{
  if (!is_open(impl))
  {
    ec = boost::asio::error::bad_descriptor;
    return invalid_socket;
  }

  (void)0
                                                  ;

  reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_, false);
  reactor_.cleanup_descriptor_data(impl.reactor_data_);
  socket_type sock = impl.socket_;
  construct(impl);
  ec = boost::system::error_code();
  return sock;
}

boost::system::error_code reactive_socket_service_base::cancel(
    reactive_socket_service_base::base_implementation_type& impl,
    boost::system::error_code& ec)
{
  if (!is_open(impl))
  {
    ec = boost::asio::error::bad_descriptor;
    return ec;
  }

  (void)0
                                                 ;

  reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code reactive_socket_service_base::do_open(
    reactive_socket_service_base::base_implementation_type& impl,
    int af, int type, int protocol, boost::system::error_code& ec)
{
  if (is_open(impl))
  {
    ec = boost::asio::error::already_open;
    return ec;
  }

  socket_holder sock(socket_ops::socket(af, type, protocol, ec));
  if (sock.get() == invalid_socket)
    return ec;

  if (int err = reactor_.register_descriptor(sock.get(), impl.reactor_data_))
  {
    ec = boost::system::error_code(err,
        boost::asio::error::get_system_category());
    return ec;
  }

  impl.socket_ = sock.release();
  switch (type)
  {
  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
  default: impl.state_ = 0; break;
  }
  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code reactive_socket_service_base::do_assign(
    reactive_socket_service_base::base_implementation_type& impl, int type,
    const reactive_socket_service_base::native_handle_type& native_socket,
    boost::system::error_code& ec)
{
  if (is_open(impl))
  {
    ec = boost::asio::error::already_open;
    return ec;
  }

  if (int err = reactor_.register_descriptor(
        native_socket, impl.reactor_data_))
  {
    ec = boost::system::error_code(err,
        boost::asio::error::get_system_category());
    return ec;
  }

  impl.socket_ = native_socket;
  switch (type)
  {
  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
  default: impl.state_ = 0; break;
  }
  impl.state_ |= socket_ops::possible_dup;
  ec = boost::system::error_code();
  return ec;
}

void reactive_socket_service_base::start_op(
    reactive_socket_service_base::base_implementation_type& impl,
    int op_type, reactor_op* op, bool is_continuation,
    bool is_non_blocking, bool noop)
{
  if (!noop)
  {
    if ((impl.state_ & socket_ops::non_blocking)
        || socket_ops::set_internal_non_blocking(
          impl.socket_, impl.state_, true, op->ec_))
    {
      reactor_.start_op(op_type, impl.socket_,
          impl.reactor_data_, op, is_continuation, is_non_blocking);
      return;
    }
  }

  reactor_.post_immediate_completion(op, is_continuation);
}

void reactive_socket_service_base::start_accept_op(
    reactive_socket_service_base::base_implementation_type& impl,
    reactor_op* op, bool is_continuation, bool peer_is_open)
{
  if (!peer_is_open)
    start_op(impl, reactor::read_op, op, is_continuation, true, false);
  else
  {
    op->ec_ = boost::asio::error::already_open;
    reactor_.post_immediate_completion(op, is_continuation);
  }
}

void reactive_socket_service_base::start_connect_op(
    reactive_socket_service_base::base_implementation_type& impl,
    reactor_op* op, bool is_continuation,
    const socket_addr_type* addr, size_t addrlen)
{
  if ((impl.state_ & socket_ops::non_blocking)
      || socket_ops::set_internal_non_blocking(
        impl.socket_, impl.state_, true, op->ec_))
  {
    if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
    {
      if (op->ec_ == boost::asio::error::in_progress
          || op->ec_ == boost::asio::error::would_block)
      {
        op->ec_ = boost::system::error_code();
        reactor_.start_op(reactor::connect_op, impl.socket_,
            impl.reactor_data_, op, is_continuation, false);
        return;
      }
    }
  }

  reactor_.post_immediate_completion(op, is_continuation);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 298 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4
# 508 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Protocol>
class reactive_socket_service :
  public service_base<reactive_socket_service<Protocol> >,
  public reactive_socket_service_base
{
public:

  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;


  typedef socket_type native_handle_type;


  struct implementation_type :
    reactive_socket_service_base::base_implementation_type
  {

    implementation_type()
      : protocol_(endpoint_type().protocol())
    {
    }


    protocol_type protocol_;
  };


  reactive_socket_service(boost::asio::io_context& io_context)
    : service_base<reactive_socket_service<Protocol> >(io_context),
      reactive_socket_service_base(io_context)
  {
  }


  void shutdown()
  {
    this->base_shutdown();
  }


  void move_construct(implementation_type& impl,
      implementation_type& other_impl)
  {
    this->base_move_construct(impl, other_impl);

    impl.protocol_ = other_impl.protocol_;
    other_impl.protocol_ = endpoint_type().protocol();
  }


  void move_assign(implementation_type& impl,
      reactive_socket_service_base& other_service,
      implementation_type& other_impl)
  {
    this->base_move_assign(impl, other_service, other_impl);

    impl.protocol_ = other_impl.protocol_;
    other_impl.protocol_ = endpoint_type().protocol();
  }


  template <typename Protocol1>
  void converting_move_construct(implementation_type& impl,
      reactive_socket_service<Protocol1>&,
      typename reactive_socket_service<
        Protocol1>::implementation_type& other_impl)
  {
    this->base_move_construct(impl, other_impl);

    impl.protocol_ = protocol_type(other_impl.protocol_);
    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
  }


  boost::system::error_code open(implementation_type& impl,
      const protocol_type& protocol, boost::system::error_code& ec)
  {
    if (!do_open(impl, protocol.family(),
          protocol.type(), protocol.protocol(), ec))
      impl.protocol_ = protocol;
    return ec;
  }


  boost::system::error_code assign(implementation_type& impl,
      const protocol_type& protocol, const native_handle_type& native_socket,
      boost::system::error_code& ec)
  {
    if (!do_assign(impl, protocol.type(), native_socket, ec))
      impl.protocol_ = protocol;
    return ec;
  }


  native_handle_type native_handle(implementation_type& impl)
  {
    return impl.socket_;
  }


  boost::system::error_code bind(implementation_type& impl,
      const endpoint_type& endpoint, boost::system::error_code& ec)
  {
    socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
    return ec;
  }


  template <typename Option>
  boost::system::error_code set_option(implementation_type& impl,
      const Option& option, boost::system::error_code& ec)
  {
    socket_ops::setsockopt(impl.socket_, impl.state_,
        option.level(impl.protocol_), option.name(impl.protocol_),
        option.data(impl.protocol_), option.size(impl.protocol_), ec);
    return ec;
  }


  template <typename Option>
  boost::system::error_code get_option(const implementation_type& impl,
      Option& option, boost::system::error_code& ec) const
  {
    std::size_t size = option.size(impl.protocol_);
    socket_ops::getsockopt(impl.socket_, impl.state_,
        option.level(impl.protocol_), option.name(impl.protocol_),
        option.data(impl.protocol_), &size, ec);
    if (!ec)
      option.resize(impl.protocol_, size);
    return ec;
  }


  endpoint_type local_endpoint(const implementation_type& impl,
      boost::system::error_code& ec) const
  {
    endpoint_type endpoint;
    std::size_t addr_len = endpoint.capacity();
    if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec))
      return endpoint_type();
    endpoint.resize(addr_len);
    return endpoint;
  }


  endpoint_type remote_endpoint(const implementation_type& impl,
      boost::system::error_code& ec) const
  {
    endpoint_type endpoint;
    std::size_t addr_len = endpoint.capacity();
    if (socket_ops::getpeername(impl.socket_,
          endpoint.data(), &addr_len, false, ec))
      return endpoint_type();
    endpoint.resize(addr_len);
    return endpoint;
  }


  boost::system::error_code shutdown(base_implementation_type& impl,
      socket_base::shutdown_type what, boost::system::error_code& ec)
  {
    socket_ops::shutdown(impl.socket_, what, ec);
    return ec;
  }



  template <typename ConstBufferSequence>
  size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags,
      boost::system::error_code& ec)
  {
    buffer_sequence_adapter<boost::asio::const_buffer,
        ConstBufferSequence> bufs(buffers);

    return socket_ops::sync_sendto(impl.socket_, impl.state_,
        bufs.buffers(), bufs.count(), flags,
        destination.data(), destination.size(), ec);
  }


  size_t send_to(implementation_type& impl, const null_buffers&,
      const endpoint_type&, socket_base::message_flags,
      boost::system::error_code& ec)
  {

    socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);

    return 0;
  }



  template <typename ConstBufferSequence, typename Handler>
  void async_send_to(implementation_type& impl,
      const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags,
      Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_sendto_op<ConstBufferSequence,
        endpoint_type, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler);

    (void)0
                                                ;

    start_op(impl, reactor::write_op, p.p, is_continuation, true, false);
    p.v = p.p = 0;
  }


  template <typename Handler>
  void async_send_to(implementation_type& impl, const null_buffers&,
      const endpoint_type&, socket_base::message_flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_null_buffers_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                              ;

    start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }



  template <typename MutableBufferSequence>
  size_t receive_from(implementation_type& impl,
      const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags,
      boost::system::error_code& ec)
  {
    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(buffers);

    std::size_t addr_len = sender_endpoint.capacity();
    std::size_t bytes_recvd = socket_ops::sync_recvfrom(
        impl.socket_, impl.state_, bufs.buffers(), bufs.count(),
        flags, sender_endpoint.data(), &addr_len, ec);

    if (!ec)
      sender_endpoint.resize(addr_len);

    return bytes_recvd;
  }


  size_t receive_from(implementation_type& impl, const null_buffers&,
      endpoint_type& sender_endpoint, socket_base::message_flags,
      boost::system::error_code& ec)
  {

    socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);


    sender_endpoint = endpoint_type();

    return 0;
  }




  template <typename MutableBufferSequence, typename Handler>
  void async_receive_from(implementation_type& impl,
      const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
      socket_base::message_flags flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_recvfrom_op<MutableBufferSequence,
        endpoint_type, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    int protocol = impl.protocol_.type();
    p.p = new (p.v) op(impl.socket_, protocol,
        buffers, sender_endpoint, flags, handler);

    (void)0
                                                     ;

    start_op(impl,
        (flags & socket_base::message_out_of_band)
          ? reactor::except_op : reactor::read_op,
        p.p, is_continuation, true, false);
    p.v = p.p = 0;
  }


  template <typename Handler>
  void async_receive_from(implementation_type& impl,
      const null_buffers&, endpoint_type& sender_endpoint,
      socket_base::message_flags flags, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_null_buffers_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                                   ;


    sender_endpoint = endpoint_type();

    start_op(impl,
        (flags & socket_base::message_out_of_band)
          ? reactor::except_op : reactor::read_op,
        p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }


  template <typename Socket>
  boost::system::error_code accept(implementation_type& impl,
      Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
  {

    if (peer.is_open())
    {
      ec = boost::asio::error::already_open;
      return ec;
    }

    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
          peer_endpoint ? &addr_len : 0, ec));


    if (new_socket.get() != invalid_socket)
    {
      if (peer_endpoint)
        peer_endpoint->resize(addr_len);
      peer.assign(impl.protocol_, new_socket.get(), ec);
      if (!ec)
        new_socket.release();
    }

    return ec;
  }



  typename Protocol::socket accept(implementation_type& impl,
      io_context* peer_io_context, endpoint_type* peer_endpoint,
      boost::system::error_code& ec)
  {
    typename Protocol::socket peer(
        peer_io_context ? *peer_io_context : io_context_);

    std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
    socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
          impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
          peer_endpoint ? &addr_len : 0, ec));


    if (new_socket.get() != invalid_socket)
    {
      if (peer_endpoint)
        peer_endpoint->resize(addr_len);
      peer.assign(impl.protocol_, new_socket.get(), ec);
      if (!ec)
        new_socket.release();
    }

    return peer;
  }




  template <typename Socket, typename Handler>
  void async_accept(implementation_type& impl, Socket& peer,
      endpoint_type* peer_endpoint, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_accept_op<Socket, Protocol, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, impl.state_, peer,
        impl.protocol_, peer_endpoint, handler);

    (void)0
                                               ;

    start_accept_op(impl, p.p, is_continuation, peer.is_open());
    p.v = p.p = 0;
  }




  template <typename Handler>
  void async_accept(implementation_type& impl,
      boost::asio::io_context* peer_io_context,
      endpoint_type* peer_endpoint, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_move_accept_op<Protocol, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(peer_io_context ? *peer_io_context : io_context_,
        impl.socket_, impl.state_, impl.protocol_, peer_endpoint, handler);

    (void)0
                                               ;

    start_accept_op(impl, p.p, is_continuation, false);
    p.v = p.p = 0;
  }



  boost::system::error_code connect(implementation_type& impl,
      const endpoint_type& peer_endpoint, boost::system::error_code& ec)
  {
    socket_ops::sync_connect(impl.socket_,
        peer_endpoint.data(), peer_endpoint.size(), ec);
    return ec;
  }


  template <typename Handler>
  void async_connect(implementation_type& impl,
      const endpoint_type& peer_endpoint, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_socket_connect_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, handler);

    (void)0
                                                ;

    start_connect_op(impl, p.p, is_continuation,
        peer_endpoint.data(), peer_endpoint.size());
    p.v = p.p = 0;
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 525 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 2 3 4

namespace boost {
namespace asio {
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
template <typename Protocol >
class basic_socket
  : protected basic_io_object<detail::reactive_socket_service<Protocol> >,
    public socket_base
{
public:

  typedef io_context::executor_type executor_type;





  typedef typename detail::reactive_socket_service<Protocol>::native_handle_type native_handle_type;



  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;



  typedef basic_socket<Protocol > lowest_layer_type;
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  explicit basic_socket(boost::asio::io_context& io_context)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
  }
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  basic_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().open(this->get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, "open");
  }
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  basic_socket(boost::asio::io_context& io_context,
      const endpoint_type& endpoint)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
    boost::system::error_code ec;
    const protocol_type protocol = endpoint.protocol();
    this->get_service().open(this->get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, "open");
    this->get_service().bind(this->get_implementation(), endpoint, ec);
    boost::asio::detail::throw_error(ec, "bind");
  }
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  basic_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol, const native_handle_type& native_socket)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        protocol, native_socket, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 179 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  basic_socket(basic_socket&& other)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(std::move(other))
  {
  }
# 194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  basic_socket& operator=(basic_socket&& other)
  {
    basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(other));
    return *this;
  }


  template <typename Protocol1 >
  friend class basic_socket;
# 214 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename Protocol1 >
  basic_socket(basic_socket<Protocol1 >&& other,
      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(
        other.get_service(), other.get_implementation())
  {
  }
# 232 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename Protocol1 >
  typename enable_if<is_convertible<Protocol1, Protocol>::value,
      basic_socket>::type& operator=(
        basic_socket<Protocol1 >&& other)
  {
    basic_socket tmp(std::move(other));
    basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(tmp));
    return *this;
  }
# 256 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_context();
  }
# 270 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<detail::reactive_socket_service<Protocol> >::get_executor();
  }
# 293 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  lowest_layer_type& lowest_layer()
  {
    return *this;
  }
# 307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  const lowest_layer_type& lowest_layer() const
  {
    return *this;
  }
# 327 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void open(const protocol_type& protocol = protocol_type())
  {
    boost::system::error_code ec;
    this->get_service().open(this->get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, "open");
  }
# 353 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code open(const protocol_type& protocol,
      boost::system::error_code& ec)
  {
    this->get_service().open(this->get_implementation(), protocol, ec);
    return ec;
  }
# 370 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void assign(const protocol_type& protocol,
      const native_handle_type& native_socket)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        protocol, native_socket, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 389 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code assign(const protocol_type& protocol,
      const native_handle_type& native_socket, boost::system::error_code& ec)
  {
    this->get_service().assign(this->get_implementation(),
        protocol, native_socket, ec);
    return ec;
  }


  bool is_open() const
  {
    return this->get_service().is_open(this->get_implementation());
  }
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void close()
  {
    boost::system::error_code ec;
    this->get_service().close(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "close");
  }
# 446 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code close(boost::system::error_code& ec)
  {
    this->get_service().close(this->get_implementation(), ec);
    return ec;
  }
# 471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  native_handle_type release()
  {
    boost::system::error_code ec;
    native_handle_type s = this->get_service().release(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "release");
    return s;
  }
# 499 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  native_handle_type release(boost::system::error_code& ec)
  {
    return this->get_service().release(this->get_implementation(), ec);
  }







  native_handle_type native_handle()
  {
    return this->get_service().native_handle(this->get_implementation());
  }
# 556 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void cancel()
  {
    boost::system::error_code ec;
    this->get_service().cancel(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel");
  }
# 604 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code cancel(boost::system::error_code& ec)
  {
    this->get_service().cancel(this->get_implementation(), ec);
    return ec;
  }
# 620 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  bool at_mark() const
  {
    boost::system::error_code ec;
    bool b = this->get_service().at_mark(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "at_mark");
    return b;
  }
# 638 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  bool at_mark(boost::system::error_code& ec) const
  {
    return this->get_service().at_mark(this->get_implementation(), ec);
  }
# 653 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  std::size_t available() const
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().available(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "available");
    return s;
  }
# 672 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  std::size_t available(boost::system::error_code& ec) const
  {
    return this->get_service().available(this->get_implementation(), ec);
  }
# 695 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void bind(const endpoint_type& endpoint)
  {
    boost::system::error_code ec;
    this->get_service().bind(this->get_implementation(), endpoint, ec);
    boost::asio::detail::throw_error(ec, "bind");
  }
# 725 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code bind(const endpoint_type& endpoint,
      boost::system::error_code& ec)
  {
    this->get_service().bind(this->get_implementation(), endpoint, ec);
    return ec;
  }
# 755 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void connect(const endpoint_type& peer_endpoint)
  {
    boost::system::error_code ec;
    if (!is_open())
    {
      this->get_service().open(this->get_implementation(),
          peer_endpoint.protocol(), ec);
      boost::asio::detail::throw_error(ec, "connect");
    }
    this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
    boost::asio::detail::throw_error(ec, "connect");
  }
# 796 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code connect(const endpoint_type& peer_endpoint,
      boost::system::error_code& ec)
  {
    if (!is_open())
    {
      this->get_service().open(this->get_implementation(),
            peer_endpoint.protocol(), ec);
      if (ec)
      {
        return ec;
      }
    }

    this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
    return ec;
  }
# 854 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename ConnectHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ConnectHandler>::type, void (boost::system::error_code)>::return_type

  async_connect(const endpoint_type& peer_endpoint,
      ConnectHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ConnectHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;

    if (!is_open())
    {
      boost::system::error_code ec;
      const protocol_type protocol = peer_endpoint.protocol();
      this->get_service().open(this->get_implementation(), protocol, ec);
      if (ec)
      {
        async_completion<ConnectHandler,
          void (boost::system::error_code)> init(handler);

        boost::asio::post(this->get_executor(),
            boost::asio::detail::bind_handler(
              static_cast<typename ::boost::asio::async_result< typename ::boost::asio::decay<ConnectHandler>::type, void (boost::system::error_code)>::completion_handler_type&&>
                                                                  (
                  init.completion_handler), ec));

        return init.result.get();
      }
    }





    async_completion<ConnectHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_connect(
        this->get_implementation(), peer_endpoint, init.completion_handler);

    return init.result.get();

  }
# 932 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename SettableSocketOption>
  void set_option(const SettableSocketOption& option)
  {
    boost::system::error_code ec;
    this->get_service().set_option(this->get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, "set_option");
  }
# 979 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename SettableSocketOption>
  boost::system::error_code set_option(const SettableSocketOption& option,
      boost::system::error_code& ec)
  {
    this->get_service().set_option(this->get_implementation(), option, ec);
    return ec;
  }
# 1022 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename GettableSocketOption>
  void get_option(GettableSocketOption& option) const
  {
    boost::system::error_code ec;
    this->get_service().get_option(this->get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, "get_option");
  }
# 1070 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename GettableSocketOption>
  boost::system::error_code get_option(GettableSocketOption& option,
      boost::system::error_code& ec) const
  {
    this->get_service().get_option(this->get_implementation(), option, ec);
    return ec;
  }
# 1100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename IoControlCommand>
  void io_control(IoControlCommand& command)
  {
    boost::system::error_code ec;
    this->get_service().io_control(this->get_implementation(), command, ec);
    boost::asio::detail::throw_error(ec, "io_control");
  }
# 1135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename IoControlCommand>
  boost::system::error_code io_control(IoControlCommand& command,
      boost::system::error_code& ec)
  {
    this->get_service().io_control(this->get_implementation(), command, ec);
    return ec;
  }
# 1154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  bool non_blocking() const
  {
    return this->get_service().non_blocking(this->get_implementation());
  }
# 1172 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void non_blocking(bool mode)
  {
    boost::system::error_code ec;
    this->get_service().non_blocking(this->get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, "non_blocking");
  }
# 1192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    this->get_service().non_blocking(this->get_implementation(), mode, ec);
    return ec;
  }
# 1283 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  bool native_non_blocking() const
  {
    return this->get_service().native_non_blocking(this->get_implementation());
  }
# 1373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void native_non_blocking(bool mode)
  {
    boost::system::error_code ec;
    this->get_service().native_non_blocking(
        this->get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, "native_non_blocking");
  }
# 1466 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code native_non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    this->get_service().native_non_blocking(
        this->get_implementation(), mode, ec);
    return ec;
  }
# 1489 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  endpoint_type local_endpoint() const
  {
    boost::system::error_code ec;
    endpoint_type ep = this->get_service().local_endpoint(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "local_endpoint");
    return ep;
  }
# 1519 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  endpoint_type local_endpoint(boost::system::error_code& ec) const
  {
    return this->get_service().local_endpoint(this->get_implementation(), ec);
  }
# 1539 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  endpoint_type remote_endpoint() const
  {
    boost::system::error_code ec;
    endpoint_type ep = this->get_service().remote_endpoint(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "remote_endpoint");
    return ep;
  }
# 1569 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  endpoint_type remote_endpoint(boost::system::error_code& ec) const
  {
    return this->get_service().remote_endpoint(this->get_implementation(), ec);
  }
# 1591 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void shutdown(shutdown_type what)
  {
    boost::system::error_code ec;
    this->get_service().shutdown(this->get_implementation(), what, ec);
    boost::asio::detail::throw_error(ec, "shutdown");
  }
# 1620 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code shutdown(shutdown_type what,
      boost::system::error_code& ec)
  {
    this->get_service().shutdown(this->get_implementation(), what, ec);
    return ec;
  }
# 1643 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  void wait(wait_type w)
  {
    boost::system::error_code ec;
    this->get_service().wait(this->get_implementation(), w, ec);
    boost::asio::detail::throw_error(ec, "wait");
  }
# 1669 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  boost::system::error_code wait(wait_type w, boost::system::error_code& ec)
  {
    this->get_service().wait(this->get_implementation(), w, ec);
    return ec;
  }
# 1711 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 3 4
  template <typename WaitHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type

  async_wait(wait_type w, WaitHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WaitHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_wait(this->get_implementation(),
        w, init.completion_handler);

    return init.result.get();

  }

protected:





  ~basic_socket()
  {
  }

private:

  basic_socket(const basic_socket&) = delete;
  basic_socket& operator=(const basic_socket&) = delete;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1754 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 2 3 4

namespace boost {
namespace asio {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
template <typename Protocol
    >
class basic_datagram_socket
  : public basic_socket<Protocol >
{
public:




  typedef typename basic_socket<
    Protocol >::native_handle_type native_handle_type;



  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  explicit basic_datagram_socket(boost::asio::io_context& io_context)
    : basic_socket<Protocol >(io_context)
  {
  }
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  basic_datagram_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol)
    : basic_socket<Protocol >(io_context, protocol)
  {
  }
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  basic_datagram_socket(boost::asio::io_context& io_context,
      const endpoint_type& endpoint)
    : basic_socket<Protocol >(io_context, endpoint)
  {
  }
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  basic_datagram_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol, const native_handle_type& native_socket)
    : basic_socket<Protocol >(
        io_context, protocol, native_socket)
  {
  }
# 151 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  basic_datagram_socket(basic_datagram_socket&& other)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 167 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  basic_datagram_socket& operator=(basic_datagram_socket&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename Protocol1 >
  basic_datagram_socket(
      basic_datagram_socket<Protocol1 >&& other,
      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 204 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename Protocol1 >
  typename enable_if<is_convertible<Protocol1, Protocol>::value,
      basic_datagram_socket>::type& operator=(
        basic_datagram_socket<Protocol1 >&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }







  ~basic_datagram_socket()
  {
  }
# 245 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "send");
    return s;
  }
# 272 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
    boost::asio::detail::throw_error(ec, "send");
    return s;
  }
# 300 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    return this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
  }
# 343 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(this->get_implementation(),
        buffers, 0, init.completion_handler);

    return init.result.get();

  }
# 395 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(this->get_implementation(),
        buffers, flags, init.completion_handler);

    return init.result.get();

  }
# 445 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send_to(
        this->get_implementation(), buffers, destination, 0, ec);
    boost::asio::detail::throw_error(ec, "send_to");
    return s;
  }
# 472 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send_to(
        this->get_implementation(), buffers, destination, flags, ec);
    boost::asio::detail::throw_error(ec, "send_to");
    return s;
  }
# 499 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags,
      boost::system::error_code& ec)
  {
    return this->get_service().send_to(this->get_implementation(),
        buffers, destination, flags, ec);
  }
# 545 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send_to(
        this->get_implementation(), buffers, destination, 0,
        init.completion_handler);

    return init.result.get();

  }
# 599 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send_to(
        this->get_implementation(), buffers, destination, flags,
        init.completion_handler);

    return init.result.get();

  }
# 650 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 678 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive(
        this->get_implementation(), buffers, flags, ec);
    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 707 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    return this->get_service().receive(
        this->get_implementation(), buffers, flags, ec);
  }
# 751 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive(this->get_implementation(),
        buffers, 0, init.completion_handler);

    return init.result.get();

  }
# 803 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive(this->get_implementation(),
        buffers, flags, init.completion_handler);

    return init.result.get();

  }
# 854 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive_from(
        this->get_implementation(), buffers, sender_endpoint, 0, ec);
    boost::asio::detail::throw_error(ec, "receive_from");
    return s;
  }
# 881 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive_from(
        this->get_implementation(), buffers, sender_endpoint, flags, ec);
    boost::asio::detail::throw_error(ec, "receive_from");
    return s;
  }
# 908 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags,
      boost::system::error_code& ec)
  {
    return this->get_service().receive_from(this->get_implementation(),
        buffers, sender_endpoint, flags, ec);
  }
# 953 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive_from(
        this->get_implementation(), buffers, sender_endpoint, 0,
        init.completion_handler);

    return init.result.get();

  }
# 1009 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive_from(
        this->get_implementation(), buffers, sender_endpoint, flags,
        init.completion_handler);

    return init.result.get();

  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1041 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/time_traits.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/time_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/time_traits.hpp" 2 3 4

namespace boost {
namespace asio {


template <typename Time>
struct time_traits;


template <>
struct time_traits<boost::posix_time::ptime>
{

  typedef boost::posix_time::ptime time_type;


  typedef boost::posix_time::time_duration duration_type;


  static time_type now()
  {

    return boost::posix_time::microsec_clock::universal_time();



  }


  static time_type add(const time_type& t, const duration_type& d)
  {
    return t + d;
  }


  static duration_type subtract(const time_type& t1, const time_type& t2)
  {
    return t1 - t2;
  }


  static bool less_than(const time_type& t1, const time_type& t2)
  {
    return t1 < t2;
  }


  static boost::posix_time::time_duration to_posix_duration(
      const duration_type& d)
  {
    return d;
  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/time_traits.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/date_time_fwd.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/date_time_fwd.hpp" 3 4
namespace boost {
namespace date_time {

template<class T, class TimeSystem>
class base_time;

}
namespace posix_time {

class ptime;

}
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Time_Traits>
class timer_queue
  : public timer_queue_base
{
public:

  typedef typename Time_Traits::time_type time_type;


  typedef typename Time_Traits::duration_type duration_type;


  class per_timer_data
  {
  public:
    per_timer_data() :
      heap_index_((std::numeric_limits<std::size_t>::max)()),
      next_(0), prev_(0)
    {
    }

  private:
    friend class timer_queue;


    op_queue<wait_op> op_queue_;


    std::size_t heap_index_;


    per_timer_data* next_;
    per_timer_data* prev_;
  };


  timer_queue()
    : timers_(),
      heap_()
  {
  }




  bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
  {

    if (timer.prev_ == 0 && &timer != timers_)
    {
      if (this->is_positive_infinity(time))
      {

        timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
      }
      else
      {


        timer.heap_index_ = heap_.size();
        heap_entry entry = { time, &timer };
        heap_.push_back(entry);
        up_heap(heap_.size() - 1);
      }


      timer.next_ = timers_;
      timer.prev_ = 0;
      if (timers_)
        timers_->prev_ = &timer;
      timers_ = &timer;
    }


    timer.op_queue_.push(op);


    return timer.heap_index_ == 0 && timer.op_queue_.front() == op;
  }


  virtual bool empty() const
  {
    return timers_ == 0;
  }


  virtual long wait_duration_msec(long max_duration) const
  {
    if (heap_.empty())
      return max_duration;

    return this->to_msec(
        Time_Traits::to_posix_duration(
          Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
        max_duration);
  }


  virtual long wait_duration_usec(long max_duration) const
  {
    if (heap_.empty())
      return max_duration;

    return this->to_usec(
        Time_Traits::to_posix_duration(
          Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
        max_duration);
  }


  virtual void get_ready_timers(op_queue<operation>& ops)
  {
    if (!heap_.empty())
    {
      const time_type now = Time_Traits::now();
      while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
      {
        per_timer_data* timer = heap_[0].timer_;
        ops.push(timer->op_queue_);
        remove_timer(*timer);
      }
    }
  }


  virtual void get_all_timers(op_queue<operation>& ops)
  {
    while (timers_)
    {
      per_timer_data* timer = timers_;
      timers_ = timers_->next_;
      ops.push(timer->op_queue_);
      timer->next_ = 0;
      timer->prev_ = 0;
    }

    heap_.clear();
  }


  std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
  {
    std::size_t num_cancelled = 0;
    if (timer.prev_ != 0 || &timer == timers_)
    {
      while (wait_op* op = (num_cancelled != max_cancelled)
          ? timer.op_queue_.front() : 0)
      {
        op->ec_ = boost::asio::error::operation_aborted;
        timer.op_queue_.pop();
        ops.push(op);
        ++num_cancelled;
      }
      if (timer.op_queue_.empty())
        remove_timer(timer);
    }
    return num_cancelled;
  }


  void move_timer(per_timer_data& target, per_timer_data& source)
  {
    target.op_queue_.push(source.op_queue_);

    target.heap_index_ = source.heap_index_;
    source.heap_index_ = (std::numeric_limits<std::size_t>::max)();

    if (target.heap_index_ < heap_.size())
      heap_[target.heap_index_].timer_ = &target;

    if (timers_ == &source)
      timers_ = &target;
    if (source.prev_)
      source.prev_->next_ = &target;
    if (source.next_)
      source.next_->prev_= &target;
    target.next_ = source.next_;
    target.prev_ = source.prev_;
    source.next_ = 0;
    source.prev_ = 0;
  }

private:

  void up_heap(std::size_t index)
  {
    while (index > 0)
    {
      std::size_t parent = (index - 1) / 2;
      if (!Time_Traits::less_than(heap_[index].time_, heap_[parent].time_))
        break;
      swap_heap(index, parent);
      index = parent;
    }
  }


  void down_heap(std::size_t index)
  {
    std::size_t child = index * 2 + 1;
    while (child < heap_.size())
    {
      std::size_t min_child = (child + 1 == heap_.size()
          || Time_Traits::less_than(
            heap_[child].time_, heap_[child + 1].time_))
        ? child : child + 1;
      if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_))
        break;
      swap_heap(index, min_child);
      index = min_child;
      child = index * 2 + 1;
    }
  }


  void swap_heap(std::size_t index1, std::size_t index2)
  {
    heap_entry tmp = heap_[index1];
    heap_[index1] = heap_[index2];
    heap_[index2] = tmp;
    heap_[index1].timer_->heap_index_ = index1;
    heap_[index2].timer_->heap_index_ = index2;
  }


  void remove_timer(per_timer_data& timer)
  {

    std::size_t index = timer.heap_index_;
    if (!heap_.empty() && index < heap_.size())
    {
      if (index == heap_.size() - 1)
      {
        heap_.pop_back();
      }
      else
      {
        swap_heap(index, heap_.size() - 1);
        heap_.pop_back();
        if (index > 0 && Time_Traits::less_than(
              heap_[index].time_, heap_[(index - 1) / 2].time_))
          up_heap(index);
        else
          down_heap(index);
      }
    }


    if (timers_ == &timer)
      timers_ = timer.next_;
    if (timer.prev_)
      timer.prev_->next_ = timer.next_;
    if (timer.next_)
      timer.next_->prev_= timer.prev_;
    timer.next_ = 0;
    timer.prev_ = 0;
  }


  template <typename Time_Type>
  static bool is_positive_infinity(const Time_Type&)
  {
    return false;
  }


  template <typename T, typename TimeSystem>
  static bool is_positive_infinity(
      const boost::date_time::base_time<T, TimeSystem>& time)
  {
    return time.is_pos_infinity();
  }


  template <typename Duration>
  long to_msec(const Duration& d, long max_duration) const
  {
    if (d.ticks() <= 0)
      return 0;
    int64_t msec = d.total_milliseconds();
    if (msec == 0)
      return 1;
    if (msec > max_duration)
      return max_duration;
    return static_cast<long>(msec);
  }


  template <typename Duration>
  long to_usec(const Duration& d, long max_duration) const
  {
    if (d.ticks() <= 0)
      return 0;
    int64_t usec = d.total_microseconds();
    if (usec == 0)
      return 1;
    if (usec > max_duration)
      return max_duration;
    return static_cast<long>(usec);
  }


  per_timer_data* timers_;

  struct heap_entry
  {

    time_type time_;


    per_timer_data* timer_;
  };


  std::vector<heap_entry> heap_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 359 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_ptime.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_ptime.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};


template <>
class timer_queue<time_traits<boost::posix_time::ptime> >
  : public timer_queue_base
{
public:

  typedef boost::posix_time::ptime time_type;


  typedef boost::posix_time::time_duration duration_type;


  typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
    per_timer_data;


  inline timer_queue();


  inline virtual ~timer_queue();




  inline bool enqueue_timer(const time_type& time,
      per_timer_data& timer, wait_op* op);


  inline virtual bool empty() const;


  inline virtual long wait_duration_msec(long max_duration) const;


  inline virtual long wait_duration_usec(long max_duration) const;


  inline virtual void get_ready_timers(op_queue<operation>& ops);


  inline virtual void get_all_timers(op_queue<operation>& ops);


  inline std::size_t cancel_timer(
      per_timer_data& timer, op_queue<operation>& ops,
      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());


  inline void move_timer(per_timer_data& target,
      per_timer_data& source);

private:
  timer_queue<forwarding_posix_time_traits> impl_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_ptime.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue()
{
}

timer_queue<time_traits<boost::posix_time::ptime> >::~timer_queue()
{
}

bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
    const time_type& time, per_timer_data& timer, wait_op* op)
{
  return impl_.enqueue_timer(time, timer, op);
}

bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
{
  return impl_.empty();
}

long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_msec(
    long max_duration) const
{
  return impl_.wait_duration_msec(max_duration);
}

long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_usec(
    long max_duration) const
{
  return impl_.wait_duration_usec(max_duration);
}

void timer_queue<time_traits<boost::posix_time::ptime> >::get_ready_timers(
    op_queue<operation>& ops)
{
  impl_.get_ready_timers(ops);
}

void timer_queue<time_traits<boost::posix_time::ptime> >::get_all_timers(
    op_queue<operation>& ops)
{
  impl_.get_all_timers(ops);
}

std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
    per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled)
{
  return impl_.cancel_timer(timer, ops, max_cancelled);
}

void timer_queue<time_traits<boost::posix_time::ptime> >::move_timer(
    per_timer_data& target, per_timer_data& source)
{
  impl_.move_timer(target, source);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_scheduler.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_scheduler.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_scheduler_fwd.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_scheduler_fwd.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {






typedef class epoll_reactor timer_scheduler;
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_scheduler_fwd.hpp" 3 4
}
}
}
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/timer_scheduler.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_handler.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_handler.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_handler.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler>
class wait_handler : public wait_op
{
public:
  struct ptr { Handler* h; wait_handler* v; wait_handler* p; ~ptr() { reset(); } static wait_handler* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<wait_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~wait_handler(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<wait_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<wait_handler*>(v), 1); v = 0; } } };

  wait_handler(Handler& h)
    : wait_op(&wait_handler::do_complete),
      handler_(static_cast<Handler&&>(h))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    wait_handler* h(static_cast<wait_handler*>(base));
    ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
    handler_work<Handler> w(h->handler_);

    (void)0;







    detail::binder1<Handler, boost::system::error_code>
      handler(h->handler_, h->ec_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/wait_handler.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Time_Traits>
class deadline_timer_service
  : public service_base<deadline_timer_service<Time_Traits> >
{
public:

  typedef typename Time_Traits::time_type time_type;


  typedef typename Time_Traits::duration_type duration_type;



  struct implementation_type
    : private boost::asio::detail::noncopyable
  {
    time_type expiry;
    bool might_have_pending_waits;
    typename timer_queue<Time_Traits>::per_timer_data timer_data;
  };


  deadline_timer_service(boost::asio::io_context& io_context)
    : service_base<deadline_timer_service<Time_Traits> >(io_context),
      scheduler_(boost::asio::use_service<timer_scheduler>(io_context))
  {
    scheduler_.init_task();
    scheduler_.add_timer_queue(timer_queue_);
  }


  ~deadline_timer_service()
  {
    scheduler_.remove_timer_queue(timer_queue_);
  }


  void shutdown()
  {
  }


  void construct(implementation_type& impl)
  {
    impl.expiry = time_type();
    impl.might_have_pending_waits = false;
  }


  void destroy(implementation_type& impl)
  {
    boost::system::error_code ec;
    cancel(impl, ec);
  }


  void move_construct(implementation_type& impl,
      implementation_type& other_impl)
  {
    scheduler_.move_timer(timer_queue_, impl.timer_data, other_impl.timer_data);

    impl.expiry = other_impl.expiry;
    other_impl.expiry = time_type();

    impl.might_have_pending_waits = other_impl.might_have_pending_waits;
    other_impl.might_have_pending_waits = false;
  }


  void move_assign(implementation_type& impl,
      deadline_timer_service& other_service,
      implementation_type& other_impl)
  {
    if (this != &other_service)
      if (impl.might_have_pending_waits)
        scheduler_.cancel_timer(timer_queue_, impl.timer_data);

    other_service.scheduler_.move_timer(other_service.timer_queue_,
        impl.timer_data, other_impl.timer_data);

    impl.expiry = other_impl.expiry;
    other_impl.expiry = time_type();

    impl.might_have_pending_waits = other_impl.might_have_pending_waits;
    other_impl.might_have_pending_waits = false;
  }


  std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
  {
    if (!impl.might_have_pending_waits)
    {
      ec = boost::system::error_code();
      return 0;
    }

    (void)0
                                                ;

    std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
    impl.might_have_pending_waits = false;
    ec = boost::system::error_code();
    return count;
  }


  std::size_t cancel_one(implementation_type& impl,
      boost::system::error_code& ec)
  {
    if (!impl.might_have_pending_waits)
    {
      ec = boost::system::error_code();
      return 0;
    }

    (void)0
                                                    ;

    std::size_t count = scheduler_.cancel_timer(
        timer_queue_, impl.timer_data, 1);
    if (count == 0)
      impl.might_have_pending_waits = false;
    ec = boost::system::error_code();
    return count;
  }


  time_type expiry(const implementation_type& impl) const
  {
    return impl.expiry;
  }


  time_type expires_at(const implementation_type& impl) const
  {
    return impl.expiry;
  }


  duration_type expires_from_now(const implementation_type& impl) const
  {
    return Time_Traits::subtract(this->expiry(impl), Time_Traits::now());
  }


  std::size_t expires_at(implementation_type& impl,
      const time_type& expiry_time, boost::system::error_code& ec)
  {
    std::size_t count = cancel(impl, ec);
    impl.expiry = expiry_time;
    ec = boost::system::error_code();
    return count;
  }


  std::size_t expires_after(implementation_type& impl,
      const duration_type& expiry_time, boost::system::error_code& ec)
  {
    return expires_at(impl,
        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
  }


  std::size_t expires_from_now(implementation_type& impl,
      const duration_type& expiry_time, boost::system::error_code& ec)
  {
    return expires_at(impl,
        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
  }


  void wait(implementation_type& impl, boost::system::error_code& ec)
  {
    time_type now = Time_Traits::now();
    ec = boost::system::error_code();
    while (Time_Traits::less_than(now, impl.expiry) && !ec)
    {
      this->do_wait(Time_Traits::to_posix_duration(
            Time_Traits::subtract(impl.expiry, now)), ec);
      now = Time_Traits::now();
    }
  }


  template <typename Handler>
  void async_wait(implementation_type& impl, Handler& handler)
  {

    typedef wait_handler<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    impl.might_have_pending_waits = true;

    (void)0
                                                          ;

    scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
    p.v = p.p = 0;
  }

private:



  template <typename Duration>
  void do_wait(const Duration& timeout, boost::system::error_code& ec)
  {






    ::timeval tv;
    tv.tv_sec = timeout.total_seconds();
    tv.tv_usec = timeout.total_microseconds() % 1000000;
    socket_ops::select(0, 0, 0, 0, &tv, ec);

  }


  timer_queue<Time_Traits> timer_queue_;


  timer_scheduler& scheduler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 279 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 2 3 4

namespace boost {
namespace asio {
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
template <typename Time,
    typename TimeTraits = boost::asio::time_traits<Time>
    >
class basic_deadline_timer
  : protected basic_io_object<detail::deadline_timer_service<TimeTraits> >
{
public:

  typedef io_context::executor_type executor_type;


  typedef TimeTraits traits_type;


  typedef typename traits_type::time_type time_type;


  typedef typename traits_type::duration_type duration_type;
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  explicit basic_deadline_timer(boost::asio::io_context& io_context)
    : basic_io_object<detail::deadline_timer_service<TimeTraits> >(io_context)
  {
  }
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  basic_deadline_timer(boost::asio::io_context& io_context,
      const time_type& expiry_time)
    : basic_io_object<detail::deadline_timer_service<TimeTraits> >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().expires_at(this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_at");
  }
# 192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  basic_deadline_timer(boost::asio::io_context& io_context,
      const duration_type& expiry_time)
    : basic_io_object<detail::deadline_timer_service<TimeTraits> >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().expires_from_now(
        this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_from_now");
  }
# 213 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  basic_deadline_timer(basic_deadline_timer&& other)
    : basic_io_object<detail::deadline_timer_service<TimeTraits> >(std::move(other))
  {
  }
# 229 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  basic_deadline_timer& operator=(basic_deadline_timer&& other)
  {
    basic_io_object<detail::deadline_timer_service<TimeTraits> >::operator=(std::move(other));
    return *this;
  }







  ~basic_deadline_timer()
  {
  }
# 258 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<detail::deadline_timer_service<TimeTraits> >::get_io_context();
  }
# 272 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<detail::deadline_timer_service<TimeTraits> >::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<detail::deadline_timer_service<TimeTraits> >::get_executor();
  }
# 307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t cancel()
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().cancel(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel");
    return s;
  }
# 337 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t cancel(boost::system::error_code& ec)
  {
    return this->get_service().cancel(this->get_implementation(), ec);
  }
# 366 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t cancel_one()
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().cancel_one(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel_one");
    return s;
  }
# 399 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t cancel_one(boost::system::error_code& ec)
  {
    return this->get_service().cancel_one(this->get_implementation(), ec);
  }






  time_type expires_at() const
  {
    return this->get_service().expires_at(this->get_implementation());
  }
# 436 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t expires_at(const time_type& expiry_time)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().expires_at(
        this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_at");
    return s;
  }
# 467 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t expires_at(const time_type& expiry_time,
      boost::system::error_code& ec)
  {
    return this->get_service().expires_at(
        this->get_implementation(), expiry_time, ec);
  }






  duration_type expires_from_now() const
  {
    return this->get_service().expires_from_now(this->get_implementation());
  }
# 506 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t expires_from_now(const duration_type& expiry_time)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().expires_from_now(
        this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_from_now");
    return s;
  }
# 537 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  std::size_t expires_from_now(const duration_type& expiry_time,
      boost::system::error_code& ec)
  {
    return this->get_service().expires_from_now(
        this->get_implementation(), expiry_time, ec);
  }
# 551 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  void wait()
  {
    boost::system::error_code ec;
    this->get_service().wait(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "wait");
  }
# 565 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  void wait(boost::system::error_code& ec)
  {
    this->get_service().wait(this->get_implementation(), ec);
  }
# 594 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 3 4
  template <typename WaitHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type

  async_wait(WaitHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WaitHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_wait(this->get_implementation(),
        init.completion_handler);

    return init.result.get();

  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 622 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 2 3 4

namespace boost {
namespace asio {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
template <typename Protocol
    >
class basic_raw_socket
  : public basic_socket<Protocol >
{
public:




  typedef typename basic_socket<
    Protocol >::native_handle_type native_handle_type;



  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  explicit basic_raw_socket(boost::asio::io_context& io_context)
    : basic_socket<Protocol >(io_context)
  {
  }
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  basic_raw_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol)
    : basic_socket<Protocol >(io_context, protocol)
  {
  }
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  basic_raw_socket(boost::asio::io_context& io_context,
      const endpoint_type& endpoint)
    : basic_socket<Protocol >(io_context, endpoint)
  {
  }
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  basic_raw_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol, const native_handle_type& native_socket)
    : basic_socket<Protocol >(
        io_context, protocol, native_socket)
  {
  }
# 151 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  basic_raw_socket(basic_raw_socket&& other)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  basic_raw_socket& operator=(basic_raw_socket&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }
# 182 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename Protocol1 >
  basic_raw_socket(basic_raw_socket<Protocol1 >&& other,
      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 199 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename Protocol1 >
  typename enable_if<is_convertible<Protocol1, Protocol>::value,
      basic_raw_socket>::type& operator=(
        basic_raw_socket<Protocol1 >&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }







  ~basic_raw_socket()
  {
  }
# 239 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "send");
    return s;
  }
# 265 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
    boost::asio::detail::throw_error(ec, "send");
    return s;
  }
# 292 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    return this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
  }
# 335 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(this->get_implementation(),
        buffers, 0, init.completion_handler);

    return init.result.get();

  }
# 387 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(this->get_implementation(),
        buffers, flags, init.completion_handler);

    return init.result.get();

  }
# 437 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send_to(
        this->get_implementation(), buffers, destination, 0, ec);
    boost::asio::detail::throw_error(ec, "send_to");
    return s;
  }
# 464 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send_to(
        this->get_implementation(), buffers, destination, flags, ec);
    boost::asio::detail::throw_error(ec, "send_to");
    return s;
  }
# 491 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags,
      boost::system::error_code& ec)
  {
    return this->get_service().send_to(this->get_implementation(),
        buffers, destination, flags, ec);
  }
# 537 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send_to(this->get_implementation(),
        buffers, destination, 0, init.completion_handler);

    return init.result.get();

  }
# 589 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send_to(const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send_to(
        this->get_implementation(), buffers, destination, flags,
        init.completion_handler);

    return init.result.get();

  }
# 640 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 668 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive(
        this->get_implementation(), buffers, flags, ec);
    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 697 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    return this->get_service().receive(
        this->get_implementation(), buffers, flags, ec);
  }
# 741 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive(this->get_implementation(),
        buffers, 0, init.completion_handler);

    return init.result.get();

  }
# 793 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive(this->get_implementation(),
        buffers, flags, init.completion_handler);

    return init.result.get();

  }
# 844 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive_from(
        this->get_implementation(), buffers, sender_endpoint, 0, ec);
    boost::asio::detail::throw_error(ec, "receive_from");
    return s;
  }
# 871 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive_from(
        this->get_implementation(), buffers, sender_endpoint, flags, ec);
    boost::asio::detail::throw_error(ec, "receive_from");
    return s;
  }
# 898 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags,
      boost::system::error_code& ec)
  {
    return this->get_service().receive_from(this->get_implementation(),
        buffers, sender_endpoint, flags, ec);
  }
# 943 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive_from(
        this->get_implementation(), buffers, sender_endpoint, 0,
        init.completion_handler);

    return init.result.get();

  }
# 999 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive_from(const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive_from(
        this->get_implementation(), buffers, sender_endpoint, flags,
        init.completion_handler);

    return init.result.get();

  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1031 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_raw_socket.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4

namespace boost {
namespace asio {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
template <typename Protocol
    >
class basic_seq_packet_socket
  : public basic_socket<Protocol >
{
public:




  typedef typename basic_socket<
    Protocol >::native_handle_type native_handle_type;



  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  explicit basic_seq_packet_socket(boost::asio::io_context& io_context)
    : basic_socket<Protocol >(io_context)
  {
  }
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  basic_seq_packet_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol)
    : basic_socket<Protocol >(io_context, protocol)
  {
  }
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  basic_seq_packet_socket(boost::asio::io_context& io_context,
      const endpoint_type& endpoint)
    : basic_socket<Protocol >(io_context, endpoint)
  {
  }
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  basic_seq_packet_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol, const native_handle_type& native_socket)
    : basic_socket<Protocol >(
        io_context, protocol, native_socket)
  {
  }
# 154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  basic_seq_packet_socket(basic_seq_packet_socket&& other)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 170 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }
# 188 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename Protocol1 >
  basic_seq_packet_socket(
      basic_seq_packet_socket<Protocol1 >&& other,
      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 208 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename Protocol1 >
  typename enable_if<is_convertible<Protocol1, Protocol>::value,
      basic_seq_packet_socket>::type& operator=(
        basic_seq_packet_socket<Protocol1 >&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }







  ~basic_seq_packet_socket()
  {
  }
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
    boost::asio::detail::throw_error(ec, "send");
    return s;
  }
# 279 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    return this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
  }
# 320 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(this->get_implementation(),
        buffers, flags, init.completion_handler);

    return init.result.get();

  }
# 374 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags& out_flags)
  {
    boost::system::error_code ec;




    std::size_t s = this->get_service().receive_with_flags(
        this->get_implementation(), buffers, 0, out_flags, ec);

    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 425 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags)
  {
    boost::system::error_code ec;




    std::size_t s = this->get_service().receive_with_flags(
        this->get_implementation(), buffers, in_flags, out_flags, ec);

    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 465 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags, boost::system::error_code& ec)
  {




    return this->get_service().receive_with_flags(this->get_implementation(),
        buffers, in_flags, out_flags, ec);

  }
# 517 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      socket_base::message_flags& out_flags,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive_with_flags(
        this->get_implementation(), buffers, 0, out_flags,
        init.completion_handler);

    return init.result.get();

  }
# 586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      socket_base::message_flags in_flags,
      socket_base::message_flags& out_flags,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive_with_flags(
        this->get_implementation(), buffers, in_flags, out_flags,
        init.completion_handler);

    return init.result.get();

  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 619 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_serial_port.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_signal_set.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 1 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 2 3 4

namespace boost {
namespace asio {
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
template <typename Protocol
    >
class basic_socket_acceptor
  : protected basic_io_object<detail::reactive_socket_service<Protocol> >,
    public socket_base
{
public:

  typedef io_context::executor_type executor_type;





  typedef typename detail::reactive_socket_service<Protocol>::native_handle_type native_handle_type;



  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  explicit basic_socket_acceptor(boost::asio::io_context& io_context)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
  }
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  basic_socket_acceptor(boost::asio::io_context& io_context,
      const protocol_type& protocol)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().open(this->get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, "open");
  }
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  basic_socket_acceptor(boost::asio::io_context& io_context,
      const endpoint_type& endpoint, bool reuse_addr = true)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
    boost::system::error_code ec;
    const protocol_type protocol = endpoint.protocol();
    this->get_service().open(this->get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, "open");
    if (reuse_addr)
    {
      this->get_service().set_option(this->get_implementation(),
          socket_base::reuse_address(true), ec);
      boost::asio::detail::throw_error(ec, "set_option");
    }
    this->get_service().bind(this->get_implementation(), endpoint, ec);
    boost::asio::detail::throw_error(ec, "bind");
    this->get_service().listen(this->get_implementation(),
        socket_base::max_listen_connections, ec);
    boost::asio::detail::throw_error(ec, "listen");
  }
# 193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  basic_socket_acceptor(boost::asio::io_context& io_context,
      const protocol_type& protocol, const native_handle_type& native_acceptor)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        protocol, native_acceptor, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 214 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  basic_socket_acceptor(basic_socket_acceptor&& other)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(std::move(other))
  {
  }
# 229 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
  {
    basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(other));
    return *this;
  }


  template <typename Protocol1 >
  friend class basic_socket_acceptor;
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename Protocol1 >
  basic_socket_acceptor(
      basic_socket_acceptor<Protocol1 >&& other,
      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
    : basic_io_object<detail::reactive_socket_service<Protocol> >(
        other.get_service(), other.get_implementation())
  {
  }
# 270 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename Protocol1 >
  typename enable_if<is_convertible<Protocol1, Protocol>::value,
      basic_socket_acceptor>::type& operator=(
        basic_socket_acceptor<Protocol1 >&& other)
  {
    basic_socket_acceptor tmp(std::move(other));
    basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(tmp));
    return *this;
  }
# 287 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  ~basic_socket_acceptor()
  {
  }
# 304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_context();
  }
# 318 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<detail::reactive_socket_service<Protocol> >::get_executor();
  }
# 346 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void open(const protocol_type& protocol = protocol_type())
  {
    boost::system::error_code ec;
    this->get_service().open(this->get_implementation(), protocol, ec);
    boost::asio::detail::throw_error(ec, "open");
  }
# 373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code open(const protocol_type& protocol,
      boost::system::error_code& ec)
  {
    this->get_service().open(this->get_implementation(), protocol, ec);
    return ec;
  }
# 390 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void assign(const protocol_type& protocol,
      const native_handle_type& native_acceptor)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        protocol, native_acceptor, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 409 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code assign(const protocol_type& protocol,
      const native_handle_type& native_acceptor, boost::system::error_code& ec)
  {
    this->get_service().assign(this->get_implementation(),
        protocol, native_acceptor, ec);
    return ec;
  }


  bool is_open() const
  {
    return this->get_service().is_open(this->get_implementation());
  }
# 441 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void bind(const endpoint_type& endpoint)
  {
    boost::system::error_code ec;
    this->get_service().bind(this->get_implementation(), endpoint, ec);
    boost::asio::detail::throw_error(ec, "bind");
  }
# 471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code bind(const endpoint_type& endpoint,
      boost::system::error_code& ec)
  {
    this->get_service().bind(this->get_implementation(), endpoint, ec);
    return ec;
  }
# 488 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void listen(int backlog = socket_base::max_listen_connections)
  {
    boost::system::error_code ec;
    this->get_service().listen(this->get_implementation(), backlog, ec);
    boost::asio::detail::throw_error(ec, "listen");
  }
# 517 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code listen(int backlog, boost::system::error_code& ec)
  {
    this->get_service().listen(this->get_implementation(), backlog, ec);
    return ec;
  }
# 533 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void close()
  {
    boost::system::error_code ec;
    this->get_service().close(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "close");
  }
# 562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code close(boost::system::error_code& ec)
  {
    this->get_service().close(this->get_implementation(), ec);
    return ec;
  }
# 587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  native_handle_type release()
  {
    boost::system::error_code ec;
    native_handle_type s = this->get_service().release(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "release");
    return s;
  }
# 615 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  native_handle_type release(boost::system::error_code& ec)
  {
    return this->get_service().release(this->get_implementation(), ec);
  }







  native_handle_type native_handle()
  {
    return this->get_service().native_handle(this->get_implementation());
  }
# 639 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void cancel()
  {
    boost::system::error_code ec;
    this->get_service().cancel(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel");
  }
# 654 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code cancel(boost::system::error_code& ec)
  {
    this->get_service().cancel(this->get_implementation(), ec);
    return ec;
  }
# 681 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename SettableSocketOption>
  void set_option(const SettableSocketOption& option)
  {
    boost::system::error_code ec;
    this->get_service().set_option(this->get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, "set_option");
  }
# 715 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename SettableSocketOption>
  boost::system::error_code set_option(const SettableSocketOption& option,
      boost::system::error_code& ec)
  {
    this->get_service().set_option(this->get_implementation(), option, ec);
    return ec;
  }
# 745 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename GettableSocketOption>
  void get_option(GettableSocketOption& option) const
  {
    boost::system::error_code ec;
    this->get_service().get_option(this->get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, "get_option");
  }
# 780 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename GettableSocketOption>
  boost::system::error_code get_option(GettableSocketOption& option,
      boost::system::error_code& ec) const
  {
    this->get_service().get_option(this->get_implementation(), option, ec);
    return ec;
  }
# 808 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename IoControlCommand>
  void io_control(IoControlCommand& command)
  {
    boost::system::error_code ec;
    this->get_service().io_control(this->get_implementation(), command, ec);
    boost::asio::detail::throw_error(ec, "io_control");
  }
# 841 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename IoControlCommand>
  boost::system::error_code io_control(IoControlCommand& command,
      boost::system::error_code& ec)
  {
    this->get_service().io_control(this->get_implementation(), command, ec);
    return ec;
  }
# 860 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  bool non_blocking() const
  {
    return this->get_service().non_blocking(this->get_implementation());
  }
# 878 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void non_blocking(bool mode)
  {
    boost::system::error_code ec;
    this->get_service().non_blocking(this->get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, "non_blocking");
  }
# 898 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    this->get_service().non_blocking(this->get_implementation(), mode, ec);
    return ec;
  }
# 919 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  bool native_non_blocking() const
  {
    return this->get_service().native_non_blocking(this->get_implementation());
  }
# 939 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void native_non_blocking(bool mode)
  {
    boost::system::error_code ec;
    this->get_service().native_non_blocking(
        this->get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, "native_non_blocking");
  }
# 962 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code native_non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    this->get_service().native_non_blocking(
        this->get_implementation(), mode, ec);
    return ec;
  }
# 985 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  endpoint_type local_endpoint() const
  {
    boost::system::error_code ec;
    endpoint_type ep = this->get_service().local_endpoint(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "local_endpoint");
    return ep;
  }
# 1016 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  endpoint_type local_endpoint(boost::system::error_code& ec) const
  {
    return this->get_service().local_endpoint(this->get_implementation(), ec);
  }
# 1037 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void wait(wait_type w)
  {
    boost::system::error_code ec;
    this->get_service().wait(this->get_implementation(), w, ec);
    boost::asio::detail::throw_error(ec, "wait");
  }
# 1063 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code wait(wait_type w, boost::system::error_code& ec)
  {
    this->get_service().wait(this->get_implementation(), w, ec);
    return ec;
  }
# 1107 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename WaitHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type

  async_wait(wait_type w, WaitHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WaitHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_wait(this->get_implementation(),
        w, init.completion_handler);

    return init.result.get();

  }
# 1154 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename Protocol1>
  void accept(basic_socket<Protocol1>& peer,
      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)

  {
    boost::system::error_code ec;
    this->get_service().accept(this->get_implementation(),
        peer, static_cast<endpoint_type*>(0), ec);
    boost::asio::detail::throw_error(ec, "accept");
  }
# 1195 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename Protocol1>
  boost::system::error_code accept(
      basic_socket<Protocol1>& peer, boost::system::error_code& ec,
      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)

  {
    this->get_service().accept(this->get_implementation(),
        peer, static_cast<endpoint_type*>(0), ec);
    return ec;
  }
# 1252 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename Protocol1, typename AcceptHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void (boost::system::error_code)>::return_type

  async_accept(basic_socket<Protocol1>& peer,
      AcceptHandler&& handler,
      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)

  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<AcceptHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_accept(this->get_implementation(),
        peer, static_cast<endpoint_type*>(0), init.completion_handler);

    return init.result.get();

  }
# 1307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  void accept(basic_socket<protocol_type>& peer, endpoint_type& peer_endpoint)

  {
    boost::system::error_code ec;
    this->get_service().accept(this->get_implementation(),
        peer, &peer_endpoint, ec);
    boost::asio::detail::throw_error(ec, "accept");
  }
# 1350 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  boost::system::error_code accept(basic_socket<protocol_type>& peer,
      endpoint_type& peer_endpoint, boost::system::error_code& ec)

  {
    this->get_service().accept(
        this->get_implementation(), peer, &peer_endpoint, ec);
    return ec;
  }
# 1392 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename AcceptHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void (boost::system::error_code)>::return_type

  async_accept(basic_socket<protocol_type>& peer,
      endpoint_type& peer_endpoint, AcceptHandler&& handler)

  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<AcceptHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_accept(this->get_implementation(),
        peer, &peer_endpoint, init.completion_handler);

    return init.result.get();

  }
# 1439 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept()
  {
    boost::system::error_code ec;
    typename Protocol::socket peer(
        this->get_service().accept(
          this->get_implementation(), 0, 0, ec));
    boost::asio::detail::throw_error(ec, "accept");
    return peer;
  }
# 1474 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept(boost::system::error_code& ec)
  {
    return this->get_service().accept(this->get_implementation(), 0, 0, ec);
  }
# 1517 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename MoveAcceptHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type

  async_accept(MoveAcceptHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
                                            type_check;







    async_completion<MoveAcceptHandler,
      void (boost::system::error_code,
        typename Protocol::socket)> init(handler);

    this->get_service().async_accept(
        this->get_implementation(), static_cast<boost::asio::io_context*>(0),
        static_cast<endpoint_type*>(0), init.completion_handler);

    return init.result.get();

  }
# 1568 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept(boost::asio::io_context& io_context)
  {
    boost::system::error_code ec;
    typename Protocol::socket peer(
        this->get_service().accept(this->get_implementation(),
          &io_context, static_cast<endpoint_type*>(0), ec));
    boost::asio::detail::throw_error(ec, "accept");
    return peer;
  }
# 1606 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept(
      boost::asio::io_context& io_context, boost::system::error_code& ec)
  {
    return this->get_service().accept(this->get_implementation(),
        &io_context, static_cast<endpoint_type*>(0), ec);
  }
# 1654 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename MoveAcceptHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type

  async_accept(boost::asio::io_context& io_context,
      MoveAcceptHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
                                            type_check;






    async_completion<MoveAcceptHandler,
      void (boost::system::error_code,
        typename Protocol::socket)> init(handler);

    this->get_service().async_accept(this->get_implementation(),
        &io_context, static_cast<endpoint_type*>(0), init.completion_handler);

    return init.result.get();

  }
# 1705 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept(endpoint_type& peer_endpoint)
  {
    boost::system::error_code ec;
    typename Protocol::socket peer(
        this->get_service().accept(this->get_implementation(),
          static_cast<boost::asio::io_context*>(0), &peer_endpoint, ec));
    boost::asio::detail::throw_error(ec, "accept");
    return peer;
  }
# 1744 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept(
      endpoint_type& peer_endpoint, boost::system::error_code& ec)
  {
    return this->get_service().accept(this->get_implementation(),
        static_cast<boost::asio::io_context*>(0), &peer_endpoint, ec);
  }
# 1795 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename MoveAcceptHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type

  async_accept(endpoint_type& peer_endpoint,
      MoveAcceptHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
                                            type_check;






    async_completion<MoveAcceptHandler,
      void (boost::system::error_code,
        typename Protocol::socket)> init(handler);

    this->get_service().async_accept(this->get_implementation(),
        static_cast<boost::asio::io_context*>(0), &peer_endpoint,
        init.completion_handler);

    return init.result.get();

  }
# 1851 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept(
      boost::asio::io_context& io_context, endpoint_type& peer_endpoint)
  {
    boost::system::error_code ec;
    typename Protocol::socket peer(
        this->get_service().accept(this->get_implementation(),
          &io_context, &peer_endpoint, ec));
    boost::asio::detail::throw_error(ec, "accept");
    return peer;
  }
# 1895 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  typename Protocol::socket accept(boost::asio::io_context& io_context,
      endpoint_type& peer_endpoint, boost::system::error_code& ec)
  {
    return this->get_service().accept(this->get_implementation(),
        &io_context, &peer_endpoint, ec);
  }
# 1949 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 3 4
  template <typename MoveAcceptHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type

  async_accept(boost::asio::io_context& io_context,
      endpoint_type& peer_endpoint,
      MoveAcceptHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
                                            type_check;






    async_completion<MoveAcceptHandler,
      void (boost::system::error_code,
        typename Protocol::socket)> init(handler);

    this->get_service().async_accept(this->get_implementation(),
        &io_context, &peer_endpoint, init.completion_handler);

    return init.result.get();

  }

};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1983 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_acceptor.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 2 3 4

namespace boost {
namespace asio {
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
template <typename Protocol
    >
class basic_stream_socket
  : public basic_socket<Protocol >
{
public:




  typedef typename basic_socket<
    Protocol >::native_handle_type native_handle_type;



  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  explicit basic_stream_socket(boost::asio::io_context& io_context)
    : basic_socket<Protocol >(io_context)
  {
  }
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  basic_stream_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol)
    : basic_socket<Protocol >(io_context, protocol)
  {
  }
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  basic_stream_socket(boost::asio::io_context& io_context,
      const endpoint_type& endpoint)
    : basic_socket<Protocol >(io_context, endpoint)
  {
  }
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  basic_stream_socket(boost::asio::io_context& io_context,
      const protocol_type& protocol, const native_handle_type& native_socket)
    : basic_socket<Protocol >(
        io_context, protocol, native_socket)
  {
  }
# 152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  basic_stream_socket(basic_stream_socket&& other)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 167 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  basic_stream_socket& operator=(basic_stream_socket&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename Protocol1 >
  basic_stream_socket(
      basic_stream_socket<Protocol1 >&& other,
      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
    : basic_socket<Protocol >(std::move(other))
  {
  }
# 202 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename Protocol1 >
  typename enable_if<is_convertible<Protocol1, Protocol>::value,
      basic_stream_socket>::type& operator=(
        basic_stream_socket<Protocol1 >&& other)
  {
    basic_socket<Protocol >::operator=(std::move(other));
    return *this;
  }







  ~basic_stream_socket()
  {
  }
# 246 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "send");
    return s;
  }
# 283 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
    boost::asio::detail::throw_error(ec, "send");
    return s;
  }
# 312 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    return this->get_service().send(
        this->get_implementation(), buffers, flags, ec);
  }
# 355 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(
        this->get_implementation(), buffers, 0,
        init.completion_handler);

    return init.result.get();

  }
# 418 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_send(const ConstBufferSequence& buffers,
      socket_base::message_flags flags,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;






    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(
        this->get_implementation(), buffers, flags,
        init.completion_handler);

    return init.result.get();

  }
# 473 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 513 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive(
        this->get_implementation(), buffers, flags, ec);
    boost::asio::detail::throw_error(ec, "receive");
    return s;
  }
# 542 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags, boost::system::error_code& ec)
  {
    return this->get_service().receive(
        this->get_implementation(), buffers, flags, ec);
  }
# 587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive(this->get_implementation(),
        buffers, 0, init.completion_handler);

    return init.result.get();

  }
# 650 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_receive(const MutableBufferSequence& buffers,
      socket_base::message_flags flags,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive(this->get_implementation(),
        buffers, flags, init.completion_handler);

    return init.result.get();

  }
# 702 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().send(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "write_some");
    return s;
  }
# 728 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return this->get_service().send(this->get_implementation(), buffers, 0, ec);
  }
# 770 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_write_some(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_send(this->get_implementation(),
        buffers, 0, init.completion_handler);

    return init.result.get();

  }
# 822 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().receive(
        this->get_implementation(), buffers, 0, ec);
    boost::asio::detail::throw_error(ec, "read_some");
    return s;
  }
# 849 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return this->get_service().receive(
        this->get_implementation(), buffers, 0, ec);
  }
# 893 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_read_some(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_receive(this->get_implementation(),
        buffers, 0, init.completion_handler);

    return init.result.get();

  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 922 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_stream_socket.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/steady_timer.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/steady_timer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/wait_traits.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/wait_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/wait_traits.hpp" 2 3 4

namespace boost {
namespace asio {


template <typename Clock>
struct wait_traits
{




  static typename Clock::duration to_wait_duration(
      const typename Clock::duration& d)
  {
    return d;
  }





  static typename Clock::duration to_wait_duration(
      const typename Clock::time_point& t)
  {
    typename Clock::time_point now = Clock::now();
    if (now + (Clock::duration::max)() < t)
      return (Clock::duration::max)();
    if (now + (Clock::duration::min)() > t)
      return (Clock::duration::min)();
    return t - now;
  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/wait_traits.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/chrono_time_traits.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/chrono_time_traits.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/chrono_time_traits.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


template <int64_t v1, int64_t v2>
struct gcd { enum { value = gcd<v2, v1 % v2>::value }; };

template <int64_t v1>
struct gcd<v1, 0> { enum { value = v1 }; };


template <typename Clock, typename WaitTraits>
struct chrono_time_traits
{

  typedef Clock clock_type;


  typedef typename clock_type::duration duration_type;


  typedef typename clock_type::time_point time_type;


  typedef typename duration_type::period period_type;


  static time_type now()
  {
    return clock_type::now();
  }


  static time_type add(const time_type& t, const duration_type& d)
  {
    const time_type epoch;
    if (t >= epoch)
    {
      if ((time_type::max)() - t < d)
        return (time_type::max)();
    }
    else
    {
      if (-(t - (time_type::min)()) > d)
        return (time_type::min)();
    }

    return t + d;
  }


  static duration_type subtract(const time_type& t1, const time_type& t2)
  {
    const time_type epoch;
    if (t1 >= epoch)
    {
      if (t2 >= epoch)
      {
        return t1 - t2;
      }
      else if (t2 == (time_type::min)())
      {
        return (duration_type::max)();
      }
      else if ((time_type::max)() - t1 < epoch - t2)
      {
        return (duration_type::max)();
      }
      else
      {
        return t1 - t2;
      }
    }
    else
    {
      if (t2 < epoch)
      {
        return t1 - t2;
      }
      else if (t1 == (time_type::min)())
      {
        return (duration_type::min)();
      }
      else if ((time_type::max)() - t2 < epoch - t1)
      {
        return (duration_type::min)();
      }
      else
      {
        return -(t2 - t1);
      }
    }
  }


  static bool less_than(const time_type& t1, const time_type& t2)
  {
    return t1 < t2;
  }



  class posix_time_duration
  {
  public:
    explicit posix_time_duration(const duration_type& d)
      : d_(d)
    {
    }

    int64_t ticks() const
    {
      return d_.count();
    }

    int64_t total_seconds() const
    {
      return duration_cast<1, 1>();
    }

    int64_t total_milliseconds() const
    {
      return duration_cast<1, 1000>();
    }

    int64_t total_microseconds() const
    {
      return duration_cast<1, 1000000>();
    }

  private:
    template <int64_t Num, int64_t Den>
    int64_t duration_cast() const
    {
      const int64_t num1 = period_type::num / gcd<period_type::num, Num>::value;
      const int64_t num2 = Num / gcd<period_type::num, Num>::value;

      const int64_t den1 = period_type::den / gcd<period_type::den, Den>::value;
      const int64_t den2 = Den / gcd<period_type::den, Den>::value;

      const int64_t num = num1 * den2;
      const int64_t den = num2 * den1;

      if (num == 1 && den == 1)
        return ticks();
      else if (num != 1 && den == 1)
        return ticks() * num;
      else if (num == 1 && period_type::den != 1)
        return ticks() / den;
      else
        return ticks() * num / den;
    }

    duration_type d_;
  };


  static posix_time_duration to_posix_duration(const duration_type& d)
  {
    return posix_time_duration(WaitTraits::to_wait_duration(d));
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 191 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/chrono_time_traits.hpp" 2 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 2 3 4

namespace boost {
namespace asio {





template <typename Clock,
    typename WaitTraits = boost::asio::wait_traits<Clock>
    >
class basic_waitable_timer;
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
template <typename Clock, typename WaitTraits >
class basic_waitable_timer
  : protected basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >
{
public:

  typedef io_context::executor_type executor_type;


  typedef Clock clock_type;


  typedef typename clock_type::duration duration;


  typedef typename clock_type::time_point time_point;


  typedef WaitTraits traits_type;
# 177 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  explicit basic_waitable_timer(boost::asio::io_context& io_context)
    : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(io_context)
  {
  }
# 192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  basic_waitable_timer(boost::asio::io_context& io_context,
      const time_point& expiry_time)
    : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().expires_at(this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_at");
  }
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  basic_waitable_timer(boost::asio::io_context& io_context,
      const duration& expiry_time)
    : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(io_context)
  {
    boost::system::error_code ec;
    this->get_service().expires_after(
        this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_after");
  }
# 232 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  basic_waitable_timer(basic_waitable_timer&& other)
    : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(std::move(other))
  {
  }
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  basic_waitable_timer& operator=(basic_waitable_timer&& other)
  {
    basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::operator=(std::move(other));
    return *this;
  }







  ~basic_waitable_timer()
  {
  }
# 277 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::get_io_context();
  }
# 291 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::get_executor();
  }
# 326 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t cancel()
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().cancel(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel");
    return s;
  }
# 358 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t cancel(boost::system::error_code& ec)
  {
    return this->get_service().cancel(this->get_implementation(), ec);
  }
# 388 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t cancel_one()
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().cancel_one(
        this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel_one");
    return s;
  }
# 423 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t cancel_one(boost::system::error_code& ec)
  {
    return this->get_service().cancel_one(this->get_implementation(), ec);
  }







  time_point expires_at() const
  {
    return this->get_service().expires_at(this->get_implementation());
  }







  time_point expiry() const
  {
    return this->get_service().expiry(this->get_implementation());
  }
# 472 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t expires_at(const time_point& expiry_time)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().expires_at(
        this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_at");
    return s;
  }
# 505 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t expires_at(const time_point& expiry_time,
      boost::system::error_code& ec)
  {
    return this->get_service().expires_at(
        this->get_implementation(), expiry_time, ec);
  }
# 535 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t expires_after(const duration& expiry_time)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().expires_after(
        this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_after");
    return s;
  }







  duration expires_from_now() const
  {
    return this->get_service().expires_from_now(this->get_implementation());
  }
# 578 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t expires_from_now(const duration& expiry_time)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().expires_from_now(
        this->get_implementation(), expiry_time, ec);
    boost::asio::detail::throw_error(ec, "expires_from_now");
    return s;
  }
# 610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  std::size_t expires_from_now(const duration& expiry_time,
      boost::system::error_code& ec)
  {
    return this->get_service().expires_from_now(
        this->get_implementation(), expiry_time, ec);
  }
# 625 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  void wait()
  {
    boost::system::error_code ec;
    this->get_service().wait(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "wait");
  }
# 639 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  void wait(boost::system::error_code& ec)
  {
    this->get_service().wait(this->get_implementation(), ec);
  }
# 668 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 3 4
  template <typename WaitHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type

  async_wait(WaitHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;





    async_completion<WaitHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_wait(this->get_implementation(),
        init.completion_handler);

    return init.result.get();

  }

private:

  basic_waitable_timer(const basic_waitable_timer&) = delete;
  basic_waitable_timer& operator=(
      const basic_waitable_timer&) = delete;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 702 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/steady_timer.hpp" 2 3 4


namespace boost {
namespace asio {
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/steady_timer.hpp" 3 4
typedef basic_waitable_timer<chrono::steady_clock> steady_timer;

}
}
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {



class socket_streambuf_io_context
{
protected:
  socket_streambuf_io_context(io_context* ctx)
    : default_io_context_(ctx)
  {
  }

  shared_ptr<io_context> default_io_context_;
};






class socket_streambuf_buffers
{
protected:
  socket_streambuf_buffers()
    : get_buffer_(buffer_size),
      put_buffer_(buffer_size)
  {
  }

  enum { buffer_size = 512 };
  std::vector<char> get_buffer_;
  std::vector<char> put_buffer_;
};

}





template <typename Protocol
    ,







    typename Clock = chrono::steady_clock,
    typename WaitTraits = wait_traits<Clock>
    >


class basic_socket_streambuf;
# 152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
template <typename Protocol ,
    typename Clock, typename WaitTraits >

class basic_socket_streambuf
  : public std::streambuf,
    private detail::socket_streambuf_io_context,
    private detail::socket_streambuf_buffers,



    public basic_socket<Protocol >

{
private:







  typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;



public:

  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;


  typedef Clock clock_type;
# 201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  typedef typename traits_helper::time_type time_type;
  typedef typename traits_helper::duration_type duration_type;

  typedef typename traits_helper::time_type time_point;
  typedef typename traits_helper::duration_type duration;



  basic_socket_streambuf()
    : detail::socket_streambuf_io_context(new io_context),
      basic_socket<Protocol >(*default_io_context_),
      expiry_time_(max_expiry_time())
  {
    init_buffers();
  }



  explicit basic_socket_streambuf(basic_stream_socket<protocol_type> s)
    : detail::socket_streambuf_io_context(0),
      basic_socket<Protocol >(std::move(s)),
      expiry_time_(max_expiry_time())
  {
    init_buffers();
  }


  basic_socket_streambuf(basic_socket_streambuf&& other)
    : detail::socket_streambuf_io_context(other),
      basic_socket<Protocol >(std::move(other.socket())),
      ec_(other.ec_),
      expiry_time_(other.expiry_time_)
  {
    get_buffer_.swap(other.get_buffer_);
    put_buffer_.swap(other.put_buffer_);
    setg(other.eback(), other.gptr(), other.egptr());
    setp(other.pptr(), other.epptr());
    other.ec_ = boost::system::error_code();
    other.expiry_time_ = max_expiry_time();
    other.init_buffers();
  }


  basic_socket_streambuf& operator=(basic_socket_streambuf&& other)
  {
    this->close();
    socket() = std::move(other.socket());
    detail::socket_streambuf_io_context::operator=(other);
    ec_ = other.ec_;
    expiry_time_ = other.expiry_time_;
    get_buffer_.swap(other.get_buffer_);
    put_buffer_.swap(other.put_buffer_);
    setg(other.eback(), other.gptr(), other.egptr());
    setp(other.pptr(), other.epptr());
    other.ec_ = boost::system::error_code();
    other.expiry_time_ = max_expiry_time();
    other.put_buffer_.resize(buffer_size);
    other.init_buffers();
    return *this;
  }



  virtual ~basic_socket_streambuf()
  {
    if (pptr() != pbase())
      overflow(traits_type::eof());
  }
# 277 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  basic_socket_streambuf* connect(const endpoint_type& endpoint)
  {
    init_buffers();
    ec_ = boost::system::error_code();
    this->connect_to_endpoints(&endpoint, &endpoint + 1);
    return !ec_ ? this : 0;
  }
# 298 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  template <typename... T>
  basic_socket_streambuf* connect(T... x)
  {
    init_buffers();
    typedef typename Protocol::resolver resolver_type;
    resolver_type resolver(socket().get_executor().context());
    connect_to_endpoints(resolver.resolve(x..., ec_));
    return !ec_ ? this : 0;
  }
# 316 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  basic_socket_streambuf* close()
  {
    sync();
    socket().close(ec_);
    if (!ec_)
      init_buffers();
    return !ec_ ? this : 0;
  }


  basic_socket<Protocol >& socket()
  {
    return *this;
  }






  const boost::system::error_code& error() const
  {
    return ec_;
  }
# 348 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  const boost::system::error_code& puberror() const
  {
    return error();
  }







  time_point expires_at() const
  {
    return expiry_time_;
  }







  time_point expiry() const
  {
    return expiry_time_;
  }
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  void expires_at(const time_point& expiry_time)
  {
    expiry_time_ = expiry_time;
  }
# 398 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  void expires_after(const duration& expiry_time)
  {
    expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
  }







  duration expires_from_now() const
  {
    return traits_helper::subtract(expires_at(), traits_helper::now());
  }
# 424 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 3 4
  void expires_from_now(const duration& expiry_time)
  {
    expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
  }


protected:
  int_type underflow()
  {




    if (gptr() != egptr())
      return traits_type::eof();

    for (;;)
    {

      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
      {
        ec_ = boost::asio::error::timed_out;
        return traits_type::eof();
      }


      if (!socket().native_non_blocking())
        socket().native_non_blocking(true, ec_);
      detail::buffer_sequence_adapter<mutable_buffer, mutable_buffer>
        bufs(boost::asio::buffer(get_buffer_) + putback_max);
      detail::signed_size_type bytes = detail::socket_ops::recv(
          socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);


      if (bytes > 0)
      {
        setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
            &get_buffer_[0] + putback_max + bytes);
        return traits_type::to_int_type(*gptr());
      }


      if (bytes == 0)
      {
        ec_ = boost::asio::error::eof;
        return traits_type::eof();
      }


      if (ec_ != boost::asio::error::would_block
          && ec_ != boost::asio::error::try_again)
        return traits_type::eof();


      if (detail::socket_ops::poll_read(
            socket().native_handle(), 0, timeout(), ec_) < 0)
        return traits_type::eof();
    }

  }

  int_type overflow(int_type c)
  {




    char_type ch = traits_type::to_char_type(c);


    const_buffer output_buffer;
    if (put_buffer_.empty())
    {
      if (traits_type::eq_int_type(c, traits_type::eof()))
        return traits_type::not_eof(c);
      output_buffer = boost::asio::buffer(&ch, sizeof(char_type));
    }
    else
    {
      output_buffer = boost::asio::buffer(pbase(),
          (pptr() - pbase()) * sizeof(char_type));
    }

    while (output_buffer.size() > 0)
    {

      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
      {
        ec_ = boost::asio::error::timed_out;
        return traits_type::eof();
      }


      if (!socket().native_non_blocking())
        socket().native_non_blocking(true, ec_);
      detail::buffer_sequence_adapter<
        const_buffer, const_buffer> bufs(output_buffer);
      detail::signed_size_type bytes = detail::socket_ops::send(
          socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);


      if (bytes > 0)
      {
        output_buffer += static_cast<std::size_t>(bytes);
        continue;
      }


      if (ec_ != boost::asio::error::would_block
          && ec_ != boost::asio::error::try_again)
        return traits_type::eof();


      if (detail::socket_ops::poll_write(
            socket().native_handle(), 0, timeout(), ec_) < 0)
        return traits_type::eof();
    }

    if (!put_buffer_.empty())
    {
      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());


      if (traits_type::eq_int_type(c, traits_type::eof()))
        return traits_type::not_eof(c);


      *pptr() = ch;
      pbump(1);
    }

    return c;

  }

  int sync()
  {
    return overflow(traits_type::eof());
  }

  std::streambuf* setbuf(char_type* s, std::streamsize n)
  {
    if (pptr() == pbase() && s == 0 && n == 0)
    {
      put_buffer_.clear();
      setp(0, 0);
      sync();
      return this;
    }

    return 0;
  }

private:

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

  void init_buffers()
  {
    setg(&get_buffer_[0],
        &get_buffer_[0] + putback_max,
        &get_buffer_[0] + putback_max);

    if (put_buffer_.empty())
      setp(0, 0);
    else
      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
  }

  int timeout() const
  {
    int64_t msec = traits_helper::to_posix_duration(
        traits_helper::subtract(expiry_time_,
          traits_helper::now())).total_milliseconds();
    if (msec > (std::numeric_limits<int>::max)())
      msec = (std::numeric_limits<int>::max)();
    else if (msec < 0)
      msec = 0;
    return static_cast<int>(msec);
  }

  template <typename EndpointSequence>
  void connect_to_endpoints(const EndpointSequence& endpoints)
  {
    this->connect_to_endpoints(endpoints.begin(), endpoints.end());
  }

  template <typename EndpointIterator>
  void connect_to_endpoints(EndpointIterator begin, EndpointIterator end)
  {



    if (ec_)
      return;

    ec_ = boost::asio::error::not_found;
    for (EndpointIterator i = begin; i != end; ++i)
    {

      if (traits_helper::less_than(expiry_time_, traits_helper::now()))
      {
        ec_ = boost::asio::error::timed_out;
        return;
      }


      typename Protocol::endpoint ep(*i);
      socket().close(ec_);
      socket().open(ep.protocol(), ec_);
      if (ec_)
        continue;


      if (!socket().native_non_blocking())
        socket().native_non_blocking(true, ec_);
      detail::socket_ops::connect(socket().native_handle(),
          ep.data(), ep.size(), ec_);


      if (!ec_)
        return;


      if (ec_ != boost::asio::error::in_progress
          && ec_ != boost::asio::error::would_block)
        continue;


      if (detail::socket_ops::poll_connect(
            socket().native_handle(), timeout(), ec_) < 0)
        continue;


      int connect_error = 0;
      size_t connect_error_len = sizeof(connect_error);
      if (detail::socket_ops::getsockopt(socket().native_handle(), 0,
            1, 4, &connect_error, &connect_error_len, ec_)
          == detail::socket_error_retval)
        return;


      ec_ = boost::system::error_code(connect_error,
          boost::asio::error::get_system_category());
      if (!ec_)
        return;
    }

  }


  static time_point max_expiry_time()
  {





    return (time_point::max)();


  }

  enum { putback_max = 8 };
  boost::system::error_code ec_;
  time_point expiry_time_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 698 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {



template <typename Protocol ,
    typename Clock, typename WaitTraits >
class socket_iostream_base
{
protected:
  socket_iostream_base()
  {
  }


  socket_iostream_base(socket_iostream_base&& other)
    : streambuf_(std::move(other.streambuf_))
  {
  }

  socket_iostream_base(basic_stream_socket<Protocol> s)
    : streambuf_(std::move(s))
  {
  }

  socket_iostream_base& operator=(socket_iostream_base&& other)
  {
    streambuf_ = std::move(other.streambuf_);
    return *this;
  }


  basic_socket_streambuf<Protocol ,
    Clock, WaitTraits > streambuf_;
};

}





template <typename Protocol
    ,







    typename Clock = chrono::steady_clock,
    typename WaitTraits = wait_traits<Clock>
    >


class basic_socket_iostream;
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
template <typename Protocol ,
    typename Clock, typename WaitTraits >

class basic_socket_iostream
  : private detail::socket_iostream_base<Protocol
        , Clock, WaitTraits >,
    public std::basic_iostream<char>
{
private:







  typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;



public:

  typedef Protocol protocol_type;


  typedef typename Protocol::endpoint endpoint_type;


  typedef Clock clock_type;
# 194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
  typedef typename traits_helper::time_type time_type;
  typedef typename traits_helper::duration_type duration_type;

  typedef typename traits_helper::time_type time_point;
  typedef typename traits_helper::duration_type duration;



  basic_socket_iostream()
    : std::basic_iostream<char>(
        &this->detail::socket_iostream_base<
          Protocol , Clock,
          WaitTraits >::streambuf_)
  {
    this->setf(std::ios_base::unitbuf);
  }



  explicit basic_socket_iostream(basic_stream_socket<protocol_type> s)
    : detail::socket_iostream_base<
        Protocol , Clock,
        WaitTraits >(std::move(s)),
      std::basic_iostream<char>(
        &this->detail::socket_iostream_base<
          Protocol , Clock,
          WaitTraits >::streambuf_)
  {
    this->setf(std::ios_base::unitbuf);
  }




  basic_socket_iostream(basic_socket_iostream&& other)
    : detail::socket_iostream_base<
        Protocol , Clock,
        WaitTraits >(std::move(other)),
      std::basic_iostream<char>(std::move(other))
  {
    this->set_rdbuf(&this->detail::socket_iostream_base<
          Protocol , Clock,
          WaitTraits >::streambuf_);
  }


  basic_socket_iostream& operator=(basic_socket_iostream&& other)
  {
    std::basic_iostream<char>::operator=(std::move(other));
    detail::socket_iostream_base<
        Protocol , Clock,
        WaitTraits >::operator=(std::move(other));
    return *this;
  }
# 262 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
  template <typename... T>
  explicit basic_socket_iostream(T... x)
    : std::basic_iostream<char>(
        &this->detail::socket_iostream_base<
          Protocol , Clock,
          WaitTraits >::streambuf_)
  {
    this->setf(std::ios_base::unitbuf);
    if (rdbuf()->connect(x...) == 0)
      this->setstate(std::ios_base::failbit);
  }
# 287 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
  template <typename... T>
  void connect(T... x)
  {
    if (rdbuf()->connect(x...) == 0)
      this->setstate(std::ios_base::failbit);
  }





  void close()
  {
    if (rdbuf()->close() == 0)
      this->setstate(std::ios_base::failbit);
  }


  basic_socket_streambuf<Protocol ,
    Clock, WaitTraits >* rdbuf() const
  {
    return const_cast<basic_socket_streambuf<Protocol ,
      Clock, WaitTraits >*>(
        &this->detail::socket_iostream_base<
          Protocol , Clock,
          WaitTraits >::streambuf_);
  }


  basic_socket<Protocol >& socket()
  {
    return rdbuf()->socket();
  }
# 333 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
  const boost::system::error_code& error() const
  {
    return rdbuf()->error();
  }







  time_point expires_at() const
  {
    return rdbuf()->expires_at();
  }






  time_point expiry() const
  {
    return rdbuf()->expiry();
  }
# 368 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
  void expires_at(const time_point& expiry_time)
  {
    rdbuf()->expires_at(expiry_time);
  }
# 382 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
  void expires_after(const duration& expiry_time)
  {
    rdbuf()->expires_after(expiry_time);
  }






  duration expires_from_now() const
  {
    return rdbuf()->expires_from_now();
  }
# 407 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 3 4
  void expires_from_now(const duration& expiry_time)
  {
    rdbuf()->expires_from_now(expiry_time);
  }


private:

  basic_socket_iostream(const basic_socket_iostream&) = delete;
  basic_socket_iostream& operator=(
      const basic_socket_iostream&) = delete;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 424 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf_fwd.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf_fwd.hpp" 3 4
namespace boost {
namespace asio {

template <typename Allocator = std::allocator<char> >
class basic_streambuf;

template <typename Allocator = std::allocator<char> >
class basic_streambuf_ref;

}
}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 2 3 4

namespace boost {
namespace asio {
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
template <typename Allocator>

class basic_streambuf
  : public std::streambuf,
    private noncopyable
{
public:







  typedef const_buffers_1 const_buffers_type;
  typedef mutable_buffers_1 mutable_buffers_type;







  explicit basic_streambuf(
      std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
      const Allocator& allocator = Allocator())
    : max_size_(maximum_size),
      buffer_(allocator)
  {
    std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
    buffer_.resize((std::max<std::size_t>)(pend, 1));
    setg(&buffer_[0], &buffer_[0], &buffer_[0]);
    setp(&buffer_[0], &buffer_[0] + pend);
  }
# 159 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
  std::size_t size() const noexcept
  {
    return pptr() - gptr();
  }






  std::size_t max_size() const noexcept
  {
    return max_size_;
  }






  std::size_t capacity() const noexcept
  {
    return buffer_.capacity();
  }
# 193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
  const_buffers_type data() const noexcept
  {
    return boost::asio::buffer(boost::asio::const_buffer(gptr(),
          (pptr() - gptr()) * sizeof(char_type)));
  }
# 215 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
  mutable_buffers_type prepare(std::size_t n)
  {
    reserve(n);
    return boost::asio::buffer(boost::asio::mutable_buffer(
          pptr(), n * sizeof(char_type)));
  }
# 234 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
  void commit(std::size_t n)
  {
    n = std::min<std::size_t>(n, epptr() - pptr());
    pbump(static_cast<int>(n));
    setg(eback(), gptr(), pptr());
  }
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
  void consume(std::size_t n)
  {
    if (egptr() < pptr())
      setg(&buffer_[0], gptr(), pptr());
    if (gptr() + n > pptr())
      n = pptr() - gptr();
    gbump(static_cast<int>(n));
  }

protected:
  enum { buffer_delta = 128 };





  int_type underflow()
  {
    if (gptr() < pptr())
    {
      setg(&buffer_[0], gptr(), pptr());
      return traits_type::to_int_type(*gptr());
    }
    else
    {
      return traits_type::eof();
    }
  }
# 284 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 3 4
  int_type overflow(int_type c)
  {
    if (!traits_type::eq_int_type(c, traits_type::eof()))
    {
      if (pptr() == epptr())
      {
        std::size_t buffer_size = pptr() - gptr();
        if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
        {
          reserve(max_size_ - buffer_size);
        }
        else
        {
          reserve(buffer_delta);
        }
      }

      *pptr() = traits_type::to_char_type(c);
      pbump(1);
      return c;
    }

    return traits_type::not_eof(c);
  }

  void reserve(std::size_t n)
  {

    std::size_t gnext = gptr() - &buffer_[0];
    std::size_t pnext = pptr() - &buffer_[0];
    std::size_t pend = epptr() - &buffer_[0];


    if (n <= pend - pnext)
    {
      return;
    }


    if (gnext > 0)
    {
      pnext -= gnext;
      std::memmove(&buffer_[0], &buffer_[0] + gnext, pnext);
    }


    if (n > pend - pnext)
    {
      if (n <= max_size_ && pnext <= max_size_ - n)
      {
        pend = pnext + n;
        buffer_.resize((std::max<std::size_t>)(pend, 1));
      }
      else
      {
        std::length_error ex("boost::asio::streambuf too long");
        boost::asio::detail::throw_exception(ex);
      }
    }


    setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
    setp(&buffer_[0] + pnext, &buffer_[0] + pend);
  }

private:
  std::size_t max_size_;
  std::vector<char_type, Allocator> buffer_;


  friend std::size_t read_size_helper(
      basic_streambuf& sb, std::size_t max_size)
  {
    return std::min<std::size_t>(
        std::max<std::size_t>(512, sb.buffer_.capacity() - sb.size()),
        std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
  }
};





template <typename Allocator>

class basic_streambuf_ref
{
public:

  typedef typename basic_streambuf<Allocator>::const_buffers_type
    const_buffers_type;


  typedef typename basic_streambuf<Allocator>::mutable_buffers_type
    mutable_buffers_type;


  explicit basic_streambuf_ref(basic_streambuf<Allocator>& sb)
    : sb_(sb)
  {
  }


  basic_streambuf_ref(const basic_streambuf_ref& other) noexcept
    : sb_(other.sb_)
  {
  }



  basic_streambuf_ref(basic_streambuf_ref&& other) noexcept
    : sb_(other.sb_)
  {
  }



  std::size_t size() const noexcept
  {
    return sb_.size();
  }


  std::size_t max_size() const noexcept
  {
    return sb_.max_size();
  }


  std::size_t capacity() const noexcept
  {
    return sb_.capacity();
  }


  const_buffers_type data() const noexcept
  {
    return sb_.data();
  }



  mutable_buffers_type prepare(std::size_t n)
  {
    return sb_.prepare(n);
  }


  void commit(std::size_t n)
  {
    return sb_.commit(n);
  }


  void consume(std::size_t n)
  {
    return sb_.consume(n);
  }

private:
  basic_streambuf<Allocator>& sb_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 451 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/basic_streambuf.hpp" 2 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream_fwd.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream_fwd.hpp" 3 4
namespace boost {
namespace asio {

template <typename Stream>
class buffered_read_stream;

}
}
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_resize_guard.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_resize_guard.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_resize_guard.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


template <typename Buffer>
class buffer_resize_guard
{
public:

  buffer_resize_guard(Buffer& buffer)
    : buffer_(buffer),
      old_size_(buffer.size())
  {
  }


  ~buffer_resize_guard()
  {
    if (old_size_ != (std::numeric_limits<size_t>::max)())
    {
      buffer_.resize(old_size_);
    }
  }


  void commit()
  {
    old_size_ = (std::numeric_limits<size_t>::max)();
  }

private:

  Buffer& buffer_;


  size_t old_size_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffer_resize_guard.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffered_stream_storage.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffered_stream_storage.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class buffered_stream_storage
{
public:

  typedef unsigned char byte_type;


  typedef std::size_t size_type;


  explicit buffered_stream_storage(std::size_t buffer_capacity)
    : begin_offset_(0),
      end_offset_(0),
      buffer_(buffer_capacity)
  {
  }


  void clear()
  {
    begin_offset_ = 0;
    end_offset_ = 0;
  }


  mutable_buffer data()
  {
    return boost::asio::buffer(buffer_) + begin_offset_;
  }


  const_buffer data() const
  {
    return boost::asio::buffer(buffer_) + begin_offset_;
  }


  bool empty() const
  {
    return begin_offset_ == end_offset_;
  }


  size_type size() const
  {
    return end_offset_ - begin_offset_;
  }


  void resize(size_type length)
  {
    (static_cast<void> (0));
    if (begin_offset_ + length <= capacity())
    {
      end_offset_ = begin_offset_ + length;
    }
    else
    {
      using namespace std;
      memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
      end_offset_ = length;
      begin_offset_ = 0;
    }
  }


  size_type capacity() const
  {
    return buffer_.size();
  }


  void consume(size_type count)
  {
    (static_cast<void> (0));
    begin_offset_ += count;
    if (empty())
      clear();
  }

private:

  size_type begin_offset_;


  size_type end_offset_;


  std::vector<byte_type> buffer_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 2 3 4

namespace boost {
namespace asio {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 3 4
template <typename Stream>
class buffered_read_stream
  : private noncopyable
{
public:

  typedef typename remove_reference<Stream>::type next_layer_type;


  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;


  typedef typename lowest_layer_type::executor_type executor_type;





  static const std::size_t default_buffer_size = 1024;



  template <typename Arg>
  explicit buffered_read_stream(Arg& a)
    : next_layer_(a),
      storage_(default_buffer_size)
  {
  }


  template <typename Arg>
  buffered_read_stream(Arg& a, std::size_t buffer_size)
    : next_layer_(a),
      storage_(buffer_size)
  {
  }


  next_layer_type& next_layer()
  {
    return next_layer_;
  }


  lowest_layer_type& lowest_layer()
  {
    return next_layer_.lowest_layer();
  }


  const lowest_layer_type& lowest_layer() const
  {
    return next_layer_.lowest_layer();
  }


  executor_type get_executor() noexcept
  {
    return next_layer_.lowest_layer().get_executor();
  }




  boost::asio::io_context& get_io_context()
  {
    return next_layer_.get_io_context();
  }



  boost::asio::io_context& get_io_service()
  {
    return next_layer_.get_io_service();
  }



  void close()
  {
    next_layer_.close();
  }


  boost::system::error_code close(boost::system::error_code& ec)
  {
    next_layer_.close(ec);
    return ec;
  }



  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers)
  {
    return next_layer_.write_some(buffers);
  }



  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return next_layer_.write_some(buffers, ec);
  }



  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_write_some(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {
    return next_layer_.async_write_some(buffers,
        static_cast<WriteHandler&&>(handler));
  }



  std::size_t fill();



  std::size_t fill(boost::system::error_code& ec);


  template <typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_fill(ReadHandler&& handler);



  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers);



  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers,
      boost::system::error_code& ec);



  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_read_some(const MutableBufferSequence& buffers,
      ReadHandler&& handler);



  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers);



  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers,
      boost::system::error_code& ec);


  std::size_t in_avail()
  {
    return storage_.size();
  }


  std::size_t in_avail(boost::system::error_code& ec)
  {
    ec = boost::system::error_code();
    return storage_.size();
  }

private:


  template <typename MutableBufferSequence>
  std::size_t copy(const MutableBufferSequence& buffers)
  {
    std::size_t bytes_copied = boost::asio::buffer_copy(
        buffers, storage_.data(), storage_.size());
    storage_.consume(bytes_copied);
    return bytes_copied;
  }




  template <typename MutableBufferSequence>
  std::size_t peek_copy(const MutableBufferSequence& buffers)
  {
    return boost::asio::buffer_copy(buffers, storage_.data(), storage_.size());
  }


  Stream next_layer_;


  detail::buffered_stream_storage storage_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 256 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_read_stream.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_read_stream.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_read_stream.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename Stream>
std::size_t buffered_read_stream<Stream>::fill()
{
  detail::buffer_resize_guard<detail::buffered_stream_storage>
    resize_guard(storage_);
  std::size_t previous_size = storage_.size();
  storage_.resize(storage_.capacity());
  storage_.resize(previous_size + next_layer_.read_some(buffer(
          storage_.data() + previous_size,
          storage_.size() - previous_size)));
  resize_guard.commit();
  return storage_.size() - previous_size;
}

template <typename Stream>
std::size_t buffered_read_stream<Stream>::fill(boost::system::error_code& ec)
{
  detail::buffer_resize_guard<detail::buffered_stream_storage>
    resize_guard(storage_);
  std::size_t previous_size = storage_.size();
  storage_.resize(storage_.capacity());
  storage_.resize(previous_size + next_layer_.read_some(buffer(
          storage_.data() + previous_size,
          storage_.size() - previous_size),
        ec));
  resize_guard.commit();
  return storage_.size() - previous_size;
}

namespace detail
{
  template <typename ReadHandler>
  class buffered_fill_handler
  {
  public:
    buffered_fill_handler(detail::buffered_stream_storage& storage,
        std::size_t previous_size, ReadHandler& handler)
      : storage_(storage),
        previous_size_(previous_size),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    buffered_fill_handler(const buffered_fill_handler& other)
      : storage_(other.storage_),
        previous_size_(other.previous_size_),
        handler_(other.handler_)
    {
    }

    buffered_fill_handler(buffered_fill_handler&& other)
      : storage_(other.storage_),
        previous_size_(other.previous_size_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        const std::size_t bytes_transferred)
    {
      storage_.resize(previous_size_ + bytes_transferred);
      handler_(ec, bytes_transferred);
    }


    detail::buffered_stream_storage& storage_;
    std::size_t previous_size_;
    ReadHandler handler_;
  };

  template <typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      buffered_fill_handler<ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      buffered_fill_handler<ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename ReadHandler>
  inline bool asio_handler_is_continuation(
      buffered_fill_handler<ReadHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      buffered_fill_handler<ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      buffered_fill_handler<ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::buffered_fill_handler<ReadHandler>, Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(const detail::buffered_fill_handler<ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename ReadHandler, typename Executor>
struct associated_executor<
    detail::buffered_fill_handler<ReadHandler>, Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(const detail::buffered_fill_handler<ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename Stream>
template <typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

buffered_read_stream<Stream>::async_fill(
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  std::size_t previous_size = storage_.size();
  storage_.resize(storage_.capacity());
  next_layer_.async_read_some(
      buffer(
        storage_.data() + previous_size,
        storage_.size() - previous_size),
      detail::buffered_fill_handler<typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                   >(
        storage_, previous_size, init.completion_handler));

  return init.result.get();
}

template <typename Stream>
template <typename MutableBufferSequence>
std::size_t buffered_read_stream<Stream>::read_some(
    const MutableBufferSequence& buffers)
{
  using boost::asio::buffer_size;
  if (buffer_size(buffers) == 0)
    return 0;

  if (storage_.empty())
    this->fill();

  return this->copy(buffers);
}

template <typename Stream>
template <typename MutableBufferSequence>
std::size_t buffered_read_stream<Stream>::read_some(
    const MutableBufferSequence& buffers, boost::system::error_code& ec)
{
  ec = boost::system::error_code();

  using boost::asio::buffer_size;
  if (buffer_size(buffers) == 0)
    return 0;

  if (storage_.empty() && !this->fill(ec))
    return 0;

  return this->copy(buffers);
}

namespace detail
{
  template <typename MutableBufferSequence, typename ReadHandler>
  class buffered_read_some_handler
  {
  public:
    buffered_read_some_handler(detail::buffered_stream_storage& storage,
        const MutableBufferSequence& buffers, ReadHandler& handler)
      : storage_(storage),
        buffers_(buffers),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


      buffered_read_some_handler(const buffered_read_some_handler& other)
        : storage_(other.storage_),
          buffers_(other.buffers_),
          handler_(other.handler_)
      {
      }

      buffered_read_some_handler(buffered_read_some_handler&& other)
        : storage_(other.storage_),
          buffers_(other.buffers_),
          handler_(static_cast<ReadHandler&&>(other.handler_))
      {
      }


    void operator()(const boost::system::error_code& ec, std::size_t)
    {
      if (ec || storage_.empty())
      {
        const std::size_t length = 0;
        handler_(ec, length);
      }
      else
      {
        const std::size_t bytes_copied = boost::asio::buffer_copy(
            buffers_, storage_.data(), storage_.size());
        storage_.consume(bytes_copied);
        handler_(ec, bytes_copied);
      }
    }


    detail::buffered_stream_storage& storage_;
    MutableBufferSequence buffers_;
    ReadHandler handler_;
  };

  template <typename MutableBufferSequence, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      buffered_read_some_handler<
        MutableBufferSequence, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename MutableBufferSequence, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      buffered_read_some_handler<
        MutableBufferSequence, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename MutableBufferSequence, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      buffered_read_some_handler<
        MutableBufferSequence, ReadHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename MutableBufferSequence,
      typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      buffered_read_some_handler<
        MutableBufferSequence, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename MutableBufferSequence,
      typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      buffered_read_some_handler<
        MutableBufferSequence, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename MutableBufferSequence,
    typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::buffered_read_some_handler<
        MutableBufferSequence, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename MutableBufferSequence,
    typename ReadHandler, typename Executor>
struct associated_executor<
    detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::buffered_read_some_handler<
        MutableBufferSequence, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename Stream>
template <typename MutableBufferSequence, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

buffered_read_stream<Stream>::async_read_some(
    const MutableBufferSequence& buffers,
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  using boost::asio::buffer_size;
  if (buffer_size(buffers) == 0 || !storage_.empty())
  {
    next_layer_.async_read_some(mutable_buffers_1(0, 0),
        detail::buffered_read_some_handler<
          MutableBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                       >(
            storage_, buffers, init.completion_handler));
  }
  else
  {
    this->async_fill(detail::buffered_read_some_handler<
          MutableBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                       >(
            storage_, buffers, init.completion_handler));
  }

  return init.result.get();
}

template <typename Stream>
template <typename MutableBufferSequence>
std::size_t buffered_read_stream<Stream>::peek(
    const MutableBufferSequence& buffers)
{
  if (storage_.empty())
    this->fill();
  return this->peek_copy(buffers);
}

template <typename Stream>
template <typename MutableBufferSequence>
std::size_t buffered_read_stream<Stream>::peek(
    const MutableBufferSequence& buffers, boost::system::error_code& ec)
{
  ec = boost::system::error_code();
  if (storage_.empty() && !this->fill(ec))
    return 0;
  return this->peek_copy(buffers);
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 430 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_read_stream.hpp" 2 3 4
# 258 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_read_stream.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream_fwd.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream_fwd.hpp" 3 4
namespace boost {
namespace asio {

template <typename Stream>
class buffered_stream;

}
}
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream_fwd.hpp" 1 3 4
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream_fwd.hpp" 3 4
namespace boost {
namespace asio {

template <typename Stream>
class buffered_write_stream;

}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/completion_condition.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/completion_condition.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/completion_condition.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail {


enum default_max_transfer_size_t { default_max_transfer_size = 65536 };



inline std::size_t adapt_completion_condition_result(bool result)
{
  return result ? 0 : default_max_transfer_size;
}




inline std::size_t adapt_completion_condition_result(std::size_t result)
{
  return result;
}

class transfer_all_t
{
public:
  typedef std::size_t result_type;

  template <typename Error>
  std::size_t operator()(const Error& err, std::size_t)
  {
    return !!err ? 0 : default_max_transfer_size;
  }
};

class transfer_at_least_t
{
public:
  typedef std::size_t result_type;

  explicit transfer_at_least_t(std::size_t minimum)
    : minimum_(minimum)
  {
  }

  template <typename Error>
  std::size_t operator()(const Error& err, std::size_t bytes_transferred)
  {
    return (!!err || bytes_transferred >= minimum_)
      ? 0 : default_max_transfer_size;
  }

private:
  std::size_t minimum_;
};

class transfer_exactly_t
{
public:
  typedef std::size_t result_type;

  explicit transfer_exactly_t(std::size_t size)
    : size_(size)
  {
  }

  template <typename Error>
  std::size_t operator()(const Error& err, std::size_t bytes_transferred)
  {
    return (!!err || bytes_transferred >= size_) ? 0 :
      (size_ - bytes_transferred < default_max_transfer_size
        ? size_ - bytes_transferred : std::size_t(default_max_transfer_size));
  }

private:
  std::size_t size_;
};

}
# 139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/completion_condition.hpp" 3 4
inline detail::transfer_all_t transfer_all()
{
  return detail::transfer_all_t();
}
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/completion_condition.hpp" 3 4
inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
{
  return detail::transfer_at_least_t(minimum);
}
# 207 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/completion_condition.hpp" 3 4
inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
{
  return detail::transfer_exactly_t(size);
}




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 219 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/completion_condition.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 2 3 4

namespace boost {
namespace asio {
# 76 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type* = 0);
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename ConstBufferSequence>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type* = 0);
# 171 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename ConstBufferSequence,
    typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type* = 0);
# 218 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename ConstBufferSequence,
    typename CompletionCondition>
std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type* = 0);
# 253 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename DynamicBuffer>
std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 287 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename DynamicBuffer>
std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 377 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
# 444 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename Allocator>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
    boost::system::error_code& ec);
# 483 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename Allocator,
    typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition);
# 524 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename SyncWriteStream, typename Allocator,
    typename CompletionCondition>
std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition, boost::system::error_code& ec);
# 593 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename AsyncWriteStream, typename ConstBufferSequence,
    typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
    WriteHandler&& handler,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type* = 0);
# 670 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename AsyncWriteStream, typename ConstBufferSequence,
    typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition,
    WriteHandler&& handler,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type* = 0);
# 724 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename AsyncWriteStream,
    typename DynamicBuffer, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s,
    DynamicBuffer&& buffers,
    WriteHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 792 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename AsyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    WriteHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 848 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
    WriteHandler&& handler);
# 909 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 3 4
template <typename AsyncWriteStream, typename Allocator,
    typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition,
    WriteHandler&& handler);






}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 926 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/base_from_completion_cond.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/base_from_completion_cond.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/base_from_completion_cond.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename CompletionCondition>
class base_from_completion_cond
{
protected:
  explicit base_from_completion_cond(CompletionCondition completion_condition)
    : completion_condition_(completion_condition)
  {
  }

  std::size_t check_for_completion(
      const boost::system::error_code& ec,
      std::size_t total_transferred)
  {
    return detail::adapt_completion_condition_result(
        completion_condition_(ec, total_transferred));
  }

private:
  CompletionCondition completion_condition_;
};

template <>
class base_from_completion_cond<transfer_all_t>
{
protected:
  explicit base_from_completion_cond(transfer_all_t)
  {
  }

  static std::size_t check_for_completion(
      const boost::system::error_code& ec,
      std::size_t total_transferred)
  {
    return transfer_all_t()(ec, total_transferred);
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 69 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/base_from_completion_cond.hpp" 2 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/consuming_buffers.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/consuming_buffers.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/consuming_buffers.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


template <typename Buffers>
struct prepared_buffers_max
{
  enum { value = buffer_sequence_adapter_base::max_buffers };
};

template <typename Elem, std::size_t N>
struct prepared_buffers_max<boost::array<Elem, N> >
{
  enum { value = N };
};



template <typename Elem, std::size_t N>
struct prepared_buffers_max<std::array<Elem, N> >
{
  enum { value = N };
};




template <typename Buffer, std::size_t MaxBuffers>
struct prepared_buffers
{
  typedef Buffer value_type;
  typedef const Buffer* const_iterator;

  enum { max_buffers = MaxBuffers < 16 ? MaxBuffers : 16 };

  prepared_buffers() : count(0) {}
  const_iterator begin() const { return elems; }
  const_iterator end() const { return elems + count; }

  Buffer elems[max_buffers];
  std::size_t count;
};


template <typename Buffer, typename Buffers, typename Buffer_Iterator>
class consuming_buffers
{
public:
  typedef prepared_buffers<Buffer, prepared_buffers_max<Buffers>::value>
    prepared_buffers_type;


  explicit consuming_buffers(const Buffers& buffers)
    : buffers_(buffers),
      total_consumed_(0),
      next_elem_(0),
      next_elem_offset_(0)
  {
    using boost::asio::buffer_size;
    total_size_ = buffer_size(buffers);
  }


  bool empty() const
  {
    return total_consumed_ >= total_size_;
  }


  prepared_buffers_type prepare(std::size_t max_size)
  {
    prepared_buffers_type result;

    Buffer_Iterator next = boost::asio::buffer_sequence_begin(buffers_);
    Buffer_Iterator end = boost::asio::buffer_sequence_end(buffers_);

    std::advance(next, next_elem_);
    std::size_t elem_offset = next_elem_offset_;
    while (next != end && max_size > 0 && (result.count) < result.max_buffers)
    {
      Buffer next_buf = Buffer(*next) + elem_offset;
      result.elems[result.count] = boost::asio::buffer(next_buf, max_size);
      max_size -= result.elems[result.count].size();
      elem_offset = 0;
      if (result.elems[result.count].size() > 0)
        ++result.count;
      ++next;
    }

    return result;
  }


  void consume(std::size_t size)
  {
    total_consumed_ += size;

    Buffer_Iterator next = boost::asio::buffer_sequence_begin(buffers_);
    Buffer_Iterator end = boost::asio::buffer_sequence_end(buffers_);

    std::advance(next, next_elem_);
    while (next != end && size > 0)
    {
      Buffer next_buf = Buffer(*next) + next_elem_offset_;
      if (size < next_buf.size())
      {
        next_elem_offset_ += size;
        size = 0;
      }
      else
      {
        size -= next_buf.size();
        next_elem_offset_ = 0;
        ++next_elem_;
        ++next;
      }
    }
  }


  std::size_t total_consumed() const
  {
    return total_consumed_;
  }

private:
  Buffers buffers_;
  std::size_t total_size_;
  std::size_t total_consumed_;
  std::size_t next_elem_;
  std::size_t next_elem_offset_;
};


template <typename Buffer>
class consuming_single_buffer
{
public:

  template <typename Buffer1>
  explicit consuming_single_buffer(const Buffer1& buffer)
    : buffer_(buffer),
      total_consumed_(0)
  {
  }


  bool empty() const
  {
    return total_consumed_ >= buffer_.size();
  }


  Buffer prepare(std::size_t max_size)
  {
    return boost::asio::buffer(buffer_ + total_consumed_, max_size);
  }


  void consume(std::size_t size)
  {
    total_consumed_ += size;
  }


  std::size_t total_consumed() const
  {
    return total_consumed_;
  }

private:
  Buffer buffer_;
  std::size_t total_consumed_;
};

template <>
class consuming_buffers<mutable_buffer, mutable_buffer, const mutable_buffer*>
  : public consuming_single_buffer<mutable_buffers_1>
{
public:
  explicit consuming_buffers(const mutable_buffer& buffer)
    : consuming_single_buffer<mutable_buffers_1>(buffer)
  {
  }
};

template <>
class consuming_buffers<const_buffer, mutable_buffer, const mutable_buffer*>
  : public consuming_single_buffer<const_buffers_1>
{
public:
  explicit consuming_buffers(const mutable_buffer& buffer)
    : consuming_single_buffer<const_buffers_1>(buffer)
  {
  }
};

template <>
class consuming_buffers<const_buffer, const_buffer, const const_buffer*>
  : public consuming_single_buffer<const_buffers_1>
{
public:
  explicit consuming_buffers(const const_buffer& buffer)
    : consuming_single_buffer<const_buffers_1>(buffer)
  {
  }
};



template <>
class consuming_buffers<mutable_buffer,
    mutable_buffers_1, const mutable_buffer*>
  : public consuming_single_buffer<mutable_buffers_1>
{
public:
  explicit consuming_buffers(const mutable_buffers_1& buffer)
    : consuming_single_buffer<mutable_buffers_1>(buffer)
  {
  }
};

template <>
class consuming_buffers<const_buffer, mutable_buffers_1, const mutable_buffer*>
  : public consuming_single_buffer<const_buffers_1>
{
public:
  explicit consuming_buffers(const mutable_buffers_1& buffer)
    : consuming_single_buffer<const_buffers_1>(buffer)
  {
  }
};

template <>
class consuming_buffers<const_buffer, const_buffers_1, const const_buffer*>
  : public consuming_single_buffer<const_buffers_1>
{
public:
  explicit consuming_buffers(const const_buffers_1& buffer)
    : consuming_single_buffer<const_buffers_1>(buffer)
  {
  }
};



template <typename Buffer, typename Elem>
class consuming_buffers<Buffer, boost::array<Elem, 2>,
    typename boost::array<Elem, 2>::const_iterator>
{
public:

  explicit consuming_buffers(const boost::array<Elem, 2>& buffers)
    : buffers_(buffers),
      total_consumed_(0)
  {
  }


  bool empty() const
  {
    return total_consumed_ >=
      Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
  }


  boost::array<Buffer, 2> prepare(std::size_t max_size)
  {
    boost::array<Buffer, 2> result = {{
      Buffer(buffers_[0]), Buffer(buffers_[1]) }};
    std::size_t buffer0_size = result[0].size();
    result[0] = boost::asio::buffer(result[0] + total_consumed_, max_size);
    result[1] = boost::asio::buffer(
        result[1] + (total_consumed_ < buffer0_size
          ? 0 : total_consumed_ - buffer0_size),
        max_size - result[0].size());
    return result;
  }


  void consume(std::size_t size)
  {
    total_consumed_ += size;
  }


  std::size_t total_consumed() const
  {
    return total_consumed_;
  }

private:
  boost::array<Elem, 2> buffers_;
  std::size_t total_consumed_;
};



template <typename Buffer, typename Elem>
class consuming_buffers<Buffer, std::array<Elem, 2>,
    typename std::array<Elem, 2>::const_iterator>
{
public:

  explicit consuming_buffers(const std::array<Elem, 2>& buffers)
    : buffers_(buffers),
      total_consumed_(0)
  {
  }


  bool empty() const
  {
    return total_consumed_ >=
      Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
  }


  std::array<Buffer, 2> prepare(std::size_t max_size)
  {
    std::array<Buffer, 2> result = {{
      Buffer(buffers_[0]), Buffer(buffers_[1]) }};
    std::size_t buffer0_size = result[0].size();
    result[0] = boost::asio::buffer(result[0] + total_consumed_, max_size);
    result[1] = boost::asio::buffer(
        result[1] + (total_consumed_ < buffer0_size
          ? 0 : total_consumed_ - buffer0_size),
        max_size - result[0].size());
    return result;
  }


  void consume(std::size_t size)
  {
    total_consumed_ += size;
  }


  std::size_t total_consumed() const
  {
    return total_consumed_;
  }

private:
  std::array<Elem, 2> buffers_;
  std::size_t total_consumed_;
};





template <typename Buffer>
class consuming_buffers<Buffer, null_buffers, const mutable_buffer*>
  : public boost::asio::null_buffers
{
public:
  consuming_buffers(const null_buffers&)
  {

  }

  bool empty()
  {
    return false;
  }

  null_buffers prepare(std::size_t)
  {
    return null_buffers();
  }

  void consume(std::size_t)
  {

  }

  std::size_t total_consumed() const
  {
    return 0;
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/consuming_buffers.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/dependent_type.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/dependent_type.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/dependent_type.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename DependsOn, typename T>
struct dependent_type
{
  typedef T type;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/dependent_type.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  template <typename SyncWriteStream, typename ConstBufferSequence,
      typename ConstBufferIterator, typename CompletionCondition>
  std::size_t write_buffer_sequence(SyncWriteStream& s,
      const ConstBufferSequence& buffers, const ConstBufferIterator&,
      CompletionCondition completion_condition, boost::system::error_code& ec)
  {
    ec = boost::system::error_code();
    boost::asio::detail::consuming_buffers<const_buffer,
        ConstBufferSequence, ConstBufferIterator> tmp(buffers);
    while (!tmp.empty())
    {
      if (std::size_t max_size = detail::adapt_completion_condition_result(
            completion_condition(ec, tmp.total_consumed())))
        tmp.consume(s.write_some(tmp.prepare(max_size), ec));
      else
        break;
    }
    return tmp.total_consumed();;
  }
}

template <typename SyncWriteStream, typename ConstBufferSequence,
    typename CompletionCondition>
inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type*)
{
  return detail::write_buffer_sequence(s, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
}

template <typename SyncWriteStream, typename ConstBufferSequence>
inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "write");
  return bytes_transferred;
}

template <typename SyncWriteStream, typename ConstBufferSequence>
inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type*)
{
  return write(s, buffers, transfer_all(), ec);
}

template <typename SyncWriteStream, typename ConstBufferSequence,
    typename CompletionCondition>
inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
  boost::asio::detail::throw_error(ec, "write");
  return bytes_transferred;
}

template <typename SyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition>
std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  typename decay<DynamicBuffer>::type b(
      static_cast<DynamicBuffer&&>(buffers));

  std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
  b.consume(bytes_transferred);
  return bytes_transferred;
}

template <typename SyncWriteStream, typename DynamicBuffer>
inline std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write(s,
      static_cast<DynamicBuffer&&>(buffers),
      transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "write");
  return bytes_transferred;
}

template <typename SyncWriteStream, typename DynamicBuffer>
inline std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  return write(s, static_cast<DynamicBuffer&&>(buffers),
      transfer_all(), ec);
}

template <typename SyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition>
inline std::size_t write(SyncWriteStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write(s,
      static_cast<DynamicBuffer&&>(buffers),
      completion_condition, ec);
  boost::asio::detail::throw_error(ec, "write");
  return bytes_transferred;
}




template <typename SyncWriteStream, typename Allocator,
    typename CompletionCondition>
inline std::size_t write(SyncWriteStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition, boost::system::error_code& ec)
{
  return write(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec);
}

template <typename SyncWriteStream, typename Allocator>
inline std::size_t write(SyncWriteStream& s,
    boost::asio::basic_streambuf<Allocator>& b)
{
  return write(s, basic_streambuf_ref<Allocator>(b));
}

template <typename SyncWriteStream, typename Allocator>
inline std::size_t write(SyncWriteStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::system::error_code& ec)
{
  return write(s, basic_streambuf_ref<Allocator>(b), ec);
}

template <typename SyncWriteStream, typename Allocator,
    typename CompletionCondition>
inline std::size_t write(SyncWriteStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition)
{
  return write(s, basic_streambuf_ref<Allocator>(b), completion_condition);
}




namespace detail
{
  template <typename AsyncWriteStream, typename ConstBufferSequence,
      typename ConstBufferIterator, typename CompletionCondition,
      typename WriteHandler>
  class write_op
    : detail::base_from_completion_cond<CompletionCondition>
  {
  public:
    write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
        CompletionCondition completion_condition, WriteHandler& handler)
      : detail::base_from_completion_cond<
          CompletionCondition>(completion_condition),
        stream_(stream),
        buffers_(buffers),
        start_(0),
        handler_(static_cast<WriteHandler&&>(handler))
    {
    }


    write_op(const write_op& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        stream_(other.stream_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(other.handler_)
    {
    }

    write_op(write_op&& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        stream_(other.stream_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(static_cast<WriteHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, buffers_.total_consumed());
        do
        {
          stream_.async_write_some(buffers_.prepare(max_size),
              static_cast<write_op&&>(*this));
          return; default:
          buffers_.consume(bytes_transferred);
          if ((!ec && bytes_transferred == 0) || buffers_.empty())
            break;
          max_size = this->check_for_completion(ec, buffers_.total_consumed());
        } while (max_size > 0);

        handler_(ec, buffers_.total_consumed());
      }
    }


    AsyncWriteStream& stream_;
    boost::asio::detail::consuming_buffers<const_buffer,
        ConstBufferSequence, ConstBufferIterator> buffers_;
    int start_;
    WriteHandler handler_;
  };

  template <typename AsyncWriteStream, typename ConstBufferSequence,
      typename ConstBufferIterator, typename CompletionCondition,
      typename WriteHandler>
  inline void* asio_handler_allocate(std::size_t size,
      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
        CompletionCondition, WriteHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncWriteStream, typename ConstBufferSequence,
      typename ConstBufferIterator, typename CompletionCondition,
      typename WriteHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
        CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncWriteStream, typename ConstBufferSequence,
      typename ConstBufferIterator, typename CompletionCondition,
      typename WriteHandler>
  inline bool asio_handler_is_continuation(
      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
        CompletionCondition, WriteHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncWriteStream,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline void asio_handler_invoke(Function& function,
      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
        CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncWriteStream,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline void asio_handler_invoke(const Function& function,
      write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
        CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename AsyncWriteStream, typename ConstBufferSequence,
      typename ConstBufferIterator, typename CompletionCondition,
      typename WriteHandler>
  inline void start_write_buffer_sequence_op(AsyncWriteStream& stream,
      const ConstBufferSequence& buffers, const ConstBufferIterator&,
      CompletionCondition completion_condition, WriteHandler& handler)
  {
    detail::write_op<AsyncWriteStream, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>(
        stream, buffers, completion_condition, handler)(
          boost::system::error_code(), 0, 1);
  }

}



template <typename AsyncWriteStream, typename ConstBufferSequence,
    typename ConstBufferIterator, typename CompletionCondition,
    typename WriteHandler, typename Allocator>
struct associated_allocator<
    detail::write_op<AsyncWriteStream, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>,
    Allocator>
{
  typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  static type get(
      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncWriteStream, typename ConstBufferSequence,
    typename ConstBufferIterator, typename CompletionCondition,
    typename WriteHandler, typename Executor>
struct associated_executor<
    detail::write_op<AsyncWriteStream, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>,
    Executor>
{
  typedef typename associated_executor<WriteHandler, Executor>::type type;

  static type get(
      const detail::write_op<AsyncWriteStream, ConstBufferSequence,
        ConstBufferIterator, CompletionCondition, WriteHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncWriteStream, typename ConstBufferSequence,
  typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition,
    WriteHandler&& handler,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_write_buffer_sequence_op(s, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition,
      init.completion_handler);

  return init.result.get();
}

template <typename AsyncWriteStream, typename ConstBufferSequence,
    typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
    WriteHandler&& handler,
    typename enable_if<
      is_const_buffer_sequence<ConstBufferSequence>::value
    >::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_write_buffer_sequence_op(s, buffers,
      boost::asio::buffer_sequence_begin(buffers), transfer_all(),
      init.completion_handler);

  return init.result.get();
}

namespace detail
{
  template <typename AsyncWriteStream, typename DynamicBuffer,
      typename CompletionCondition, typename WriteHandler>
  class write_dynbuf_op
  {
  public:
    template <typename BufferSequence>
    write_dynbuf_op(AsyncWriteStream& stream,
        BufferSequence&& buffers,
        CompletionCondition completion_condition, WriteHandler& handler)
      : stream_(stream),
        buffers_(static_cast<BufferSequence&&>(buffers)),
        completion_condition_(
          static_cast<CompletionCondition&&>(completion_condition)),
        handler_(static_cast<WriteHandler&&>(handler))
    {
    }


    write_dynbuf_op(const write_dynbuf_op& other)
      : stream_(other.stream_),
        buffers_(other.buffers_),
        completion_condition_(other.completion_condition_),
        handler_(other.handler_)
    {
    }

    write_dynbuf_op(write_dynbuf_op&& other)
      : stream_(other.stream_),
        buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
        completion_condition_(
          static_cast<CompletionCondition&&>(
            other.completion_condition_)),
        handler_(static_cast<WriteHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      switch (start)
      {
        case 1:
        async_write(stream_, buffers_.data(), completion_condition_,
            static_cast<write_dynbuf_op&&>(*this));
        return; default:
        buffers_.consume(bytes_transferred);
        handler_(ec, static_cast<const std::size_t&>(bytes_transferred));
      }
    }


    AsyncWriteStream& stream_;
    DynamicBuffer buffers_;
    CompletionCondition completion_condition_;
    WriteHandler handler_;
  };

  template <typename AsyncWriteStream, typename DynamicBuffer,
      typename CompletionCondition, typename WriteHandler>
  inline void* asio_handler_allocate(std::size_t size,
      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
        CompletionCondition, WriteHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncWriteStream, typename DynamicBuffer,
      typename CompletionCondition, typename WriteHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
        CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncWriteStream, typename DynamicBuffer,
      typename CompletionCondition, typename WriteHandler>
  inline bool asio_handler_is_continuation(
      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
        CompletionCondition, WriteHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
        this_handler->handler_);
  }

  template <typename Function, typename AsyncWriteStream,
      typename DynamicBuffer, typename CompletionCondition,
      typename WriteHandler>
  inline void asio_handler_invoke(Function& function,
      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
        CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncWriteStream,
      typename DynamicBuffer, typename CompletionCondition,
      typename WriteHandler>
  inline void asio_handler_invoke(const Function& function,
      write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
        CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename AsyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition, typename WriteHandler, typename Allocator>
struct associated_allocator<
    detail::write_dynbuf_op<AsyncWriteStream,
      DynamicBuffer, CompletionCondition, WriteHandler>,
    Allocator>
{
  typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  static type get(
      const detail::write_dynbuf_op<AsyncWriteStream,
        DynamicBuffer, CompletionCondition, WriteHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition, typename WriteHandler, typename Executor>
struct associated_executor<
    detail::write_dynbuf_op<AsyncWriteStream,
      DynamicBuffer, CompletionCondition, WriteHandler>,
    Executor>
{
  typedef typename associated_executor<WriteHandler, Executor>::type type;

  static type get(
      const detail::write_dynbuf_op<AsyncWriteStream,
        DynamicBuffer, CompletionCondition, WriteHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncWriteStream,
    typename DynamicBuffer, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s,
    DynamicBuffer&& buffers,
    WriteHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  return async_write(s,
      static_cast<DynamicBuffer&&>(buffers),
      transfer_all(), static_cast<WriteHandler&&>(handler));
}

template <typename AsyncWriteStream, typename DynamicBuffer,
    typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    WriteHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::write_dynbuf_op<AsyncWriteStream,
    typename decay<DynamicBuffer>::type,
      CompletionCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                    >(
          s, static_cast<DynamicBuffer&&>(buffers),
            completion_condition, init.completion_handler)(
              boost::system::error_code(), 0, 1);

  return init.result.get();
}




template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    WriteHandler&& handler)
{
  return async_write(s, basic_streambuf_ref<Allocator>(b),
      static_cast<WriteHandler&&>(handler));
}

template <typename AsyncWriteStream, typename Allocator,
    typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write(AsyncWriteStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition,
    WriteHandler&& handler)
{
  return async_write(s, basic_streambuf_ref<Allocator>(b),
      completion_condition, static_cast<WriteHandler&&>(handler));
}




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 675 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write.hpp" 2 3 4
# 928 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 2 3 4

namespace boost {
namespace asio {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 3 4
template <typename Stream>
class buffered_write_stream
  : private noncopyable
{
public:

  typedef typename remove_reference<Stream>::type next_layer_type;


  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;


  typedef typename lowest_layer_type::executor_type executor_type;





  static const std::size_t default_buffer_size = 1024;



  template <typename Arg>
  explicit buffered_write_stream(Arg& a)
    : next_layer_(a),
      storage_(default_buffer_size)
  {
  }


  template <typename Arg>
  buffered_write_stream(Arg& a, std::size_t buffer_size)
    : next_layer_(a),
      storage_(buffer_size)
  {
  }


  next_layer_type& next_layer()
  {
    return next_layer_;
  }


  lowest_layer_type& lowest_layer()
  {
    return next_layer_.lowest_layer();
  }


  const lowest_layer_type& lowest_layer() const
  {
    return next_layer_.lowest_layer();
  }


  executor_type get_executor() noexcept
  {
    return next_layer_.lowest_layer().get_executor();
  }




  boost::asio::io_context& get_io_context()
  {
    return next_layer_.get_io_context();
  }



  boost::asio::io_context& get_io_service()
  {
    return next_layer_.get_io_service();
  }



  void close()
  {
    next_layer_.close();
  }


  boost::system::error_code close(boost::system::error_code& ec)
  {
    next_layer_.close(ec);
    return ec;
  }




  std::size_t flush();




  std::size_t flush(boost::system::error_code& ec);


  template <typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_flush(WriteHandler&& handler);



  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers);



  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec);



  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_write_some(const ConstBufferSequence& buffers,
      WriteHandler&& handler);



  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    return next_layer_.read_some(buffers);
  }



  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return next_layer_.read_some(buffers, ec);
  }



  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_read_some(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {
    return next_layer_.async_read_some(buffers,
        static_cast<ReadHandler&&>(handler));
  }



  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers)
  {
    return next_layer_.peek(buffers);
  }



  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return next_layer_.peek(buffers, ec);
  }


  std::size_t in_avail()
  {
    return next_layer_.in_avail();
  }


  std::size_t in_avail(boost::system::error_code& ec)
  {
    return next_layer_.in_avail(ec);
  }

private:


  template <typename ConstBufferSequence>
  std::size_t copy(const ConstBufferSequence& buffers);


  Stream next_layer_;


  detail::buffered_stream_storage storage_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 248 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_write_stream.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_write_stream.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_write_stream.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename Stream>
std::size_t buffered_write_stream<Stream>::flush()
{
  std::size_t bytes_written = write(next_layer_,
      buffer(storage_.data(), storage_.size()));
  storage_.consume(bytes_written);
  return bytes_written;
}

template <typename Stream>
std::size_t buffered_write_stream<Stream>::flush(boost::system::error_code& ec)
{
  std::size_t bytes_written = write(next_layer_,
      buffer(storage_.data(), storage_.size()),
      transfer_all(), ec);
  storage_.consume(bytes_written);
  return bytes_written;
}

namespace detail
{
  template <typename WriteHandler>
  class buffered_flush_handler
  {
  public:
    buffered_flush_handler(detail::buffered_stream_storage& storage,
        WriteHandler& handler)
      : storage_(storage),
        handler_(static_cast<WriteHandler&&>(handler))
    {
    }


    buffered_flush_handler(const buffered_flush_handler& other)
      : storage_(other.storage_),
        handler_(other.handler_)
    {
    }

    buffered_flush_handler(buffered_flush_handler&& other)
      : storage_(other.storage_),
        handler_(static_cast<WriteHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        const std::size_t bytes_written)
    {
      storage_.consume(bytes_written);
      handler_(ec, bytes_written);
    }


    detail::buffered_stream_storage& storage_;
    WriteHandler handler_;
  };

  template <typename WriteHandler>
  inline void* asio_handler_allocate(std::size_t size,
      buffered_flush_handler<WriteHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename WriteHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      buffered_flush_handler<WriteHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename WriteHandler>
  inline bool asio_handler_is_continuation(
      buffered_flush_handler<WriteHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename WriteHandler>
  inline void asio_handler_invoke(Function& function,
      buffered_flush_handler<WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename WriteHandler>
  inline void asio_handler_invoke(const Function& function,
      buffered_flush_handler<WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename WriteHandler, typename Allocator>
struct associated_allocator<
    detail::buffered_flush_handler<WriteHandler>, Allocator>
{
  typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename WriteHandler, typename Executor>
struct associated_executor<
    detail::buffered_flush_handler<WriteHandler>, Executor>
{
  typedef typename associated_executor<WriteHandler, Executor>::type type;

  static type get(const detail::buffered_flush_handler<WriteHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename Stream>
template <typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

buffered_write_stream<Stream>::async_flush(
    WriteHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  async_write(next_layer_, buffer(storage_.data(), storage_.size()),
      detail::buffered_flush_handler<typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                    >(
        storage_, init.completion_handler));

  return init.result.get();
}

template <typename Stream>
template <typename ConstBufferSequence>
std::size_t buffered_write_stream<Stream>::write_some(
    const ConstBufferSequence& buffers)
{
  using boost::asio::buffer_size;
  if (buffer_size(buffers) == 0)
    return 0;

  if (storage_.size() == storage_.capacity())
    this->flush();

  return this->copy(buffers);
}

template <typename Stream>
template <typename ConstBufferSequence>
std::size_t buffered_write_stream<Stream>::write_some(
    const ConstBufferSequence& buffers, boost::system::error_code& ec)
{
  ec = boost::system::error_code();

  using boost::asio::buffer_size;
  if (buffer_size(buffers) == 0)
    return 0;

  if (storage_.size() == storage_.capacity() && !flush(ec))
    return 0;

  return this->copy(buffers);
}

namespace detail
{
  template <typename ConstBufferSequence, typename WriteHandler>
  class buffered_write_some_handler
  {
  public:
    buffered_write_some_handler(detail::buffered_stream_storage& storage,
        const ConstBufferSequence& buffers, WriteHandler& handler)
      : storage_(storage),
        buffers_(buffers),
        handler_(static_cast<WriteHandler&&>(handler))
    {
    }


      buffered_write_some_handler(const buffered_write_some_handler& other)
        : storage_(other.storage_),
          buffers_(other.buffers_),
          handler_(other.handler_)
      {
      }

      buffered_write_some_handler(buffered_write_some_handler&& other)
        : storage_(other.storage_),
          buffers_(other.buffers_),
          handler_(static_cast<WriteHandler&&>(other.handler_))
      {
      }


    void operator()(const boost::system::error_code& ec, std::size_t)
    {
      if (ec)
      {
        const std::size_t length = 0;
        handler_(ec, length);
      }
      else
      {
        using boost::asio::buffer_size;
        std::size_t orig_size = storage_.size();
        std::size_t space_avail = storage_.capacity() - orig_size;
        std::size_t bytes_avail = buffer_size(buffers_);
        std::size_t length = bytes_avail < space_avail
          ? bytes_avail : space_avail;
        storage_.resize(orig_size + length);
        const std::size_t bytes_copied = boost::asio::buffer_copy(
            storage_.data() + orig_size, buffers_, length);
        handler_(ec, bytes_copied);
      }
    }


    detail::buffered_stream_storage& storage_;
    ConstBufferSequence buffers_;
    WriteHandler handler_;
  };

  template <typename ConstBufferSequence, typename WriteHandler>
  inline void* asio_handler_allocate(std::size_t size,
      buffered_write_some_handler<
        ConstBufferSequence, WriteHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename ConstBufferSequence, typename WriteHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      buffered_write_some_handler<
        ConstBufferSequence, WriteHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename ConstBufferSequence, typename WriteHandler>
  inline bool asio_handler_is_continuation(
      buffered_write_some_handler<
        ConstBufferSequence, WriteHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename ConstBufferSequence,
      typename WriteHandler>
  inline void asio_handler_invoke(Function& function,
      buffered_write_some_handler<
        ConstBufferSequence, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename ConstBufferSequence,
      typename WriteHandler>
  inline void asio_handler_invoke(const Function& function,
      buffered_write_some_handler<
        ConstBufferSequence, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename ConstBufferSequence,
    typename WriteHandler, typename Allocator>
struct associated_allocator<
    detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
    Allocator>
{
  typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  static type get(
      const detail::buffered_write_some_handler<
        ConstBufferSequence, WriteHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename ConstBufferSequence,
    typename WriteHandler, typename Executor>
struct associated_executor<
    detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
    Executor>
{
  typedef typename associated_executor<WriteHandler, Executor>::type type;

  static type get(
      const detail::buffered_write_some_handler<
        ConstBufferSequence, WriteHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename Stream>
template <typename ConstBufferSequence, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

buffered_write_stream<Stream>::async_write_some(
    const ConstBufferSequence& buffers,
    WriteHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  using boost::asio::buffer_size;
  if (buffer_size(buffers) == 0
      || storage_.size() < storage_.capacity())
  {
    next_layer_.async_write_some(const_buffers_1(0, 0),
        detail::buffered_write_some_handler<
          ConstBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                        >(
            storage_, buffers, init.completion_handler));
  }
  else
  {
    this->async_flush(detail::buffered_write_some_handler<
          ConstBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                        >(
            storage_, buffers, init.completion_handler));
  }

  return init.result.get();
}

template <typename Stream>
template <typename ConstBufferSequence>
std::size_t buffered_write_stream<Stream>::copy(
    const ConstBufferSequence& buffers)
{
  using boost::asio::buffer_size;
  std::size_t orig_size = storage_.size();
  std::size_t space_avail = storage_.capacity() - orig_size;
  std::size_t bytes_avail = buffer_size(buffers);
  std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
  storage_.resize(orig_size + length);
  return boost::asio::buffer_copy(
      storage_.data() + orig_size, buffers, length);
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 412 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/buffered_write_stream.hpp" 2 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_write_stream.hpp" 2 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream.hpp" 2 3 4

namespace boost {
namespace asio {
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream.hpp" 3 4
template <typename Stream>
class buffered_stream
  : private noncopyable
{
public:

  typedef typename remove_reference<Stream>::type next_layer_type;


  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;


  typedef typename lowest_layer_type::executor_type executor_type;


  template <typename Arg>
  explicit buffered_stream(Arg& a)
    : inner_stream_impl_(a),
      stream_impl_(inner_stream_impl_)
  {
  }


  template <typename Arg>
  explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
      std::size_t write_buffer_size)
    : inner_stream_impl_(a, write_buffer_size),
      stream_impl_(inner_stream_impl_, read_buffer_size)
  {
  }


  next_layer_type& next_layer()
  {
    return stream_impl_.next_layer().next_layer();
  }


  lowest_layer_type& lowest_layer()
  {
    return stream_impl_.lowest_layer();
  }


  const lowest_layer_type& lowest_layer() const
  {
    return stream_impl_.lowest_layer();
  }


  executor_type get_executor() noexcept
  {
    return stream_impl_.lowest_layer().get_executor();
  }




  boost::asio::io_context& get_io_context()
  {
    return stream_impl_.get_io_context();
  }



  boost::asio::io_context& get_io_service()
  {
    return stream_impl_.get_io_service();
  }



  void close()
  {
    stream_impl_.close();
  }


  boost::system::error_code close(boost::system::error_code& ec)
  {
    stream_impl_.close(ec);
    return ec;
  }




  std::size_t flush()
  {
    return stream_impl_.next_layer().flush();
  }




  std::size_t flush(boost::system::error_code& ec)
  {
    return stream_impl_.next_layer().flush(ec);
  }


  template <typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_flush(WriteHandler&& handler)
  {
    return stream_impl_.next_layer().async_flush(
        static_cast<WriteHandler&&>(handler));
  }



  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers)
  {
    return stream_impl_.write_some(buffers);
  }



  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return stream_impl_.write_some(buffers, ec);
  }



  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_write_some(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {
    return stream_impl_.async_write_some(buffers,
        static_cast<WriteHandler&&>(handler));
  }



  std::size_t fill()
  {
    return stream_impl_.fill();
  }



  std::size_t fill(boost::system::error_code& ec)
  {
    return stream_impl_.fill(ec);
  }


  template <typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_fill(ReadHandler&& handler)
  {
    return stream_impl_.async_fill(static_cast<ReadHandler&&>(handler));
  }



  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    return stream_impl_.read_some(buffers);
  }



  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return stream_impl_.read_some(buffers, ec);
  }



  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_read_some(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {
    return stream_impl_.async_read_some(buffers,
        static_cast<ReadHandler&&>(handler));
  }



  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers)
  {
    return stream_impl_.peek(buffers);
  }



  template <typename MutableBufferSequence>
  std::size_t peek(const MutableBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return stream_impl_.peek(buffers, ec);
  }


  std::size_t in_avail()
  {
    return stream_impl_.in_avail();
  }


  std::size_t in_avail(boost::system::error_code& ec)
  {
    return stream_impl_.in_avail(ec);
  }

private:

  typedef buffered_write_stream<Stream> write_stream_type;
  write_stream_type inner_stream_impl_;


  typedef buffered_read_stream<write_stream_type&> read_stream_type;
  read_stream_type stream_impl_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 279 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffered_stream.hpp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffers_iterator.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffers_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffers_iterator.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  template <bool IsMutable>
  struct buffers_iterator_types_helper;

  template <>
  struct buffers_iterator_types_helper<false>
  {
    typedef const_buffer buffer_type;
    template <typename ByteType>
    struct byte_type
    {
      typedef typename add_const<ByteType>::type type;
    };
  };

  template <>
  struct buffers_iterator_types_helper<true>
  {
    typedef mutable_buffer buffer_type;
    template <typename ByteType>
    struct byte_type
    {
      typedef ByteType type;
    };
  };

  template <typename BufferSequence, typename ByteType>
  struct buffers_iterator_types
  {
    enum
    {
      is_mutable = is_convertible<
          typename BufferSequence::value_type,
          mutable_buffer>::value
    };
    typedef buffers_iterator_types_helper<is_mutable> helper;
    typedef typename helper::buffer_type buffer_type;
    typedef typename helper::template byte_type<ByteType>::type byte_type;
    typedef typename BufferSequence::const_iterator const_iterator;
  };

  template <typename ByteType>
  struct buffers_iterator_types<mutable_buffer, ByteType>
  {
    typedef mutable_buffer buffer_type;
    typedef ByteType byte_type;
    typedef const mutable_buffer* const_iterator;
  };

  template <typename ByteType>
  struct buffers_iterator_types<const_buffer, ByteType>
  {
    typedef const_buffer buffer_type;
    typedef typename add_const<ByteType>::type byte_type;
    typedef const const_buffer* const_iterator;
  };



  template <typename ByteType>
  struct buffers_iterator_types<mutable_buffers_1, ByteType>
  {
    typedef mutable_buffer buffer_type;
    typedef ByteType byte_type;
    typedef const mutable_buffer* const_iterator;
  };

  template <typename ByteType>
  struct buffers_iterator_types<const_buffers_1, ByteType>
  {
    typedef const_buffer buffer_type;
    typedef typename add_const<ByteType>::type byte_type;
    typedef const const_buffer* const_iterator;
  };


}


template <typename BufferSequence, typename ByteType = char>
class buffers_iterator
{
private:
  typedef typename detail::buffers_iterator_types<
      BufferSequence, ByteType>::buffer_type buffer_type;

  typedef typename detail::buffers_iterator_types<BufferSequence,
          ByteType>::const_iterator buffer_sequence_iterator_type;

public:

  typedef std::ptrdiff_t difference_type;


  typedef ByteType value_type;
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffers_iterator.hpp" 3 4
  typedef typename detail::buffers_iterator_types<
      BufferSequence, ByteType>::byte_type* pointer;
# 149 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffers_iterator.hpp" 3 4
  typedef typename detail::buffers_iterator_types<
      BufferSequence, ByteType>::byte_type& reference;



  typedef std::random_access_iterator_tag iterator_category;


  buffers_iterator()
    : current_buffer_(),
      current_buffer_position_(0),
      begin_(),
      current_(),
      end_(),
      position_(0)
  {
  }


  static buffers_iterator begin(const BufferSequence& buffers)



  {
    buffers_iterator new_iter;
    new_iter.begin_ = boost::asio::buffer_sequence_begin(buffers);
    new_iter.current_ = boost::asio::buffer_sequence_begin(buffers);
    new_iter.end_ = boost::asio::buffer_sequence_end(buffers);
    while (new_iter.current_ != new_iter.end_)
    {
      new_iter.current_buffer_ = *new_iter.current_;
      if (new_iter.current_buffer_.size() > 0)
        break;
      ++new_iter.current_;
    }
    return new_iter;
  }


  static buffers_iterator end(const BufferSequence& buffers)



  {
    buffers_iterator new_iter;
    new_iter.begin_ = boost::asio::buffer_sequence_begin(buffers);
    new_iter.current_ = boost::asio::buffer_sequence_begin(buffers);
    new_iter.end_ = boost::asio::buffer_sequence_end(buffers);
    while (new_iter.current_ != new_iter.end_)
    {
      buffer_type buffer = *new_iter.current_;
      new_iter.position_ += buffer.size();
      ++new_iter.current_;
    }
    return new_iter;
  }


  reference operator*() const
  {
    return dereference();
  }


  pointer operator->() const
  {
    return &dereference();
  }


  reference operator[](std::ptrdiff_t difference) const
  {
    buffers_iterator tmp(*this);
    tmp.advance(difference);
    return *tmp;
  }


  buffers_iterator& operator++()
  {
    increment();
    return *this;
  }


  buffers_iterator operator++(int)
  {
    buffers_iterator tmp(*this);
    ++*this;
    return tmp;
  }


  buffers_iterator& operator--()
  {
    decrement();
    return *this;
  }


  buffers_iterator operator--(int)
  {
    buffers_iterator tmp(*this);
    --*this;
    return tmp;
  }


  buffers_iterator& operator+=(std::ptrdiff_t difference)
  {
    advance(difference);
    return *this;
  }


  buffers_iterator& operator-=(std::ptrdiff_t difference)
  {
    advance(-difference);
    return *this;
  }


  friend buffers_iterator operator+(const buffers_iterator& iter,
      std::ptrdiff_t difference)
  {
    buffers_iterator tmp(iter);
    tmp.advance(difference);
    return tmp;
  }


  friend buffers_iterator operator+(std::ptrdiff_t difference,
      const buffers_iterator& iter)
  {
    buffers_iterator tmp(iter);
    tmp.advance(difference);
    return tmp;
  }


  friend buffers_iterator operator-(const buffers_iterator& iter,
      std::ptrdiff_t difference)
  {
    buffers_iterator tmp(iter);
    tmp.advance(-difference);
    return tmp;
  }


  friend std::ptrdiff_t operator-(const buffers_iterator& a,
      const buffers_iterator& b)
  {
    return b.distance_to(a);
  }


  friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
  {
    return a.equal(b);
  }


  friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
  {
    return !a.equal(b);
  }


  friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
  {
    return a.distance_to(b) > 0;
  }


  friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
  {
    return !(b < a);
  }


  friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
  {
    return b < a;
  }


  friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
  {
    return !(a < b);
  }

private:

  reference dereference() const
  {
    return static_cast<pointer>(
        current_buffer_.data())[current_buffer_position_];
  }


  bool equal(const buffers_iterator& other) const
  {
    return position_ == other.position_;
  }


  void increment()
  {
    (static_cast<void> (0));
    ++position_;


    ++current_buffer_position_;
    if (current_buffer_position_ != current_buffer_.size())
      return;


    ++current_;
    current_buffer_position_ = 0;
    while (current_ != end_)
    {
      current_buffer_ = *current_;
      if (current_buffer_.size() > 0)
        return;
      ++current_;
    }
  }


  void decrement()
  {
    (static_cast<void> (0));
    --position_;


    if (current_buffer_position_ != 0)
    {
      --current_buffer_position_;
      return;
    }


    buffer_sequence_iterator_type iter = current_;
    while (iter != begin_)
    {
      --iter;
      buffer_type buffer = *iter;
      std::size_t buffer_size = buffer.size();
      if (buffer_size > 0)
      {
        current_ = iter;
        current_buffer_ = buffer;
        current_buffer_position_ = buffer_size - 1;
        return;
      }
    }
  }


  void advance(std::ptrdiff_t n)
  {
    if (n > 0)
    {
      (static_cast<void> (0));
      for (;;)
      {
        std::ptrdiff_t current_buffer_balance
          = current_buffer_.size() - current_buffer_position_;


        if (current_buffer_balance > n)
        {
          position_ += n;
          current_buffer_position_ += n;
          return;
        }


        n -= current_buffer_balance;
        position_ += current_buffer_balance;



        if (++current_ == end_)
        {
          (static_cast<void> (0));
          current_buffer_ = buffer_type();
          current_buffer_position_ = 0;
          return;
        }
        current_buffer_ = *current_;
        current_buffer_position_ = 0;
      }
    }
    else if (n < 0)
    {
      std::size_t abs_n = -n;
      (static_cast<void> (0));
      for (;;)
      {

        if (current_buffer_position_ >= abs_n)
        {
          position_ -= abs_n;
          current_buffer_position_ -= abs_n;
          return;
        }


        abs_n -= current_buffer_position_;
        position_ -= current_buffer_position_;


        if (current_ == begin_)
        {
          (static_cast<void> (0));
          current_buffer_position_ = 0;
          return;
        }


        buffer_sequence_iterator_type iter = current_;
        while (iter != begin_)
        {
          --iter;
          buffer_type buffer = *iter;
          std::size_t buffer_size = buffer.size();
          if (buffer_size > 0)
          {
            current_ = iter;
            current_buffer_ = buffer;
            current_buffer_position_ = buffer_size;
            break;
          }
        }
      }
    }
  }


  std::ptrdiff_t distance_to(const buffers_iterator& other) const
  {
    return other.position_ - position_;
  }

  buffer_type current_buffer_;
  std::size_t current_buffer_position_;
  buffer_sequence_iterator_type begin_;
  buffer_sequence_iterator_type current_;
  buffer_sequence_iterator_type end_;
  std::size_t position_;
};


template <typename BufferSequence>
inline buffers_iterator<BufferSequence> buffers_begin(
    const BufferSequence& buffers)
{
  return buffers_iterator<BufferSequence>::begin(buffers);
}


template <typename BufferSequence>
inline buffers_iterator<BufferSequence> buffers_end(
    const BufferSequence& buffers)
{
  return buffers_iterator<BufferSequence>::end(buffers);
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 522 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/buffers_iterator.hpp" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  char (&has_iterator_helper(...))[2];

  template <typename T>
  char has_iterator_helper(T*, typename T::iterator* = 0);

  template <typename T>
  struct has_iterator_typedef
  {
    enum { value = (sizeof((has_iterator_helper)((T*)(0))) == 1) };
  };
}



template <typename T>
struct is_endpoint_sequence
{




  enum
  {
    value = detail::has_iterator_typedef<T>::value
  };

};
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename EndpointSequence>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type* = 0);
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename EndpointSequence>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, boost::system::error_code& ec,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type* = 0);
# 159 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename Iterator>
Iterator connect(basic_socket<Protocol >& s, Iterator begin,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
# 187 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename Iterator>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, boost::system::error_code& ec,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
# 220 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename Iterator>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end);
# 257 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename Iterator>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end, boost::system::error_code& ec);
# 312 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename EndpointSequence, typename ConnectCondition>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, ConnectCondition connect_condition,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type* = 0);
# 380 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename EndpointSequence, typename ConnectCondition>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, ConnectCondition connect_condition,
    boost::system::error_code& ec,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type* = 0);
# 425 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, ConnectCondition connect_condition,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
# 466 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol >& s, Iterator begin,
    ConnectCondition connect_condition, boost::system::error_code& ec,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
# 527 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol >& s, Iterator begin,
    Iterator end, ConnectCondition connect_condition);
# 595 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end, ConnectCondition connect_condition,
    boost::system::error_code& ec);
# 672 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename EndpointSequence, typename RangeConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type

async_connect(basic_socket<Protocol >& s,
    const EndpointSequence& endpoints,
    RangeConnectHandler&& handler,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type* = 0);
# 718 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename Iterator, typename IteratorConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s,
    Iterator begin, IteratorConnectHandler&& handler,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
# 776 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol ,
    typename Iterator, typename IteratorConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end,
    IteratorConnectHandler&& handler);
# 879 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename EndpointSequence,
    typename ConnectCondition, typename RangeConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type

async_connect(basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, ConnectCondition connect_condition,
    RangeConnectHandler&& handler,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type* = 0);
# 936 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename Iterator,
    typename ConnectCondition, typename IteratorConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s, Iterator begin,
    ConnectCondition connect_condition,
    IteratorConnectHandler&& handler,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
# 1044 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 3 4
template <typename Protocol , typename Iterator,
    typename ConnectCondition, typename IteratorConnectHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end, ConnectCondition connect_condition,
    IteratorConnectHandler&& handler);



}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1058 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/connect.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/connect.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/connect.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  struct default_connect_condition
  {
    template <typename Endpoint>
    bool operator()(const boost::system::error_code&, const Endpoint&)
    {
      return true;
    }
  };

  template <typename Protocol, typename Iterator>
  inline typename Protocol::endpoint deref_connect_result(
      Iterator iter, boost::system::error_code& ec)
  {
    return ec ? typename Protocol::endpoint() : *iter;
  }

  template <typename T, typename Iterator>
  struct legacy_connect_condition_helper : T
  {
    typedef char (*fallback_func_type)(...);
    operator fallback_func_type() const;
  };

  template <typename R, typename Arg1, typename Arg2, typename Iterator>
  struct legacy_connect_condition_helper<R (*)(Arg1, Arg2), Iterator>
  {
    R operator()(Arg1, Arg2) const;
    char operator()(...) const;
  };

  template <typename T, typename Iterator>
  struct is_legacy_connect_condition
  {
    static char asio_connect_condition_check(char);
    static char (&asio_connect_condition_check(Iterator))[2];

    static const bool value =
      sizeof(asio_connect_condition_check(
        (*static_cast<legacy_connect_condition_helper<T, Iterator>*>(0))(
          *static_cast<const boost::system::error_code*>(0),
          *static_cast<const Iterator*>(0)))) != 1;
  };

  template <typename ConnectCondition, typename Iterator>
  inline Iterator call_connect_condition(ConnectCondition& connect_condition,
      const boost::system::error_code& ec, Iterator next, Iterator end,
      typename enable_if<is_legacy_connect_condition<
        ConnectCondition, Iterator>::value>::type* = 0)
  {
    if (next != end)
      return connect_condition(ec, next);
    return end;
  }

  template <typename ConnectCondition, typename Iterator>
  inline Iterator call_connect_condition(ConnectCondition& connect_condition,
      const boost::system::error_code& ec, Iterator next, Iterator end,
      typename enable_if<!is_legacy_connect_condition<
        ConnectCondition, Iterator>::value>::type* = 0)
  {
    for (;next != end; ++next)
      if (connect_condition(ec, *next))
        return next;
    return end;
  }
}

template <typename Protocol , typename EndpointSequence>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type*)
{
  boost::system::error_code ec;
  typename Protocol::endpoint result = connect(s, endpoints, ec);
  boost::asio::detail::throw_error(ec, "connect");
  return result;
}

template <typename Protocol , typename EndpointSequence>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, boost::system::error_code& ec,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type*)
{
  return detail::deref_connect_result<Protocol>(
      connect(s, endpoints.begin(), endpoints.end(),
        detail::default_connect_condition(), ec), ec);
}


template <typename Protocol , typename Iterator>
Iterator connect(basic_socket<Protocol >& s, Iterator begin,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
{
  boost::system::error_code ec;
  Iterator result = connect(s, begin, ec);
  boost::asio::detail::throw_error(ec, "connect");
  return result;
}

template <typename Protocol , typename Iterator>
inline Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, boost::system::error_code& ec,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
{
  return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
}


template <typename Protocol , typename Iterator>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end)
{
  boost::system::error_code ec;
  Iterator result = connect(s, begin, end, ec);
  boost::asio::detail::throw_error(ec, "connect");
  return result;
}

template <typename Protocol , typename Iterator>
inline Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end, boost::system::error_code& ec)
{
  return connect(s, begin, end, detail::default_connect_condition(), ec);
}

template <typename Protocol ,
    typename EndpointSequence, typename ConnectCondition>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, ConnectCondition connect_condition,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type*)
{
  boost::system::error_code ec;
  typename Protocol::endpoint result = connect(
      s, endpoints, connect_condition, ec);
  boost::asio::detail::throw_error(ec, "connect");
  return result;
}

template <typename Protocol ,
    typename EndpointSequence, typename ConnectCondition>
typename Protocol::endpoint connect(
    basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, ConnectCondition connect_condition,
    boost::system::error_code& ec,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type*)
{
  return detail::deref_connect_result<Protocol>(
      connect(s, endpoints.begin(), endpoints.end(),
        connect_condition, ec), ec);
}


template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, ConnectCondition connect_condition,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
{
  boost::system::error_code ec;
  Iterator result = connect(s, begin, connect_condition, ec);
  boost::asio::detail::throw_error(ec, "connect");
  return result;
}

template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
inline Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, ConnectCondition connect_condition,
    boost::system::error_code& ec,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
{
  return connect(s, begin, Iterator(), connect_condition, ec);
}


template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end, ConnectCondition connect_condition)
{
  boost::system::error_code ec;
  Iterator result = connect(s, begin, end, connect_condition, ec);
  boost::asio::detail::throw_error(ec, "connect");
  return result;
}

template <typename Protocol ,
    typename Iterator, typename ConnectCondition>
Iterator connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end, ConnectCondition connect_condition,
    boost::system::error_code& ec)
{
  ec = boost::system::error_code();

  for (Iterator iter = begin; iter != end; ++iter)
  {
    iter = (detail::call_connect_condition(connect_condition, ec, iter, end));
    if (iter != end)
    {
      s.close(ec);
      s.connect(*iter, ec);
      if (!ec)
        return iter;
    }
    else
      break;
  }

  if (!ec)
    ec = boost::asio::error::not_found;

  return end;
}

namespace detail
{

  template <typename ConnectCondition>
  class base_from_connect_condition
  {
  protected:
    explicit base_from_connect_condition(
        const ConnectCondition& connect_condition)
      : connect_condition_(connect_condition)
    {
    }

    template <typename Iterator>
    void check_condition(const boost::system::error_code& ec,
        Iterator& iter, Iterator& end)
    {
      iter = detail::call_connect_condition(connect_condition_, ec, iter, end);
    }

  private:
    ConnectCondition connect_condition_;
  };



  template <>
  class base_from_connect_condition<default_connect_condition>
  {
  protected:
    explicit base_from_connect_condition(const default_connect_condition&)
    {
    }

    template <typename Iterator>
    void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
    {
    }
  };

  template <typename Protocol ,
      typename EndpointSequence, typename ConnectCondition,
      typename RangeConnectHandler>
  class range_connect_op : base_from_connect_condition<ConnectCondition>
  {
  public:
    range_connect_op(basic_socket<Protocol >& sock,
        const EndpointSequence& endpoints,
        const ConnectCondition& connect_condition,
        RangeConnectHandler& handler)
      : base_from_connect_condition<ConnectCondition>(connect_condition),
        socket_(sock),
        endpoints_(endpoints),
        index_(0),
        start_(0),
        handler_(static_cast<RangeConnectHandler&&>(handler))
    {
    }


    range_connect_op(const range_connect_op& other)
      : base_from_connect_condition<ConnectCondition>(other),
        socket_(other.socket_),
        endpoints_(other.endpoints_),
        index_(other.index_),
        start_(other.start_),
        handler_(other.handler_)
    {
    }

    range_connect_op(range_connect_op&& other)
      : base_from_connect_condition<ConnectCondition>(other),
        socket_(other.socket_),
        endpoints_(other.endpoints_),
        index_(other.index_),
        start_(other.start_),
        handler_(static_cast<RangeConnectHandler&&>(other.handler_))
    {
    }


    void operator()(boost::system::error_code ec, int start = 0)
    {
      typename EndpointSequence::const_iterator begin = endpoints_.begin();
      typename EndpointSequence::const_iterator iter = begin;
      std::advance(iter, index_);
      typename EndpointSequence::const_iterator end = endpoints_.end();

      switch (start_ = start)
      {
        case 1:
        for (;;)
        {
          this->check_condition(ec, iter, end);
          index_ = std::distance(begin, iter);

          if (iter != end)
          {
            socket_.close(ec);
            socket_.async_connect(*iter,
                static_cast<range_connect_op&&>(*this));
            return;
          }

          if (start)
          {
            ec = boost::asio::error::not_found;
            boost::asio::post(socket_.get_executor(),
                detail::bind_handler(
                  static_cast<range_connect_op&&>(*this), ec));
            return;
          }

          default:

          if (iter == end)
            break;

          if (!socket_.is_open())
          {
            ec = boost::asio::error::operation_aborted;
            break;
          }

          if (!ec)
            break;

          ++iter;
          ++index_;
        }

        handler_(static_cast<const boost::system::error_code&>(ec),
            static_cast<const typename Protocol::endpoint&>(
              ec || iter == end ? typename Protocol::endpoint() : *iter));
      }
    }


    basic_socket<Protocol >& socket_;
    EndpointSequence endpoints_;
    std::size_t index_;
    int start_;
    RangeConnectHandler handler_;
  };

  template <typename Protocol ,
      typename EndpointSequence, typename ConnectCondition,
      typename RangeConnectHandler>
  inline void* asio_handler_allocate(std::size_t size,
      range_connect_op<Protocol , EndpointSequence,
        ConnectCondition, RangeConnectHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename Protocol ,
      typename EndpointSequence, typename ConnectCondition,
      typename RangeConnectHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      range_connect_op<Protocol , EndpointSequence,
        ConnectCondition, RangeConnectHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename Protocol ,
      typename EndpointSequence, typename ConnectCondition,
      typename RangeConnectHandler>
  inline bool asio_handler_is_continuation(
      range_connect_op<Protocol , EndpointSequence,
        ConnectCondition, RangeConnectHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
        this_handler->handler_);
  }

  template <typename Function, typename Protocol
      , typename EndpointSequence,
      typename ConnectCondition, typename RangeConnectHandler>
  inline void asio_handler_invoke(Function& function,
      range_connect_op<Protocol , EndpointSequence,
        ConnectCondition, RangeConnectHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename Protocol
      , typename EndpointSequence,
      typename ConnectCondition, typename RangeConnectHandler>
  inline void asio_handler_invoke(const Function& function,
      range_connect_op<Protocol , EndpointSequence,
        ConnectCondition, RangeConnectHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Protocol , typename Iterator,
      typename ConnectCondition, typename IteratorConnectHandler>
  class iterator_connect_op : base_from_connect_condition<ConnectCondition>
  {
  public:
    iterator_connect_op(basic_socket<Protocol >& sock,
        const Iterator& begin, const Iterator& end,
        const ConnectCondition& connect_condition,
        IteratorConnectHandler& handler)
      : base_from_connect_condition<ConnectCondition>(connect_condition),
        socket_(sock),
        iter_(begin),
        end_(end),
        start_(0),
        handler_(static_cast<IteratorConnectHandler&&>(handler))
    {
    }


    iterator_connect_op(const iterator_connect_op& other)
      : base_from_connect_condition<ConnectCondition>(other),
        socket_(other.socket_),
        iter_(other.iter_),
        end_(other.end_),
        start_(other.start_),
        handler_(other.handler_)
    {
    }

    iterator_connect_op(iterator_connect_op&& other)
      : base_from_connect_condition<ConnectCondition>(other),
        socket_(other.socket_),
        iter_(other.iter_),
        end_(other.end_),
        start_(other.start_),
        handler_(static_cast<IteratorConnectHandler&&>(other.handler_))
    {
    }


    void operator()(boost::system::error_code ec, int start = 0)
    {
      switch (start_ = start)
      {
        case 1:
        for (;;)
        {
          this->check_condition(ec, iter_, end_);

          if (iter_ != end_)
          {
            socket_.close(ec);
            socket_.async_connect(*iter_,
                static_cast<iterator_connect_op&&>(*this));
            return;
          }

          if (start)
          {
            ec = boost::asio::error::not_found;
            boost::asio::post(socket_.get_executor(),
                detail::bind_handler(
                  static_cast<iterator_connect_op&&>(*this), ec));
            return;
          }

          default:

          if (iter_ == end_)
            break;

          if (!socket_.is_open())
          {
            ec = boost::asio::error::operation_aborted;
            break;
          }

          if (!ec)
            break;

          ++iter_;
        }

        handler_(static_cast<const boost::system::error_code&>(ec),
            static_cast<const Iterator&>(iter_));
      }
    }


    basic_socket<Protocol >& socket_;
    Iterator iter_;
    Iterator end_;
    int start_;
    IteratorConnectHandler handler_;
  };

  template <typename Protocol , typename Iterator,
      typename ConnectCondition, typename IteratorConnectHandler>
  inline void* asio_handler_allocate(std::size_t size,
      iterator_connect_op<Protocol , Iterator,
        ConnectCondition, IteratorConnectHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename Protocol , typename Iterator,
      typename ConnectCondition, typename IteratorConnectHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      iterator_connect_op<Protocol , Iterator,
        ConnectCondition, IteratorConnectHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename Protocol , typename Iterator,
      typename ConnectCondition, typename IteratorConnectHandler>
  inline bool asio_handler_is_continuation(
      iterator_connect_op<Protocol , Iterator,
        ConnectCondition, IteratorConnectHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
        this_handler->handler_);
  }

  template <typename Function, typename Protocol
      , typename Iterator,
      typename ConnectCondition, typename IteratorConnectHandler>
  inline void asio_handler_invoke(Function& function,
      iterator_connect_op<Protocol , Iterator,
        ConnectCondition, IteratorConnectHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename Protocol
      , typename Iterator,
      typename ConnectCondition, typename IteratorConnectHandler>
  inline void asio_handler_invoke(const Function& function,
      iterator_connect_op<Protocol , Iterator,
        ConnectCondition, IteratorConnectHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename Protocol ,
    typename EndpointSequence, typename ConnectCondition,
    typename RangeConnectHandler, typename Allocator>
struct associated_allocator<
    detail::range_connect_op<Protocol ,
      EndpointSequence, ConnectCondition, RangeConnectHandler>,
    Allocator>
{
  typedef typename associated_allocator<
      RangeConnectHandler, Allocator>::type type;

  static type get(
      const detail::range_connect_op<Protocol ,
        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<RangeConnectHandler,
        Allocator>::get(h.handler_, a);
  }
};

template <typename Protocol ,
    typename EndpointSequence, typename ConnectCondition,
    typename RangeConnectHandler, typename Executor>
struct associated_executor<
    detail::range_connect_op<Protocol ,
      EndpointSequence, ConnectCondition, RangeConnectHandler>,
    Executor>
{
  typedef typename associated_executor<
      RangeConnectHandler, Executor>::type type;

  static type get(
      const detail::range_connect_op<Protocol ,
        EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<RangeConnectHandler,
        Executor>::get(h.handler_, ex);
  }
};

template <typename Protocol ,
    typename Iterator, typename ConnectCondition,
    typename IteratorConnectHandler, typename Allocator>
struct associated_allocator<
    detail::iterator_connect_op<Protocol , Iterator,
      ConnectCondition, IteratorConnectHandler>,
    Allocator>
{
  typedef typename associated_allocator<
      IteratorConnectHandler, Allocator>::type type;

  static type get(
      const detail::iterator_connect_op<Protocol ,
        Iterator, ConnectCondition, IteratorConnectHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<IteratorConnectHandler,
        Allocator>::get(h.handler_, a);
  }
};

template <typename Protocol ,
    typename Iterator, typename ConnectCondition,
    typename IteratorConnectHandler, typename Executor>
struct associated_executor<
    detail::iterator_connect_op<Protocol , Iterator,
      ConnectCondition, IteratorConnectHandler>,
    Executor>
{
  typedef typename associated_executor<
      IteratorConnectHandler, Executor>::type type;

  static type get(
      const detail::iterator_connect_op<Protocol ,
        Iterator, ConnectCondition, IteratorConnectHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<IteratorConnectHandler,
        Executor>::get(h.handler_, ex);
  }
};



template <typename Protocol ,
    typename EndpointSequence, typename RangeConnectHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type

async_connect(basic_socket<Protocol >& s,
    const EndpointSequence& endpoints,
    RangeConnectHandler&& handler,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void(boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const typename Protocol::endpoint*>(0))) == 1, "RangeConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const typename Protocol::endpoint>()), char(0))> __attribute__((__unused__))
                                                                 type_check;

  async_completion<RangeConnectHandler,
    void (boost::system::error_code, typename Protocol::endpoint)>
      init(handler);

  detail::range_connect_op<Protocol , EndpointSequence,
    detail::default_connect_condition,
      typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type
                                                                      >(s,
          endpoints, detail::default_connect_condition(),
            init.completion_handler)(boost::system::error_code(), 1);

  return init.result.get();
}


template <typename Protocol ,
    typename Iterator, typename IteratorConnectHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s,
    Iterator begin, IteratorConnectHandler&& handler,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
                                                 type_check;

  async_completion<IteratorConnectHandler,
    void (boost::system::error_code, Iterator)> init(handler);

  detail::iterator_connect_op<Protocol , Iterator,
    detail::default_connect_condition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
                                                                         >(s,
        begin, Iterator(), detail::default_connect_condition(),
          init.completion_handler)(boost::system::error_code(), 1);

  return init.result.get();
}


template <typename Protocol ,
    typename Iterator, typename IteratorConnectHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end,
    IteratorConnectHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
                                                 type_check;

  async_completion<IteratorConnectHandler,
    void (boost::system::error_code, Iterator)> init(handler);

  detail::iterator_connect_op<Protocol , Iterator,
    detail::default_connect_condition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
                                                                         >(s,
        begin, end, detail::default_connect_condition(),
          init.completion_handler)(boost::system::error_code(), 1);

  return init.result.get();
}

template <typename Protocol , typename EndpointSequence,
    typename ConnectCondition, typename RangeConnectHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type

async_connect(basic_socket<Protocol >& s,
    const EndpointSequence& endpoints, ConnectCondition connect_condition,
    RangeConnectHandler&& handler,
    typename enable_if<is_endpoint_sequence<
        EndpointSequence>::value>::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void(boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const typename Protocol::endpoint*>(0))) == 1, "RangeConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const typename Protocol::endpoint>()), char(0))> __attribute__((__unused__))
                                                                 type_check;

  async_completion<RangeConnectHandler,
    void (boost::system::error_code, typename Protocol::endpoint)>
      init(handler);

  detail::range_connect_op<Protocol , EndpointSequence,
    ConnectCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type
                                                                    >(s,
        endpoints, connect_condition, init.completion_handler)(
          boost::system::error_code(), 1);

  return init.result.get();
}


template <typename Protocol , typename Iterator,
    typename ConnectCondition, typename IteratorConnectHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s,
    Iterator begin, ConnectCondition connect_condition,
    IteratorConnectHandler&& handler,
    typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
                                                 type_check;

  async_completion<IteratorConnectHandler,
    void (boost::system::error_code, Iterator)> init(handler);

  detail::iterator_connect_op<Protocol , Iterator,
    ConnectCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
                                                                         >(s,
        begin, Iterator(), connect_condition, init.completion_handler)(
          boost::system::error_code(), 1);

  return init.result.get();
}


template <typename Protocol , typename Iterator,
    typename ConnectCondition, typename IteratorConnectHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type

async_connect(basic_socket<Protocol >& s,
    Iterator begin, Iterator end, ConnectCondition connect_condition,
    IteratorConnectHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
                                                 type_check;

  async_completion<IteratorConnectHandler,
    void (boost::system::error_code, Iterator)> init(handler);

  detail::iterator_connect_op<Protocol , Iterator,
    ConnectCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
                                                                         >(s,
        begin, end, connect_condition, init.completion_handler)(
          boost::system::error_code(), 1);

  return init.result.get();
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 861 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/connect.hpp" 2 3 4
# 1060 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/connect.hpp" 2 3 4
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/coroutine.hpp" 1 3 4
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/coroutine.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {

class coroutine_ref;

}
# 242 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/coroutine.hpp" 3 4
class coroutine
{
public:

  coroutine() : value_(0) {}


  bool is_child() const { return value_ < 0; }


  bool is_parent() const { return !is_child(); }


  bool is_complete() const { return value_ == -1; }

private:
  friend class detail::coroutine_ref;
  int value_;
};


namespace detail {

class coroutine_ref
{
public:
  coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
  coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
  ~coroutine_ref() { if (!modified_) value_ = -1; }
  operator int() const { return value_; }
  int& operator=(int v) { modified_ = true; return value_ = v; }
private:
  void operator=(const coroutine_ref&);
  int& value_;
  bool modified_;
};

}
}
}
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/datagram_socket_service.hpp" 1 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/deadline_timer_service.hpp" 1 3 4
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/deadline_timer.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/deadline_timer.hpp" 3 4
namespace boost {
namespace asio {


typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;

}
}
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/defer.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/defer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/defer.hpp" 2 3 4

namespace boost {
namespace asio {
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/defer.hpp" 3 4
template <typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
    CompletionToken&& token);
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/defer.hpp" 3 4
template <typename Executor, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
    const Executor& ex, CompletionToken&& token,
    typename enable_if<is_executor<Executor>::value>::type* = 0);





template <typename ExecutionContext, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
    ExecutionContext& ctx, CompletionToken&& token,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type* = 0);

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/defer.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/defer.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/defer.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/defer.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
    CompletionToken&& token)
{
  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;

  async_completion<CompletionToken, void()> init(token);

  typename associated_executor<handler>::type ex(
      (get_associated_executor)(init.completion_handler));

  typename associated_allocator<handler>::type alloc(
      (get_associated_allocator)(init.completion_handler));

  ex.defer(static_cast<handler&&>(init.completion_handler), alloc);

  return init.result.get();
}

template <typename Executor, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
    const Executor& ex, CompletionToken&& token,
    typename enable_if<is_executor<Executor>::value>::type*)
{
  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;

  async_completion<CompletionToken, void()> init(token);

  typename associated_allocator<handler>::type alloc(
      (get_associated_allocator)(init.completion_handler));

  ex.defer(detail::work_dispatcher<handler>(init.completion_handler), alloc);

  return init.result.get();
}

template <typename ExecutionContext, typename CompletionToken>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
    ExecutionContext& ctx, CompletionToken&& token,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type*)
{
  return (defer)(ctx.get_executor(),
      static_cast<CompletionToken&&>(token));
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/defer.hpp" 2 3 4
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/defer.hpp" 2 3 4
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/dispatch.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/dispatch.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/dispatch.hpp" 2 3 4

namespace boost {
namespace asio {
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/dispatch.hpp" 3 4
template <typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
    CompletionToken&& token);
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/dispatch.hpp" 3 4
template <typename Executor, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
    const Executor& ex, CompletionToken&& token,
    typename enable_if<is_executor<Executor>::value>::type* = 0);






template <typename ExecutionContext, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
    ExecutionContext& ctx, CompletionToken&& token,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type* = 0);

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 107 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/dispatch.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/dispatch.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/dispatch.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/dispatch.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
    CompletionToken&& token)
{
  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;

  async_completion<CompletionToken, void()> init(token);

  typename associated_executor<handler>::type ex(
      (get_associated_executor)(init.completion_handler));

  typename associated_allocator<handler>::type alloc(
      (get_associated_allocator)(init.completion_handler));

  ex.dispatch(static_cast<handler&&>(init.completion_handler), alloc);

  return init.result.get();
}

template <typename Executor, typename CompletionToken>
typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
    const Executor& ex, CompletionToken&& token,
    typename enable_if<is_executor<Executor>::value>::type*)
{
  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;

  async_completion<CompletionToken, void()> init(token);

  typename associated_allocator<handler>::type alloc(
      (get_associated_allocator)(init.completion_handler));

  ex.dispatch(detail::work_dispatcher<handler>(
        init.completion_handler), alloc);

  return init.result.get();
}

template <typename ExecutionContext, typename CompletionToken>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
    ExecutionContext& ctx, CompletionToken&& token,
    typename enable_if<is_convertible<
      ExecutionContext&, execution_context&>::value>::type*)
{
  return (dispatch)(ctx.get_executor(),
      static_cast<CompletionToken&&>(token));
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/dispatch.hpp" 2 3 4
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/dispatch.hpp" 2 3 4
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/basic_endpoint.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/basic_endpoint.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/endpoint.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/endpoint.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4

namespace boost {
namespace asio {
namespace generic {
namespace detail {


class endpoint
{
public:

  inline endpoint();


  inline endpoint(const void* sock_addr,
      std::size_t sock_addr_size, int sock_protocol);


  endpoint(const endpoint& other)
    : data_(other.data_),
      size_(other.size_),
      protocol_(other.protocol_)
  {
  }


  endpoint& operator=(const endpoint& other)
  {
    data_ = other.data_;
    size_ = other.size_;
    protocol_ = other.protocol_;
    return *this;
  }


  int family() const
  {
    return data_.base.sa_family;
  }


  int protocol() const
  {
    return protocol_;
  }


  boost::asio::detail::socket_addr_type* data()
  {
    return &data_.base;
  }


  const boost::asio::detail::socket_addr_type* data() const
  {
    return &data_.base;
  }


  std::size_t size() const
  {
    return size_;
  }


  inline void resize(std::size_t size);


  std::size_t capacity() const
  {
    return sizeof(boost::asio::detail::sockaddr_storage_type);
  }


  inline friend bool operator==(
      const endpoint& e1, const endpoint& e2);


  inline friend bool operator<(
      const endpoint& e1, const endpoint& e2);

private:

  union data_union
  {
    boost::asio::detail::socket_addr_type base;
    boost::asio::detail::sockaddr_storage_type generic;
  } data_;


  std::size_t size_;


  int protocol_;


  inline void init(const void* sock_addr,
      std::size_t sock_addr_size, int sock_protocol);
};

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/impl/endpoint.ipp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/impl/endpoint.ipp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/endpoint.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4

namespace boost {
namespace asio {
namespace generic {
namespace detail {

endpoint::endpoint()
{
  init(0, 0, 0);
}

endpoint::endpoint(const void* sock_addr,
    std::size_t sock_addr_size, int sock_protocol)
{
  init(sock_addr, sock_addr_size, sock_protocol);
}

void endpoint::resize(std::size_t new_size)
{
  if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
  {
    boost::system::error_code ec(boost::asio::error::invalid_argument);
    boost::asio::detail::throw_error(ec);
  }
  else
  {
    size_ = new_size;
    protocol_ = 0;
  }
}

bool operator==(const endpoint& e1, const endpoint& e2)
{
  using namespace std;
  return e1.size() == e2.size() && memcmp(e1.data(), e2.data(), e1.size()) == 0;
}

bool operator<(const endpoint& e1, const endpoint& e2)
{
  if (e1.protocol() < e2.protocol())
    return true;

  if (e1.protocol() > e2.protocol())
    return false;

  using namespace std;
  std::size_t compare_size = e1.size() < e2.size() ? e1.size() : e2.size();
  int compare_result = memcmp(e1.data(), e2.data(), compare_size);

  if (compare_result < 0)
    return true;

  if (compare_result > 0)
    return false;

  return e1.size() < e2.size();
}

void endpoint::init(const void* sock_addr,
    std::size_t sock_addr_size, int sock_protocol)
{
  if (sock_addr_size > sizeof(boost::asio::detail::sockaddr_storage_type))
  {
    boost::system::error_code ec(boost::asio::error::invalid_argument);
    boost::asio::detail::throw_error(ec);
  }

  using namespace std;
  memset(&data_.generic, 0, sizeof(boost::asio::detail::sockaddr_storage_type));
  if (sock_addr_size > 0)
    memcpy(&data_.generic, sock_addr, sock_addr_size);

  size_ = sock_addr_size;
  protocol_ = sock_protocol;
}

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4

namespace boost {
namespace asio {
namespace generic {
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/basic_endpoint.hpp" 3 4
template <typename Protocol>
class basic_endpoint
{
public:

  typedef Protocol protocol_type;






  typedef boost::asio::detail::socket_addr_type data_type;



  basic_endpoint()
  {
  }


  basic_endpoint(const void* socket_address,
      std::size_t socket_address_size, int socket_protocol = 0)
    : impl_(socket_address, socket_address_size, socket_protocol)
  {
  }


  template <typename Endpoint>
  basic_endpoint(const Endpoint& endpoint)
    : impl_(endpoint.data(), endpoint.size(), endpoint.protocol().protocol())
  {
  }


  basic_endpoint(const basic_endpoint& other)
    : impl_(other.impl_)
  {
  }



  basic_endpoint(basic_endpoint&& other)
    : impl_(other.impl_)
  {
  }



  basic_endpoint& operator=(const basic_endpoint& other)
  {
    impl_ = other.impl_;
    return *this;
  }



  basic_endpoint& operator=(basic_endpoint&& other)
  {
    impl_ = other.impl_;
    return *this;
  }



  protocol_type protocol() const
  {
    return protocol_type(impl_.family(), impl_.protocol());
  }


  data_type* data()
  {
    return impl_.data();
  }


  const data_type* data() const
  {
    return impl_.data();
  }


  std::size_t size() const
  {
    return impl_.size();
  }


  void resize(std::size_t new_size)
  {
    impl_.resize(new_size);
  }


  std::size_t capacity() const
  {
    return impl_.capacity();
  }


  friend bool operator==(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return e1.impl_ == e2.impl_;
  }


  friend bool operator!=(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return !(e1.impl_ == e2.impl_);
  }


  friend bool operator<(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return e1.impl_ < e2.impl_;
  }


  friend bool operator>(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return e2.impl_ < e1.impl_;
  }


  friend bool operator<=(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return !(e2 < e1);
  }


  friend bool operator>=(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return !(e1 < e2);
  }

private:

  boost::asio::generic::detail::endpoint impl_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 194 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/datagram_protocol.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/datagram_protocol.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/datagram_protocol.hpp" 2 3 4

namespace boost {
namespace asio {
namespace generic {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/datagram_protocol.hpp" 3 4
class datagram_protocol
{
public:

  datagram_protocol(int address_family, int socket_protocol)
    : family_(address_family),
      protocol_(socket_protocol)
  {
  }





  template <typename Protocol>
  datagram_protocol(const Protocol& source_protocol)
    : family_(source_protocol.family()),
      protocol_(source_protocol.protocol())
  {
    if (source_protocol.type() != type())
    {
      std::bad_cast ex;
      boost::asio::detail::throw_exception(ex);
    }
  }


  int type() const
  {
    return SOCK_DGRAM;
  }


  int protocol() const
  {
    return protocol_;
  }


  int family() const
  {
    return family_;
  }


  friend bool operator==(const datagram_protocol& p1,
      const datagram_protocol& p2)
  {
    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
  }


  friend bool operator!=(const datagram_protocol& p1,
      const datagram_protocol& p2)
  {
    return !(p1 == p2);
  }


  typedef basic_endpoint<datagram_protocol> endpoint;


  typedef basic_datagram_socket<datagram_protocol> socket;

private:
  int family_;
  int protocol_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/datagram_protocol.hpp" 2 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/raw_protocol.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/raw_protocol.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/raw_protocol.hpp" 2 3 4

namespace boost {
namespace asio {
namespace generic {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/raw_protocol.hpp" 3 4
class raw_protocol
{
public:

  raw_protocol(int address_family, int socket_protocol)
    : family_(address_family),
      protocol_(socket_protocol)
  {
  }





  template <typename Protocol>
  raw_protocol(const Protocol& source_protocol)
    : family_(source_protocol.family()),
      protocol_(source_protocol.protocol())
  {
    if (source_protocol.type() != type())
    {
      std::bad_cast ex;
      boost::asio::detail::throw_exception(ex);
    }
  }


  int type() const
  {
    return SOCK_RAW;
  }


  int protocol() const
  {
    return protocol_;
  }


  int family() const
  {
    return family_;
  }


  friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
  {
    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
  }


  friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
  {
    return !(p1 == p2);
  }


  typedef basic_endpoint<raw_protocol> endpoint;


  typedef basic_raw_socket<raw_protocol> socket;

private:
  int family_;
  int protocol_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/raw_protocol.hpp" 2 3 4
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/seq_packet_protocol.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/seq_packet_protocol.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/seq_packet_protocol.hpp" 2 3 4

namespace boost {
namespace asio {
namespace generic {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/seq_packet_protocol.hpp" 3 4
class seq_packet_protocol
{
public:

  seq_packet_protocol(int address_family, int socket_protocol)
    : family_(address_family),
      protocol_(socket_protocol)
  {
  }






  template <typename Protocol>
  seq_packet_protocol(const Protocol& source_protocol)
    : family_(source_protocol.family()),
      protocol_(source_protocol.protocol())
  {
    if (source_protocol.type() != type())
    {
      std::bad_cast ex;
      boost::asio::detail::throw_exception(ex);
    }
  }


  int type() const
  {
    return SOCK_SEQPACKET;
  }


  int protocol() const
  {
    return protocol_;
  }


  int family() const
  {
    return family_;
  }


  friend bool operator==(const seq_packet_protocol& p1,
      const seq_packet_protocol& p2)
  {
    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
  }


  friend bool operator!=(const seq_packet_protocol& p1,
      const seq_packet_protocol& p2)
  {
    return !(p1 == p2);
  }


  typedef basic_endpoint<seq_packet_protocol> endpoint;


  typedef basic_seq_packet_socket<seq_packet_protocol> socket;

private:
  int family_;
  int protocol_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/seq_packet_protocol.hpp" 2 3 4
# 61 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/stream_protocol.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/stream_protocol.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/stream_protocol.hpp" 2 3 4

namespace boost {
namespace asio {
namespace generic {
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/stream_protocol.hpp" 3 4
class stream_protocol
{
public:

  stream_protocol(int address_family, int socket_protocol)
    : family_(address_family),
      protocol_(socket_protocol)
  {
  }





  template <typename Protocol>
  stream_protocol(const Protocol& source_protocol)
    : family_(source_protocol.family()),
      protocol_(source_protocol.protocol())
  {
    if (source_protocol.type() != type())
    {
      std::bad_cast ex;
      boost::asio::detail::throw_exception(ex);
    }
  }


  int type() const
  {
    return SOCK_STREAM;
  }


  int protocol() const
  {
    return protocol_;
  }


  int family() const
  {
    return family_;
  }


  friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
  {
    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
  }


  friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
  {
    return !(p1 == p2);
  }


  typedef basic_endpoint<stream_protocol> endpoint;


  typedef basic_stream_socket<stream_protocol> socket;



  typedef basic_socket_iostream<stream_protocol> iostream;


private:
  int family_;
  int protocol_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/generic/stream_protocol.hpp" 2 3 4
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/high_resolution_timer.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/high_resolution_timer.hpp" 3 4
namespace boost {
namespace asio {
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/high_resolution_timer.hpp" 3 4
typedef basic_waitable_timer<
    chrono::high_resolution_clock>
  high_resolution_timer;

}
}
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_service.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_service.hpp" 2 3 4

namespace boost {
namespace asio {



typedef io_context io_service;


}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_service.hpp" 2 3 4
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/io_service_strand.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/array.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/array.hpp" 3 4
namespace boost {
namespace asio {
namespace detail {


using std::array;




}
}
}
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/winsock_init.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 3 4
class address_v4
{
public:

  typedef uint_least32_t uint_type;
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 3 4
  typedef boost::asio::detail::array<unsigned char, 4> bytes_type;



  address_v4()
  {
    addr_.s_addr = 0;
  }


  inline explicit address_v4(const bytes_type& bytes);


  inline explicit address_v4(uint_type addr);


  address_v4(const address_v4& other)
    : addr_(other.addr_)
  {
  }



  address_v4(address_v4&& other)
    : addr_(other.addr_)
  {
  }



  address_v4& operator=(const address_v4& other)
  {
    addr_ = other.addr_;
    return *this;
  }



  address_v4& operator=(address_v4&& other)
  {
    addr_ = other.addr_;
    return *this;
  }



  inline bytes_type to_bytes() const;


  inline uint_type to_uint() const;



  inline unsigned long to_ulong() const;



  inline std::string to_string() const;




  inline std::string to_string(boost::system::error_code& ec) const;



  static address_v4 from_string(const char* str);



  static address_v4 from_string(
      const char* str, boost::system::error_code& ec);



  static address_v4 from_string(const std::string& str);



  static address_v4 from_string(
      const std::string& str, boost::system::error_code& ec);



  inline bool is_loopback() const;


  inline bool is_unspecified() const;




  inline bool is_class_a() const;



  inline bool is_class_b() const;



  inline bool is_class_c() const;



  inline bool is_multicast() const;


  friend bool operator==(const address_v4& a1, const address_v4& a2)
  {
    return a1.addr_.s_addr == a2.addr_.s_addr;
  }


  friend bool operator!=(const address_v4& a1, const address_v4& a2)
  {
    return a1.addr_.s_addr != a2.addr_.s_addr;
  }


  friend bool operator<(const address_v4& a1, const address_v4& a2)
  {
    return a1.to_uint() < a2.to_uint();
  }


  friend bool operator>(const address_v4& a1, const address_v4& a2)
  {
    return a1.to_uint() > a2.to_uint();
  }


  friend bool operator<=(const address_v4& a1, const address_v4& a2)
  {
    return a1.to_uint() <= a2.to_uint();
  }


  friend bool operator>=(const address_v4& a1, const address_v4& a2)
  {
    return a1.to_uint() >= a2.to_uint();
  }


  static address_v4 any()
  {
    return address_v4();
  }


  static address_v4 loopback()
  {
    return address_v4(0x7F000001);
  }


  static address_v4 broadcast()
  {
    return address_v4(0xFFFFFFFF);
  }





  inline static address_v4 broadcast(
      const address_v4& addr, const address_v4& mask);



  inline static address_v4 netmask(const address_v4& addr);


private:

  boost::asio::detail::in4_addr_type addr_;
};





inline address_v4 make_address_v4(const address_v4::bytes_type& bytes)
{
  return address_v4(bytes);
}





inline address_v4 make_address_v4(address_v4::uint_type addr)
{
  return address_v4(addr);
}





inline address_v4 make_address_v4(const char* str);





inline address_v4 make_address_v4(
    const char* str, boost::system::error_code& ec);





inline address_v4 make_address_v4(const std::string& str);





inline address_v4 make_address_v4(
    const std::string& str, boost::system::error_code& ec);
# 288 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 3 4
inline address_v4 make_address_v4(string_view str);





inline address_v4 make_address_v4(
    string_view str, boost::system::error_code& ec);
# 314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 3 4
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os, const address_v4& addr);



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 325 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {



inline address_v4 address_v4::from_string(const char* str)
{
  return boost::asio::ip::make_address_v4(str);
}

inline address_v4 address_v4::from_string(
    const char* str, boost::system::error_code& ec)
{
  return boost::asio::ip::make_address_v4(str, ec);
}

inline address_v4 address_v4::from_string(const std::string& str)
{
  return boost::asio::ip::make_address_v4(str);
}

inline address_v4 address_v4::from_string(
    const std::string& str, boost::system::error_code& ec)
{
  return boost::asio::ip::make_address_v4(str, ec);
}



template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
{
  return os << addr.to_string().c_str();
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.hpp" 2 3 4
# 327 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.ipp" 3 4
# 1 "/usr/include/c++/10/climits" 1 3 4
# 39 "/usr/include/c++/10/climits" 3 4
       
# 40 "/usr/include/c++/10/climits" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 43 "/usr/include/c++/10/climits" 2 3
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

address_v4::address_v4(const address_v4::bytes_type& bytes)
{
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.ipp" 3 4
  using namespace std;
  memcpy(&addr_.s_addr, bytes.data(), 4);
}

address_v4::address_v4(address_v4::uint_type addr)
{
  if ((std::numeric_limits<uint_type>::max)() > 0xFFFFFFFF)
  {
    std::out_of_range ex("address_v4 from unsigned integer");
    boost::asio::detail::throw_exception(ex);
  }

  addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(
      static_cast<boost::asio::detail::u_long_type>(addr));
}

address_v4::bytes_type address_v4::to_bytes() const
{
  using namespace std;
  bytes_type bytes;

  memcpy(bytes.data(), &addr_.s_addr, 4);



  return bytes;
}

address_v4::uint_type address_v4::to_uint() const
{
  return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
}


unsigned long address_v4::to_ulong() const
{
  return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
}


std::string address_v4::to_string() const
{
  boost::system::error_code ec;
  char addr_str[boost::asio::detail::max_addr_v4_str_len];
  const char* addr =
    boost::asio::detail::socket_ops::inet_ntop(
        2, &addr_, addr_str,
        boost::asio::detail::max_addr_v4_str_len, 0, ec);
  if (addr == 0)
    boost::asio::detail::throw_error(ec);
  return addr;
}


std::string address_v4::to_string(boost::system::error_code& ec) const
{
  char addr_str[boost::asio::detail::max_addr_v4_str_len];
  const char* addr =
    boost::asio::detail::socket_ops::inet_ntop(
        2, &addr_, addr_str,
        boost::asio::detail::max_addr_v4_str_len, 0, ec);
  if (addr == 0)
    return std::string();
  return addr;
}


bool address_v4::is_loopback() const
{
  return (to_uint() & 0xFF000000) == 0x7F000000;
}

bool address_v4::is_unspecified() const
{
  return to_uint() == 0;
}


bool address_v4::is_class_a() const
{
  return (to_uint() & 0x80000000) == 0;
}

bool address_v4::is_class_b() const
{
  return (to_uint() & 0xC0000000) == 0x80000000;
}

bool address_v4::is_class_c() const
{
  return (to_uint() & 0xE0000000) == 0xC0000000;
}


bool address_v4::is_multicast() const
{
  return (to_uint() & 0xF0000000) == 0xE0000000;
}


address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
{
  return address_v4(addr.to_uint() | (mask.to_uint() ^ 0xFFFFFFFF));
}

address_v4 address_v4::netmask(const address_v4& addr)
{
  if (addr.is_class_a())
    return address_v4(0xFF000000);
  if (addr.is_class_b())
    return address_v4(0xFFFF0000);
  if (addr.is_class_c())
    return address_v4(0xFFFFFF00);
  return address_v4(0xFFFFFFFF);
}


address_v4 make_address_v4(const char* str)
{
  boost::system::error_code ec;
  address_v4 addr = make_address_v4(str, ec);
  boost::asio::detail::throw_error(ec);
  return addr;
}

address_v4 make_address_v4(
    const char* str, boost::system::error_code& ec)
{
  address_v4::bytes_type bytes;
  if (boost::asio::detail::socket_ops::inet_pton(
        2, str, &bytes, 0, ec) <= 0)
    return address_v4();
  return address_v4(bytes);
}

address_v4 make_address_v4(const std::string& str)
{
  return make_address_v4(str.c_str());
}

address_v4 make_address_v4(
    const std::string& str, boost::system::error_code& ec)
{
  return make_address_v4(str.c_str(), ec);
}



address_v4 make_address_v4(string_view str)
{
  return make_address_v4(static_cast<std::string>(str));
}

address_v4 make_address_v4(string_view str,
    boost::system::error_code& ec)
{
  return make_address_v4(static_cast<std::string>(str), ec);
}



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
# 329 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

template <typename> class basic_address_iterator;
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 3 4
class address_v6
{
public:
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 3 4
  typedef boost::asio::detail::array<unsigned char, 16> bytes_type;



  inline address_v6();


  inline explicit address_v6(const bytes_type& bytes,
      unsigned long scope_id = 0);


  inline address_v6(const address_v6& other);



  inline address_v6(address_v6&& other);



  inline address_v6& operator=(const address_v6& other);



  inline address_v6& operator=(address_v6&& other);






  unsigned long scope_id() const
  {
    return scope_id_;
  }





  void scope_id(unsigned long id)
  {
    scope_id_ = id;
  }


  inline bytes_type to_bytes() const;


  inline std::string to_string() const;



  inline std::string to_string(boost::system::error_code& ec) const;



  static address_v6 from_string(const char* str);



  static address_v6 from_string(
      const char* str, boost::system::error_code& ec);



  static address_v6 from_string(const std::string& str);



  static address_v6 from_string(
      const std::string& str, boost::system::error_code& ec);



  inline address_v4 to_v4() const;



  inline bool is_loopback() const;


  inline bool is_unspecified() const;


  inline bool is_link_local() const;


  inline bool is_site_local() const;


  inline bool is_v4_mapped() const;




  inline bool is_v4_compatible() const;



  inline bool is_multicast() const;


  inline bool is_multicast_global() const;


  inline bool is_multicast_link_local() const;


  inline bool is_multicast_node_local() const;


  inline bool is_multicast_org_local() const;


  inline bool is_multicast_site_local() const;


  inline friend bool operator==(
      const address_v6& a1, const address_v6& a2);


  friend bool operator!=(const address_v6& a1, const address_v6& a2)
  {
    return !(a1 == a2);
  }


  inline friend bool operator<(
      const address_v6& a1, const address_v6& a2);


  friend bool operator>(const address_v6& a1, const address_v6& a2)
  {
    return a2 < a1;
  }


  friend bool operator<=(const address_v6& a1, const address_v6& a2)
  {
    return !(a2 < a1);
  }


  friend bool operator>=(const address_v6& a1, const address_v6& a2)
  {
    return !(a1 < a2);
  }


  static address_v6 any()
  {
    return address_v6();
  }


  inline static address_v6 loopback();



  inline static address_v6 v4_mapped(const address_v4& addr);


  inline static address_v6 v4_compatible(const address_v4& addr);


private:
  friend class basic_address_iterator<address_v6>;


  boost::asio::detail::in6_addr_type addr_;


  unsigned long scope_id_;
};





inline address_v6 make_address_v6(const address_v6::bytes_type& bytes,
    unsigned long scope_id = 0)
{
  return address_v6(bytes, scope_id);
}





inline address_v6 make_address_v6(const char* str);





inline address_v6 make_address_v6(
    const char* str, boost::system::error_code& ec);





inline address_v6 make_address_v6(const std::string& str);





inline address_v6 make_address_v6(
    const std::string& str, boost::system::error_code& ec);
# 277 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 3 4
inline address_v6 make_address_v6(string_view str);





inline address_v6 make_address_v6(
    string_view str, boost::system::error_code& ec);






enum v4_mapped_t { v4_mapped };





inline address_v4 make_address_v4(
    v4_mapped_t, const address_v6& v6_addr);





inline address_v6 make_address_v6(
    v4_mapped_t, const address_v4& v4_addr);
# 321 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 3 4
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os, const address_v6& addr);



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {



inline address_v6 address_v6::from_string(const char* str)
{
  return boost::asio::ip::make_address_v6(str);
}

inline address_v6 address_v6::from_string(
    const char* str, boost::system::error_code& ec)
{
  return boost::asio::ip::make_address_v6(str, ec);
}

inline address_v6 address_v6::from_string(const std::string& str)
{
  return boost::asio::ip::make_address_v6(str);
}

inline address_v6 address_v6::from_string(
    const std::string& str, boost::system::error_code& ec)
{
  return boost::asio::ip::make_address_v6(str, ec);
}



template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
{
  return os << addr.to_string().c_str();
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.hpp" 2 3 4
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/bad_address_cast.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/bad_address_cast.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/bad_address_cast.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {


class bad_address_cast : public std::bad_cast
{
public:

  bad_address_cast() {}


  virtual ~bad_address_cast() noexcept {}


  virtual const char* what() const noexcept
  {
    return "bad address cast";
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/bad_address_cast.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

address_v6::address_v6()
  : addr_(),
    scope_id_(0)
{
}

address_v6::address_v6(const address_v6::bytes_type& bytes,
    unsigned long scope)
  : scope_id_(scope)
{
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 3 4
  using namespace std;
  memcpy(addr_.__in6_u.__u6_addr8, bytes.data(), 16);
}

address_v6::address_v6(const address_v6& other)
  : addr_(other.addr_),
    scope_id_(other.scope_id_)
{
}


address_v6::address_v6(address_v6&& other)
  : addr_(other.addr_),
    scope_id_(other.scope_id_)
{
}


address_v6& address_v6::operator=(const address_v6& other)
{
  addr_ = other.addr_;
  scope_id_ = other.scope_id_;
  return *this;
}


address_v6& address_v6::operator=(address_v6&& other)
{
  addr_ = other.addr_;
  scope_id_ = other.scope_id_;
  return *this;
}


address_v6::bytes_type address_v6::to_bytes() const
{
  using namespace std;
  bytes_type bytes;

  memcpy(bytes.data(), addr_.__in6_u.__u6_addr8, 16);



  return bytes;
}

std::string address_v6::to_string() const
{
  boost::system::error_code ec;
  char addr_str[boost::asio::detail::max_addr_v6_str_len];
  const char* addr =
    boost::asio::detail::socket_ops::inet_ntop(
        10, &addr_, addr_str,
        boost::asio::detail::max_addr_v6_str_len, scope_id_, ec);
  if (addr == 0)
    boost::asio::detail::throw_error(ec);
  return addr;
}


std::string address_v6::to_string(boost::system::error_code& ec) const
{
  char addr_str[boost::asio::detail::max_addr_v6_str_len];
  const char* addr =
    boost::asio::detail::socket_ops::inet_ntop(
        10, &addr_, addr_str,
        boost::asio::detail::max_addr_v6_str_len, scope_id_, ec);
  if (addr == 0)
    return std::string();
  return addr;
}

address_v4 address_v6::to_v4() const
{
  if (!is_v4_mapped() && !is_v4_compatible())
  {
    bad_address_cast ex;
    boost::asio::detail::throw_exception(ex);
  }

  address_v4::bytes_type v4_bytes = { { addr_.__in6_u.__u6_addr8[12],
    addr_.__in6_u.__u6_addr8[13], addr_.__in6_u.__u6_addr8[14], addr_.__in6_u.__u6_addr8[15] } };
  return address_v4(v4_bytes);
}


bool address_v6::is_loopback() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
      && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
      && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
      && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
      && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
      && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
      && (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
      && (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 1));
}

bool address_v6::is_unspecified() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
      && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
      && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
      && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
      && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
      && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
      && (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
      && (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 0));
}

bool address_v6::is_link_local() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
}

bool address_v6::is_site_local() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0xc0));
}

bool address_v6::is_v4_mapped() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
      && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
      && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
      && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
      && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
      && (addr_.__in6_u.__u6_addr8[10] == 0xff) && (addr_.__in6_u.__u6_addr8[11] == 0xff));
}


bool address_v6::is_v4_compatible() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
      && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
      && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
      && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
      && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
      && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
      && !((addr_.__in6_u.__u6_addr8[12] == 0)
        && (addr_.__in6_u.__u6_addr8[13] == 0)
        && (addr_.__in6_u.__u6_addr8[14] == 0)
        && ((addr_.__in6_u.__u6_addr8[15] == 0) || (addr_.__in6_u.__u6_addr8[15] == 1))));
}


bool address_v6::is_multicast() const
{
  return (addr_.__in6_u.__u6_addr8[0] == 0xff);
}

bool address_v6::is_multicast_global() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x0e));
}

bool address_v6::is_multicast_link_local() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
}

bool address_v6::is_multicast_node_local() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x01));
}

bool address_v6::is_multicast_org_local() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x08));
}

bool address_v6::is_multicast_site_local() const
{
  return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x05));
}

bool operator==(const address_v6& a1, const address_v6& a2)
{
  using namespace std;
  return memcmp(&a1.addr_, &a2.addr_,
      sizeof(boost::asio::detail::in6_addr_type)) == 0
    && a1.scope_id_ == a2.scope_id_;
}

bool operator<(const address_v6& a1, const address_v6& a2)
{
  using namespace std;
  int memcmp_result = memcmp(&a1.addr_, &a2.addr_,
      sizeof(boost::asio::detail::in6_addr_type));
  if (memcmp_result < 0)
    return true;
  if (memcmp_result > 0)
    return false;
  return a1.scope_id_ < a2.scope_id_;
}

address_v6 address_v6::loopback()
{
  address_v6 tmp;
  tmp.addr_.__in6_u.__u6_addr8[15] = 1;
  return tmp;
}


address_v6 address_v6::v4_mapped(const address_v4& addr)
{
  address_v4::bytes_type v4_bytes = addr.to_bytes();
  bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF,
    v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
  return address_v6(v6_bytes);
}

address_v6 address_v6::v4_compatible(const address_v4& addr)
{
  address_v4::bytes_type v4_bytes = addr.to_bytes();
  bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
  return address_v6(v6_bytes);
}


address_v6 make_address_v6(const char* str)
{
  boost::system::error_code ec;
  address_v6 addr = make_address_v6(str, ec);
  boost::asio::detail::throw_error(ec);
  return addr;
}

address_v6 make_address_v6(
    const char* str, boost::system::error_code& ec)
{
  address_v6::bytes_type bytes;
  unsigned long scope_id = 0;
  if (boost::asio::detail::socket_ops::inet_pton(
        10, str, &bytes[0], &scope_id, ec) <= 0)
    return address_v6();
  return address_v6(bytes, scope_id);
}

address_v6 make_address_v6(const std::string& str)
{
  return make_address_v6(str.c_str());
}

address_v6 make_address_v6(
    const std::string& str, boost::system::error_code& ec)
{
  return make_address_v6(str.c_str(), ec);
}



address_v6 make_address_v6(string_view str)
{
  return make_address_v6(static_cast<std::string>(str));
}

address_v6 make_address_v6(string_view str,
    boost::system::error_code& ec)
{
  return make_address_v6(static_cast<std::string>(str), ec);
}



address_v4 make_address_v4(
    v4_mapped_t, const address_v6& v6_addr)
{
  if (!v6_addr.is_v4_mapped())
  {
    bad_address_cast ex;
    boost::asio::detail::throw_exception(ex);
  }

  address_v6::bytes_type v6_bytes = v6_addr.to_bytes();
  address_v4::bytes_type v4_bytes = { { v6_bytes[12],
    v6_bytes[13], v6_bytes[14], v6_bytes[15] } };
  return address_v4(v4_bytes);
}

address_v6 make_address_v6(
    v4_mapped_t, const address_v4& v4_addr)
{
  address_v4::bytes_type v4_bytes = v4_addr.to_bytes();
  address_v6::bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0xFF, 0xFF, v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
  return address_v6(v6_bytes);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 351 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
# 336 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 3 4
class address
{
public:

  inline address();


  inline address(const boost::asio::ip::address_v4& ipv4_address);


  inline address(const boost::asio::ip::address_v6& ipv6_address);


  inline address(const address& other);



  inline address(address&& other);



  inline address& operator=(const address& other);



  inline address& operator=(address&& other);



  inline address& operator=(
      const boost::asio::ip::address_v4& ipv4_address);


  inline address& operator=(
      const boost::asio::ip::address_v6& ipv6_address);


  bool is_v4() const
  {
    return type_ == ipv4;
  }


  bool is_v6() const
  {
    return type_ == ipv6;
  }


  inline boost::asio::ip::address_v4 to_v4() const;


  inline boost::asio::ip::address_v6 to_v6() const;


  inline std::string to_string() const;



  inline std::string to_string(boost::system::error_code& ec) const;




  static address from_string(const char* str);




  static address from_string(const char* str, boost::system::error_code& ec);




  static address from_string(const std::string& str);




  static address from_string(
      const std::string& str, boost::system::error_code& ec);



  inline bool is_loopback() const;


  inline bool is_unspecified() const;


  inline bool is_multicast() const;


  inline friend bool operator==(const address& a1, const address& a2);


  friend bool operator!=(const address& a1, const address& a2)
  {
    return !(a1 == a2);
  }


  inline friend bool operator<(const address& a1, const address& a2);


  friend bool operator>(const address& a1, const address& a2)
  {
    return a2 < a1;
  }


  friend bool operator<=(const address& a1, const address& a2)
  {
    return !(a2 < a1);
  }


  friend bool operator>=(const address& a1, const address& a2)
  {
    return !(a1 < a2);
  }

private:

  enum { ipv4, ipv6 } type_;


  boost::asio::ip::address_v4 ipv4_address_;


  boost::asio::ip::address_v6 ipv6_address_;
};






inline address make_address(const char* str);






inline address make_address(
    const char* str, boost::system::error_code& ec);






inline address make_address(const std::string& str);






inline address make_address(
    const std::string& str, boost::system::error_code& ec);
# 218 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 3 4
inline address make_address(string_view str);






inline address make_address(
    string_view str, boost::system::error_code& ec);
# 245 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 3 4
template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os, const address& addr);



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 256 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {



inline address address::from_string(const char* str)
{
  return boost::asio::ip::make_address(str);
}

inline address address::from_string(
    const char* str, boost::system::error_code& ec)
{
  return boost::asio::ip::make_address(str, ec);
}

inline address address::from_string(const std::string& str)
{
  return boost::asio::ip::make_address(str);
}

inline address address::from_string(
    const std::string& str, boost::system::error_code& ec)
{
  return boost::asio::ip::make_address(str, ec);
}



template <typename Elem, typename Traits>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os, const address& addr)
{
  return os << addr.to_string().c_str();
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.hpp" 2 3 4
# 258 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.ipp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.ipp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.ipp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

address::address()
  : type_(ipv4),
    ipv4_address_(),
    ipv6_address_()
{
}

address::address(const boost::asio::ip::address_v4& ipv4_address)
  : type_(ipv4),
    ipv4_address_(ipv4_address),
    ipv6_address_()
{
}

address::address(const boost::asio::ip::address_v6& ipv6_address)
  : type_(ipv6),
    ipv4_address_(),
    ipv6_address_(ipv6_address)
{
}

address::address(const address& other)
  : type_(other.type_),
    ipv4_address_(other.ipv4_address_),
    ipv6_address_(other.ipv6_address_)
{
}


address::address(address&& other)
  : type_(other.type_),
    ipv4_address_(other.ipv4_address_),
    ipv6_address_(other.ipv6_address_)
{
}


address& address::operator=(const address& other)
{
  type_ = other.type_;
  ipv4_address_ = other.ipv4_address_;
  ipv6_address_ = other.ipv6_address_;
  return *this;
}


address& address::operator=(address&& other)
{
  type_ = other.type_;
  ipv4_address_ = other.ipv4_address_;
  ipv6_address_ = other.ipv6_address_;
  return *this;
}


address& address::operator=(const boost::asio::ip::address_v4& ipv4_address)
{
  type_ = ipv4;
  ipv4_address_ = ipv4_address;
  ipv6_address_ = boost::asio::ip::address_v6();
  return *this;
}

address& address::operator=(const boost::asio::ip::address_v6& ipv6_address)
{
  type_ = ipv6;
  ipv4_address_ = boost::asio::ip::address_v4();
  ipv6_address_ = ipv6_address;
  return *this;
}

address make_address(const char* str)
{
  boost::system::error_code ec;
  address addr = make_address(str, ec);
  boost::asio::detail::throw_error(ec);
  return addr;
}

address make_address(const char* str, boost::system::error_code& ec)
{
  boost::asio::ip::address_v6 ipv6_address =
    boost::asio::ip::make_address_v6(str, ec);
  if (!ec)
    return address(ipv6_address);

  boost::asio::ip::address_v4 ipv4_address =
    boost::asio::ip::make_address_v4(str, ec);
  if (!ec)
    return address(ipv4_address);

  return address();
}

address make_address(const std::string& str)
{
  return make_address(str.c_str());
}

address make_address(const std::string& str,
    boost::system::error_code& ec)
{
  return make_address(str.c_str(), ec);
}



address make_address(string_view str)
{
  return make_address(static_cast<std::string>(str));
}

address make_address(string_view str,
    boost::system::error_code& ec)
{
  return make_address(static_cast<std::string>(str), ec);
}



boost::asio::ip::address_v4 address::to_v4() const
{
  if (type_ != ipv4)
  {
    bad_address_cast ex;
    boost::asio::detail::throw_exception(ex);
  }
  return ipv4_address_;
}

boost::asio::ip::address_v6 address::to_v6() const
{
  if (type_ != ipv6)
  {
    bad_address_cast ex;
    boost::asio::detail::throw_exception(ex);
  }
  return ipv6_address_;
}

std::string address::to_string() const
{
  if (type_ == ipv6)
    return ipv6_address_.to_string();
  return ipv4_address_.to_string();
}


std::string address::to_string(boost::system::error_code& ec) const
{
  if (type_ == ipv6)
    return ipv6_address_.to_string(ec);
  return ipv4_address_.to_string(ec);
}


bool address::is_loopback() const
{
  return (type_ == ipv4)
    ? ipv4_address_.is_loopback()
    : ipv6_address_.is_loopback();
}

bool address::is_unspecified() const
{
  return (type_ == ipv4)
    ? ipv4_address_.is_unspecified()
    : ipv6_address_.is_unspecified();
}

bool address::is_multicast() const
{
  return (type_ == ipv4)
    ? ipv4_address_.is_multicast()
    : ipv6_address_.is_multicast();
}

bool operator==(const address& a1, const address& a2)
{
  if (a1.type_ != a2.type_)
    return false;
  if (a1.type_ == address::ipv6)
    return a1.ipv6_address_ == a2.ipv6_address_;
  return a1.ipv4_address_ == a2.ipv4_address_;
}

bool operator<(const address& a1, const address& a2)
{
  if (a1.type_ < a2.type_)
    return true;
  if (a1.type_ > a2.type_)
    return false;
  if (a1.type_ == address::ipv6)
    return a1.ipv6_address_ < a2.ipv6_address_;
  return a1.ipv4_address_ < a2.ipv4_address_;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 235 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/address.ipp" 2 3 4
# 260 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address.hpp" 2 3 4
# 72 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_iterator.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_iterator.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

template <typename> class basic_address_iterator;
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_iterator.hpp" 3 4
template <> class basic_address_iterator<address_v4>
{
public:

  typedef address_v4 value_type;


  typedef std::ptrdiff_t difference_type;


  typedef const address_v4* pointer;


  typedef const address_v4& reference;


  typedef std::input_iterator_tag iterator_category;


  basic_address_iterator(const address_v4& addr) noexcept
    : address_(addr)
  {
  }


  basic_address_iterator(
      const basic_address_iterator& other) noexcept
    : address_(other.address_)
  {
  }



  basic_address_iterator(basic_address_iterator&& other) noexcept
    : address_(static_cast<address_v4&&>(other.address_))
  {
  }



  basic_address_iterator& operator=(
      const basic_address_iterator& other) noexcept
  {
    address_ = other.address_;
    return *this;
  }



  basic_address_iterator& operator=(
      basic_address_iterator&& other) noexcept
  {
    address_ = static_cast<address_v4&&>(other.address_);
    return *this;
  }



  const address_v4& operator*() const noexcept
  {
    return address_;
  }


  const address_v4* operator->() const noexcept
  {
    return &address_;
  }


  basic_address_iterator& operator++() noexcept
  {
    address_ = address_v4((address_.to_uint() + 1) & 0xFFFFFFFF);
    return *this;
  }


  basic_address_iterator operator++(int) noexcept
  {
    basic_address_iterator tmp(*this);
    ++*this;
    return tmp;
  }


  basic_address_iterator& operator--() noexcept
  {
    address_ = address_v4((address_.to_uint() - 1) & 0xFFFFFFFF);
    return *this;
  }


  basic_address_iterator operator--(int)
  {
    basic_address_iterator tmp(*this);
    --*this;
    return tmp;
  }


  friend bool operator==(const basic_address_iterator& a,
      const basic_address_iterator& b)
  {
    return a.address_ == b.address_;
  }


  friend bool operator!=(const basic_address_iterator& a,
      const basic_address_iterator& b)
  {
    return a.address_ != b.address_;
  }

private:
  address_v4 address_;
};


typedef basic_address_iterator<address_v4> address_v4_iterator;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_iterator.hpp" 2 3 4
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_range.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_range.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_range.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

template <typename> class basic_address_range;







template <> class basic_address_range<address_v4>
{
public:

  typedef basic_address_iterator<address_v4> iterator;


  basic_address_range() noexcept
    : begin_(address_v4()),
      end_(address_v4())
  {
  }


  explicit basic_address_range(const iterator& first,
      const iterator& last) noexcept
    : begin_(first),
      end_(last)
  {
  }


  basic_address_range(const basic_address_range& other) noexcept
    : begin_(other.begin_),
      end_(other.end_)
  {
  }



  basic_address_range(basic_address_range&& other) noexcept
    : begin_(static_cast<iterator&&>(other.begin_)),
      end_(static_cast<iterator&&>(other.end_))
  {
  }



  basic_address_range& operator=(
      const basic_address_range& other) noexcept
  {
    begin_ = other.begin_;
    end_ = other.end_;
    return *this;
  }



  basic_address_range& operator=(
      basic_address_range&& other) noexcept
  {
    begin_ = static_cast<iterator&&>(other.begin_);
    end_ = static_cast<iterator&&>(other.end_);
    return *this;
  }



  iterator begin() const noexcept
  {
    return begin_;
  }


  iterator end() const noexcept
  {
    return end_;
  }


  bool empty() const noexcept
  {
    return size() == 0;
  }


  std::size_t size() const noexcept
  {
    return end_->to_uint() - begin_->to_uint();
  }


  iterator find(const address_v4& addr) const noexcept
  {
    return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
  }

private:
  iterator begin_;
  iterator end_;
};


typedef basic_address_range<address_v4> address_v4_range;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v4_range.hpp" 2 3 4
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_iterator.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_iterator.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_iterator.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

template <typename> class basic_address_iterator;
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_iterator.hpp" 3 4
template <> class basic_address_iterator<address_v6>
{
public:

  typedef address_v6 value_type;


  typedef std::ptrdiff_t difference_type;


  typedef const address_v6* pointer;


  typedef const address_v6& reference;


  typedef std::input_iterator_tag iterator_category;


  basic_address_iterator(const address_v6& addr) noexcept
    : address_(addr)
  {
  }


  basic_address_iterator(
      const basic_address_iterator& other) noexcept
    : address_(other.address_)
  {
  }



  basic_address_iterator(basic_address_iterator&& other) noexcept
    : address_(static_cast<address_v6&&>(other.address_))
  {
  }



  basic_address_iterator& operator=(
      const basic_address_iterator& other) noexcept
  {
    address_ = other.address_;
    return *this;
  }



  basic_address_iterator& operator=(
      basic_address_iterator&& other) noexcept
  {
    address_ = static_cast<address_v6&&>(other.address_);
    return *this;
  }



  const address_v6& operator*() const noexcept
  {
    return address_;
  }


  const address_v6* operator->() const noexcept
  {
    return &address_;
  }


  basic_address_iterator& operator++() noexcept
  {
    for (int i = 15; i >= 0; --i)
    {
      if (address_.addr_.__in6_u.__u6_addr8[i] < 0xFF)
      {
        ++address_.addr_.__in6_u.__u6_addr8[i];
        break;
      }

      address_.addr_.__in6_u.__u6_addr8[i] = 0;
    }

    return *this;
  }


  basic_address_iterator operator++(int) noexcept
  {
    basic_address_iterator tmp(*this);
    ++*this;
    return tmp;
  }


  basic_address_iterator& operator--() noexcept
  {
    for (int i = 15; i >= 0; --i)
    {
      if (address_.addr_.__in6_u.__u6_addr8[i] > 0)
      {
        --address_.addr_.__in6_u.__u6_addr8[i];
        break;
      }

      address_.addr_.__in6_u.__u6_addr8[i] = 0xFF;
    }

    return *this;
  }


  basic_address_iterator operator--(int)
  {
    basic_address_iterator tmp(*this);
    --*this;
    return tmp;
  }


  friend bool operator==(const basic_address_iterator& a,
      const basic_address_iterator& b)
  {
    return a.address_ == b.address_;
  }


  friend bool operator!=(const basic_address_iterator& a,
      const basic_address_iterator& b)
  {
    return a.address_ != b.address_;
  }

private:
  address_v6 address_;
};


typedef basic_address_iterator<address_v6> address_v6_iterator;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_iterator.hpp" 2 3 4
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_range.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_range.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_range.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

template <typename> class basic_address_range;







template <> class basic_address_range<address_v6>
{
public:

  typedef basic_address_iterator<address_v6> iterator;


  basic_address_range() noexcept
    : begin_(address_v6()),
      end_(address_v6())
  {
  }


  explicit basic_address_range(const iterator& first,
      const iterator& last) noexcept
    : begin_(first),
      end_(last)
  {
  }


  basic_address_range(const basic_address_range& other) noexcept
    : begin_(other.begin_),
      end_(other.end_)
  {
  }



  basic_address_range(basic_address_range&& other) noexcept
    : begin_(static_cast<iterator&&>(other.begin_)),
      end_(static_cast<iterator&&>(other.end_))
  {
  }



  basic_address_range& operator=(
      const basic_address_range& other) noexcept
  {
    begin_ = other.begin_;
    end_ = other.end_;
    return *this;
  }



  basic_address_range& operator=(
      basic_address_range&& other) noexcept
  {
    begin_ = static_cast<iterator&&>(other.begin_);
    end_ = static_cast<iterator&&>(other.end_);
    return *this;
  }



  iterator begin() const noexcept
  {
    return begin_;
  }


  iterator end() const noexcept
  {
    return end_;
  }


  bool empty() const noexcept
  {
    return begin_ == end_;
  }


  iterator find(const address_v6& addr) const noexcept
  {
    return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
  }

private:
  iterator begin_;
  iterator end_;
};


typedef basic_address_range<address_v6> address_v6_range;

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/address_v6_range.hpp" 2 3 4
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/endpoint.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/endpoint.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
namespace detail {


class endpoint
{
public:

  inline endpoint();


  inline endpoint(int family, unsigned short port_num);


  inline endpoint(const boost::asio::ip::address& addr,
      unsigned short port_num);


  endpoint(const endpoint& other)
    : data_(other.data_)
  {
  }


  endpoint& operator=(const endpoint& other)
  {
    data_ = other.data_;
    return *this;
  }


  boost::asio::detail::socket_addr_type* data()
  {
    return &data_.base;
  }


  const boost::asio::detail::socket_addr_type* data() const
  {
    return &data_.base;
  }


  std::size_t size() const
  {
    if (is_v4())
      return sizeof(boost::asio::detail::sockaddr_in4_type);
    else
      return sizeof(boost::asio::detail::sockaddr_in6_type);
  }


  inline void resize(std::size_t new_size);


  std::size_t capacity() const
  {
    return sizeof(data_);
  }


  inline unsigned short port() const;


  inline void port(unsigned short port_num);


  inline boost::asio::ip::address address() const;


  inline void address(const boost::asio::ip::address& addr);


  inline friend bool operator==(
      const endpoint& e1, const endpoint& e2);


  inline friend bool operator<(
      const endpoint& e1, const endpoint& e2);


  bool is_v4() const
  {
    return data_.base.sa_family == 2;
  }



  inline std::string to_string() const;


private:

  union data_union
  {
    boost::asio::detail::socket_addr_type base;
    boost::asio::detail::sockaddr_in4_type v4;
    boost::asio::detail::sockaddr_in6_type v6;
  } data_;
};

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/impl/endpoint.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/impl/endpoint.ipp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/endpoint.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
namespace detail {

endpoint::endpoint()
  : data_()
{
  data_.v4.sin_family = 2;
  data_.v4.sin_port = 0;
  data_.v4.sin_addr.s_addr = ((in_addr_t) 0x00000000);
}

endpoint::endpoint(int family, unsigned short port_num)
  : data_()
{
  using namespace std;
  if (family == 2)
  {
    data_.v4.sin_family = 2;
    data_.v4.sin_port =
      boost::asio::detail::socket_ops::host_to_network_short(port_num);
    data_.v4.sin_addr.s_addr = ((in_addr_t) 0x00000000);
  }
  else
  {
    data_.v6.sin6_family = 10;
    data_.v6.sin6_port =
      boost::asio::detail::socket_ops::host_to_network_short(port_num);
    data_.v6.sin6_flowinfo = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[0] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[1] = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[2] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[3] = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[4] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[5] = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[6] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[7] = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[8] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[9] = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[10] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[11] = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[12] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[13] = 0;
    data_.v6.sin6_addr.__in6_u.__u6_addr8[14] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[15] = 0;
    data_.v6.sin6_scope_id = 0;
  }
}

endpoint::endpoint(const boost::asio::ip::address& addr,
    unsigned short port_num)
  : data_()
{
  using namespace std;
  if (addr.is_v4())
  {
    data_.v4.sin_family = 2;
    data_.v4.sin_port =
      boost::asio::detail::socket_ops::host_to_network_short(port_num);
    data_.v4.sin_addr.s_addr =
      boost::asio::detail::socket_ops::host_to_network_long(
        addr.to_v4().to_uint());
  }
  else
  {
    data_.v6.sin6_family = 10;
    data_.v6.sin6_port =
      boost::asio::detail::socket_ops::host_to_network_short(port_num);
    data_.v6.sin6_flowinfo = 0;
    boost::asio::ip::address_v6 v6_addr = addr.to_v6();
    boost::asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
    memcpy(data_.v6.sin6_addr.__in6_u.__u6_addr8, bytes.data(), 16);
    data_.v6.sin6_scope_id =
      static_cast<boost::asio::detail::u_long_type>(
        v6_addr.scope_id());
  }
}

void endpoint::resize(std::size_t new_size)
{
  if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
  {
    boost::system::error_code ec(boost::asio::error::invalid_argument);
    boost::asio::detail::throw_error(ec);
  }
}

unsigned short endpoint::port() const
{
  if (is_v4())
  {
    return boost::asio::detail::socket_ops::network_to_host_short(
        data_.v4.sin_port);
  }
  else
  {
    return boost::asio::detail::socket_ops::network_to_host_short(
        data_.v6.sin6_port);
  }
}

void endpoint::port(unsigned short port_num)
{
  if (is_v4())
  {
    data_.v4.sin_port
      = boost::asio::detail::socket_ops::host_to_network_short(port_num);
  }
  else
  {
    data_.v6.sin6_port
      = boost::asio::detail::socket_ops::host_to_network_short(port_num);
  }
}

boost::asio::ip::address endpoint::address() const
{
  using namespace std;
  if (is_v4())
  {
    return boost::asio::ip::address_v4(
        boost::asio::detail::socket_ops::network_to_host_long(
          data_.v4.sin_addr.s_addr));
  }
  else
  {
    boost::asio::ip::address_v6::bytes_type bytes;

    memcpy(bytes.data(), data_.v6.sin6_addr.__in6_u.__u6_addr8, 16);



    return boost::asio::ip::address_v6(bytes, data_.v6.sin6_scope_id);
  }
}

void endpoint::address(const boost::asio::ip::address& addr)
{
  endpoint tmp_endpoint(addr, port());
  data_ = tmp_endpoint.data_;
}

bool operator==(const endpoint& e1, const endpoint& e2)
{
  return e1.address() == e2.address() && e1.port() == e2.port();
}

bool operator<(const endpoint& e1, const endpoint& e2)
{
  if (e1.address() < e2.address())
    return true;
  if (e1.address() != e2.address())
    return false;
  return e1.port() < e2.port();
}


std::string endpoint::to_string() const
{
  std::ostringstream tmp_os;
  tmp_os.imbue(std::locale::classic());
  if (is_v4())
    tmp_os << address();
  else
    tmp_os << '[' << address() << ']';
  tmp_os << ':' << port();

  return tmp_os.str();
}


}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 200 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
# 139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 3 4
template <typename InternetProtocol>
class basic_endpoint
{
public:

  typedef InternetProtocol protocol_type;






  typedef boost::asio::detail::socket_addr_type data_type;



  basic_endpoint()
    : impl_()
  {
  }
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 3 4
  basic_endpoint(const InternetProtocol& internet_protocol,
      unsigned short port_num)
    : impl_(internet_protocol.family(), port_num)
  {
  }




  basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
    : impl_(addr, port_num)
  {
  }


  basic_endpoint(const basic_endpoint& other)
    : impl_(other.impl_)
  {
  }



  basic_endpoint(basic_endpoint&& other)
    : impl_(other.impl_)
  {
  }



  basic_endpoint& operator=(const basic_endpoint& other)
  {
    impl_ = other.impl_;
    return *this;
  }



  basic_endpoint& operator=(basic_endpoint&& other)
  {
    impl_ = other.impl_;
    return *this;
  }



  protocol_type protocol() const
  {
    if (impl_.is_v4())
      return InternetProtocol::v4();
    return InternetProtocol::v6();
  }


  data_type* data()
  {
    return impl_.data();
  }


  const data_type* data() const
  {
    return impl_.data();
  }


  std::size_t size() const
  {
    return impl_.size();
  }


  void resize(std::size_t new_size)
  {
    impl_.resize(new_size);
  }


  std::size_t capacity() const
  {
    return impl_.capacity();
  }



  unsigned short port() const
  {
    return impl_.port();
  }



  void port(unsigned short port_num)
  {
    impl_.port(port_num);
  }


  boost::asio::ip::address address() const
  {
    return impl_.address();
  }


  void address(const boost::asio::ip::address& addr)
  {
    impl_.address(addr);
  }


  friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
      const basic_endpoint<InternetProtocol>& e2)
  {
    return e1.impl_ == e2.impl_;
  }


  friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
      const basic_endpoint<InternetProtocol>& e2)
  {
    return !(e1 == e2);
  }


  friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
      const basic_endpoint<InternetProtocol>& e2)
  {
    return e1.impl_ < e2.impl_;
  }


  friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
      const basic_endpoint<InternetProtocol>& e2)
  {
    return e2.impl_ < e1.impl_;
  }


  friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
      const basic_endpoint<InternetProtocol>& e2)
  {
    return !(e2 < e1);
  }


  friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
      const basic_endpoint<InternetProtocol>& e2)
  {
    return !(e1 < e2);
  }

private:

  boost::asio::ip::detail::endpoint impl_;
};
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 3 4
template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os,
    const basic_endpoint<InternetProtocol>& endpoint);



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 262 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/basic_endpoint.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/basic_endpoint.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/basic_endpoint.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

template <typename Elem, typename Traits, typename InternetProtocol>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os,
    const basic_endpoint<InternetProtocol>& endpoint)
{
  boost::asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
  return os << tmp_ep.to_string().c_str();
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/basic_endpoint.hpp" 2 3 4
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_iterator.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_iterator.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_entry.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_entry.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_entry.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_entry.hpp" 3 4
template <typename InternetProtocol>
class basic_resolver_entry
{
public:

  typedef InternetProtocol protocol_type;


  typedef typename InternetProtocol::endpoint endpoint_type;


  basic_resolver_entry()
  {
  }


  basic_resolver_entry(const endpoint_type& ep,
      boost::asio::string_view host, boost::asio::string_view service)
    : endpoint_(ep),
      host_name_(static_cast<std::string>(host)),
      service_name_(static_cast<std::string>(service))
  {
  }


  endpoint_type endpoint() const
  {
    return endpoint_;
  }


  operator endpoint_type() const
  {
    return endpoint_;
  }


  std::string host_name() const
  {
    return host_name_;
  }


  template <class Allocator>
  std::basic_string<char, std::char_traits<char>, Allocator> host_name(
      const Allocator& alloc = Allocator()) const
  {
    return std::basic_string<char, std::char_traits<char>, Allocator>(
        host_name_.c_str(), alloc);
  }


  std::string service_name() const
  {
    return service_name_;
  }


  template <class Allocator>
  std::basic_string<char, std::char_traits<char>, Allocator> service_name(
      const Allocator& alloc = Allocator()) const
  {
    return std::basic_string<char, std::char_traits<char>, Allocator>(
        service_name_.c_str(), alloc);
  }

private:
  endpoint_type endpoint_;
  std::string host_name_;
  std::string service_name_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_entry.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_iterator.hpp" 3 4
template <typename InternetProtocol>
class basic_resolver_iterator
{
public:

  typedef std::ptrdiff_t difference_type;


  typedef basic_resolver_entry<InternetProtocol> value_type;


  typedef const basic_resolver_entry<InternetProtocol>* pointer;


  typedef const basic_resolver_entry<InternetProtocol>& reference;


  typedef std::forward_iterator_tag iterator_category;


  basic_resolver_iterator()
    : index_(0)
  {
  }


  basic_resolver_iterator(const basic_resolver_iterator& other)
    : values_(other.values_),
      index_(other.index_)
  {
  }



  basic_resolver_iterator(basic_resolver_iterator&& other)
    : values_(static_cast<values_ptr_type&&>(other.values_)),
      index_(other.index_)
  {
    other.index_ = 0;
  }



  basic_resolver_iterator& operator=(const basic_resolver_iterator& other)
  {
    values_ = other.values_;
    index_ = other.index_;
    return *this;
  }



  basic_resolver_iterator& operator=(basic_resolver_iterator&& other)
  {
    if (this != &other)
    {
      values_ = static_cast<values_ptr_type&&>(other.values_);
      index_ = other.index_;
      other.index_ = 0;
    }

    return *this;
  }



  const basic_resolver_entry<InternetProtocol>& operator*() const
  {
    return dereference();
  }


  const basic_resolver_entry<InternetProtocol>* operator->() const
  {
    return &dereference();
  }


  basic_resolver_iterator& operator++()
  {
    increment();
    return *this;
  }


  basic_resolver_iterator operator++(int)
  {
    basic_resolver_iterator tmp(*this);
    ++*this;
    return tmp;
  }


  friend bool operator==(const basic_resolver_iterator& a,
      const basic_resolver_iterator& b)
  {
    return a.equal(b);
  }


  friend bool operator!=(const basic_resolver_iterator& a,
      const basic_resolver_iterator& b)
  {
    return !a.equal(b);
  }

protected:
  void increment()
  {
    if (++index_ == values_->size())
    {

      values_.reset();
      index_ = 0;
    }
  }

  bool equal(const basic_resolver_iterator& other) const
  {
    if (!values_ && !other.values_)
      return true;
    if (values_ != other.values_)
      return false;
    return index_ == other.index_;
  }

  const basic_resolver_entry<InternetProtocol>& dereference() const
  {
    return (*values_)[index_];
  }

  typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
  typedef boost::asio::detail::shared_ptr<values_type> values_ptr_type;
  values_ptr_type values_;
  std::size_t index_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 193 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_query_base.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_query_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_base.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_base.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {



class resolver_base
{
public:
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_base.hpp" 3 4
  enum flags
  {
    canonical_name = 0x0002,
    passive = 0x0001,
    numeric_host = 0x0004,
    numeric_service = 0x0400,
    v4_mapped = 0x0008,
    all_matching = 0x0010,
    address_configured = 0x0020
  };



  friend flags operator&(flags x, flags y)
  {
    return static_cast<flags>(
        static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
  }

  friend flags operator|(flags x, flags y)
  {
    return static_cast<flags>(
        static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
  }

  friend flags operator^(flags x, flags y)
  {
    return static_cast<flags>(
        static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
  }

  friend flags operator~(flags x)
  {
    return static_cast<flags>(~static_cast<unsigned int>(x));
  }

  friend flags& operator&=(flags& x, flags y)
  {
    x = x & y;
    return x;
  }

  friend flags& operator|=(flags& x, flags y)
  {
    x = x | y;
    return x;
  }

  friend flags& operator^=(flags& x, flags y)
  {
    x = x ^ y;
    return x;
  }


protected:

  ~resolver_base()
  {
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_base.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {




class resolver_query_base : public resolver_base
{
protected:

  ~resolver_query_base()
  {
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
template <typename InternetProtocol>
class basic_resolver_query
  : public resolver_query_base
{
public:

  typedef InternetProtocol protocol_type;
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
  basic_resolver_query(const std::string& service,
      resolver_query_base::flags resolve_flags = passive | address_configured)
    : hints_(),
      host_name_(),
      service_name_(service)
  {
    typename InternetProtocol::endpoint endpoint;
    hints_.ai_flags = static_cast<int>(resolve_flags);
    hints_.ai_family = 0;
    hints_.ai_socktype = endpoint.protocol().type();
    hints_.ai_protocol = endpoint.protocol().protocol();
    hints_.ai_addrlen = 0;
    hints_.ai_canonname = 0;
    hints_.ai_addr = 0;
    hints_.ai_next = 0;
  }
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
  basic_resolver_query(const protocol_type& protocol,
      const std::string& service,
      resolver_query_base::flags resolve_flags = passive | address_configured)
    : hints_(),
      host_name_(),
      service_name_(service)
  {
    hints_.ai_flags = static_cast<int>(resolve_flags);
    hints_.ai_family = protocol.family();
    hints_.ai_socktype = protocol.type();
    hints_.ai_protocol = protocol.protocol();
    hints_.ai_addrlen = 0;
    hints_.ai_canonname = 0;
    hints_.ai_addr = 0;
    hints_.ai_next = 0;
  }
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
  basic_resolver_query(const std::string& host, const std::string& service,
      resolver_query_base::flags resolve_flags = address_configured)
    : hints_(),
      host_name_(host),
      service_name_(service)
  {
    typename InternetProtocol::endpoint endpoint;
    hints_.ai_flags = static_cast<int>(resolve_flags);
    hints_.ai_family = 0;
    hints_.ai_socktype = endpoint.protocol().type();
    hints_.ai_protocol = endpoint.protocol().protocol();
    hints_.ai_addrlen = 0;
    hints_.ai_canonname = 0;
    hints_.ai_addr = 0;
    hints_.ai_next = 0;
  }
# 199 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
  basic_resolver_query(const protocol_type& protocol,
      const std::string& host, const std::string& service,
      resolver_query_base::flags resolve_flags = address_configured)
    : hints_(),
      host_name_(host),
      service_name_(service)
  {
    hints_.ai_flags = static_cast<int>(resolve_flags);
    hints_.ai_family = protocol.family();
    hints_.ai_socktype = protocol.type();
    hints_.ai_protocol = protocol.protocol();
    hints_.ai_addrlen = 0;
    hints_.ai_canonname = 0;
    hints_.ai_addr = 0;
    hints_.ai_next = 0;
  }


  const boost::asio::detail::addrinfo_type& hints() const
  {
    return hints_;
  }


  std::string host_name() const
  {
    return host_name_;
  }


  std::string service_name() const
  {
    return service_name_;
  }

private:
  boost::asio::detail::addrinfo_type hints_;
  std::string host_name_;
  std::string service_name_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 245 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
template <typename InternetProtocol>
class basic_resolver_results

  : public basic_resolver_iterator<InternetProtocol>



{
public:

  typedef InternetProtocol protocol_type;


  typedef typename protocol_type::endpoint endpoint_type;


  typedef basic_resolver_entry<protocol_type> value_type;


  typedef const value_type& const_reference;


  typedef value_type& reference;


  typedef basic_resolver_iterator<protocol_type> const_iterator;


  typedef const_iterator iterator;


  typedef std::ptrdiff_t difference_type;


  typedef std::size_t size_type;


  basic_resolver_results()
  {
  }


  basic_resolver_results(const basic_resolver_results& other)
    : basic_resolver_iterator<InternetProtocol>(other)
  {
  }



  basic_resolver_results(basic_resolver_results&& other)
    : basic_resolver_iterator<InternetProtocol>(
        static_cast<basic_resolver_results&&>(other))
  {
  }



  basic_resolver_results& operator=(const basic_resolver_results& other)
  {
    basic_resolver_iterator<InternetProtocol>::operator=(other);
    return *this;
  }



  basic_resolver_results& operator=(basic_resolver_results&& other)
  {
    basic_resolver_iterator<InternetProtocol>::operator=(
        static_cast<basic_resolver_results&&>(other));
    return *this;
  }




  static basic_resolver_results create(
      boost::asio::detail::addrinfo_type* address_info,
      const std::string& host_name, const std::string& service_name)
  {
    basic_resolver_results results;
    if (!address_info)
      return results;

    std::string actual_host_name = host_name;
    if (address_info->ai_canonname)
      actual_host_name = address_info->ai_canonname;

    results.values_.reset(new values_type);

    while (address_info)
    {
      if (address_info->ai_family == 2
          || address_info->ai_family == 10)
      {
        using namespace std;
        typename InternetProtocol::endpoint endpoint;
        endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
        memcpy(endpoint.data(), address_info->ai_addr,
            address_info->ai_addrlen);
        results.values_->push_back(
            basic_resolver_entry<InternetProtocol>(endpoint,
              actual_host_name, service_name));
      }
      address_info = address_info->ai_next;
    }

    return results;
  }


  static basic_resolver_results create(const endpoint_type& endpoint,
      const std::string& host_name, const std::string& service_name)
  {
    basic_resolver_results results;
    results.values_.reset(new values_type);
    results.values_->push_back(
        basic_resolver_entry<InternetProtocol>(
          endpoint, host_name, service_name));
    return results;
  }


  template <typename EndpointIterator>
  static basic_resolver_results create(
      EndpointIterator begin, EndpointIterator end,
      const std::string& host_name, const std::string& service_name)
  {
    basic_resolver_results results;
    if (begin != end)
    {
      results.values_.reset(new values_type);
      for (EndpointIterator ep_iter = begin; ep_iter != end; ++ep_iter)
      {
        results.values_->push_back(
            basic_resolver_entry<InternetProtocol>(
              *ep_iter, host_name, service_name));
      }
    }
    return results;
  }
# 234 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
  size_type size() const noexcept
  {
    return this->values_->size();
  }


  size_type max_size() const noexcept
  {
    return this->values_->max_size();
  }


  bool empty() const noexcept
  {
    return this->values_->empty();
  }


  const_iterator begin() const
  {
    basic_resolver_results tmp(*this);
    tmp.index_ = 0;
    return tmp;
  }


  const_iterator end() const
  {
    return const_iterator();
  }


  const_iterator cbegin() const
  {
    return begin();
  }


  const_iterator cend() const
  {
    return end();
  }


  void swap(basic_resolver_results& that) noexcept
  {
    if (this != &that)
    {
      this->values_.swap(that.values_);
      std::size_t index = this->index_;
      this->index_ = that.index_;
      that.index_ = index;
    }
  }


  friend bool operator==(const basic_resolver_results& a,
      const basic_resolver_results& b)
  {
    return a.equal(b);
  }


  friend bool operator!=(const basic_resolver_results& a,
      const basic_resolver_results& b)
  {
    return !a.equal(b);
  }

private:
  typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 312 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver_results.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_endpoint_op.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_endpoint_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_op.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class resolve_op : public operation
{
public:

  boost::system::error_code ec_;

protected:
  resolve_op(func_type complete_func)
    : operation(complete_func)
  {
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_op.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Protocol, typename Handler>
class resolve_endpoint_op : public resolve_op
{
public:
  struct ptr { Handler* h; resolve_endpoint_op* v; resolve_endpoint_op* p; ~ptr() { reset(); } static resolve_endpoint_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_endpoint_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~resolve_endpoint_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_endpoint_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<resolve_endpoint_op*>(v), 1); v = 0; } } };

  typedef typename Protocol::endpoint endpoint_type;
  typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;

  resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
      const endpoint_type& endpoint, io_context_impl& ioc, Handler& handler)
    : resolve_op(&resolve_endpoint_op::do_complete),
      cancel_token_(cancel_token),
      endpoint_(endpoint),
      io_context_impl_(ioc),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    if (owner && owner != &o->io_context_impl_)
    {




      char host_name[1025];
      char service_name[32];
      socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
          o->endpoint_.size(), host_name, 1025, service_name, 32,
          o->endpoint_.protocol().type(), o->ec_);
      o->results_ = results_type::create(o->endpoint_, host_name, service_name);


      o->io_context_impl_.post_deferred_completion(o);
      p.v = p.p = 0;
    }
    else
    {



      (void)0;







      detail::binder2<Handler, boost::system::error_code, results_type>
        handler(o->handler_, o->ec_, o->results_);
      p.h = boost::asio::detail::addressof(handler.handler_);
      p.reset();

      if (owner)
      {
        fenced_block b(fenced_block::half);
        (void)0;
        w.complete(handler, handler.handler_);
        (void)0;
      }
    }
  }

private:
  socket_ops::weak_cancel_token_type cancel_token_;
  endpoint_type endpoint_;
  io_context_impl& io_context_impl_;
  Handler handler_;
  results_type results_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_query_op.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_query_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_query_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Protocol, typename Handler>
class resolve_query_op : public resolve_op
{
public:
  struct ptr { Handler* h; resolve_query_op* v; resolve_query_op* p; ~ptr() { reset(); } static resolve_query_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_query_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~resolve_query_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_query_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<resolve_query_op*>(v), 1); v = 0; } } };

  typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
  typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;

  resolve_query_op(socket_ops::weak_cancel_token_type cancel_token,
      const query_type& query, io_context_impl& ioc, Handler& handler)
    : resolve_op(&resolve_query_op::do_complete),
      cancel_token_(cancel_token),
      query_(query),
      io_context_impl_(ioc),
      handler_(static_cast<Handler&&>(handler)),
      addrinfo_(0)
  {
    handler_work<Handler>::start(handler_);
  }

  ~resolve_query_op()
  {
    if (addrinfo_)
      socket_ops::freeaddrinfo(addrinfo_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    resolve_query_op* o(static_cast<resolve_query_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };

    if (owner && owner != &o->io_context_impl_)
    {




      socket_ops::background_getaddrinfo(o->cancel_token_,
          o->query_.host_name().c_str(), o->query_.service_name().c_str(),
          o->query_.hints(), &o->addrinfo_, o->ec_);


      o->io_context_impl_.post_deferred_completion(o);
      p.v = p.p = 0;
    }
    else
    {




      handler_work<Handler> w(o->handler_);

      (void)0;







      detail::binder2<Handler, boost::system::error_code, results_type>
        handler(o->handler_, o->ec_, results_type());
      p.h = boost::asio::detail::addressof(handler.handler_);
      if (o->addrinfo_)
      {
        handler.arg2_ = results_type::create(o->addrinfo_,
            o->query_.host_name(), o->query_.service_name());
      }
      p.reset();

      if (owner)
      {
        fenced_block b(fenced_block::half);
        (void)0;
        w.complete(handler, handler.handler_);
        (void)0;
      }
    }
  }

private:
  socket_ops::weak_cancel_token_type cancel_token_;
  query_type query_;
  io_context_impl& io_context_impl_;
  Handler handler_;
  boost::asio::detail::addrinfo_type* addrinfo_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolve_query_op.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service_base.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class resolver_service_base
{
public:


  typedef socket_ops::shared_cancel_token_type implementation_type;


  inline resolver_service_base(boost::asio::io_context& io_context);


  inline ~resolver_service_base();


  inline void base_shutdown();


  inline void base_notify_fork(
      boost::asio::io_context::fork_event fork_ev);


  inline void construct(implementation_type& impl);


  inline void destroy(implementation_type&);


  inline void move_construct(implementation_type& impl,
      implementation_type& other_impl);


  inline void move_assign(implementation_type& impl,
      resolver_service_base& other_service,
      implementation_type& other_impl);


  inline void cancel(implementation_type& impl);

protected:

  inline void start_resolve_op(resolve_op* op);



  class auto_addrinfo
    : private boost::asio::detail::noncopyable
  {
  public:
    explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
      : ai_(ai)
    {
    }

    ~auto_addrinfo()
    {
      if (ai_)
        socket_ops::freeaddrinfo(ai_);
    }

    operator boost::asio::detail::addrinfo_type*()
    {
      return ai_;
    }

  private:
    boost::asio::detail::addrinfo_type* ai_;
  };



  class work_io_context_runner;


  inline void start_work_thread();


  io_context_impl& io_context_impl_;

private:

  boost::asio::detail::mutex mutex_;


  boost::asio::detail::scoped_ptr<boost::asio::io_context> work_io_context_;


  io_context_impl& work_io_context_impl_;


  boost::asio::executor_work_guard<
      boost::asio::io_context::executor_type> work_;


  boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/resolver_service_base.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/resolver_service_base.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service_base.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class resolver_service_base::work_io_context_runner
{
public:
  work_io_context_runner(boost::asio::io_context& io_context)
    : io_context_(io_context) {}
  void operator()() { io_context_.run(); }
private:
  boost::asio::io_context& io_context_;
};

resolver_service_base::resolver_service_base(
    boost::asio::io_context& io_context)
  : io_context_impl_(boost::asio::use_service<io_context_impl>(io_context)),
    work_io_context_(new boost::asio::io_context(-1)),
    work_io_context_impl_(boost::asio::use_service<
        io_context_impl>(*work_io_context_)),
    work_(boost::asio::make_work_guard(*work_io_context_)),
    work_thread_(0)
{
}

resolver_service_base::~resolver_service_base()
{
  base_shutdown();
}

void resolver_service_base::base_shutdown()
{
  work_.reset();
  if (work_io_context_.get())
  {
    work_io_context_->stop();
    if (work_thread_.get())
    {
      work_thread_->join();
      work_thread_.reset();
    }
    work_io_context_.reset();
  }
}

void resolver_service_base::base_notify_fork(
    boost::asio::io_context::fork_event fork_ev)
{
  if (work_thread_.get())
  {
    if (fork_ev == boost::asio::io_context::fork_prepare)
    {
      work_io_context_->stop();
      work_thread_->join();
    }
    else
    {
      work_io_context_->restart();
      work_thread_.reset(new boost::asio::detail::thread(
            work_io_context_runner(*work_io_context_)));
    }
  }
}

void resolver_service_base::construct(
    resolver_service_base::implementation_type& impl)
{
  impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
}

void resolver_service_base::destroy(
    resolver_service_base::implementation_type& impl)
{
  (void)0
                                        ;

  impl.reset();
}

void resolver_service_base::move_construct(implementation_type& impl,
    implementation_type& other_impl)
{
  impl = static_cast<implementation_type&&>(other_impl);
}

void resolver_service_base::move_assign(implementation_type& impl,
    resolver_service_base&, implementation_type& other_impl)
{
  destroy(impl);
  impl = static_cast<implementation_type&&>(other_impl);
}

void resolver_service_base::cancel(
    resolver_service_base::implementation_type& impl)
{
  (void)0
                                        ;

  impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
}

void resolver_service_base::start_resolve_op(resolve_op* op)
{
  if ((((static_cast<unsigned>(io_context_impl_.concurrency_hint()) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
                                            )
  {
    start_work_thread();
    io_context_impl_.work_started();
    work_io_context_impl_.post_immediate_completion(op, false);
  }
  else
  {
    op->ec_ = boost::asio::error::operation_not_supported;
    io_context_impl_.post_immediate_completion(op, false);
  }
}

void resolver_service_base::start_work_thread()
{
  boost::asio::detail::mutex::scoped_lock lock(mutex_);
  if (!work_thread_.get())
  {
    work_thread_.reset(new boost::asio::detail::thread(
          work_io_context_runner(*work_io_context_)));
  }
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 155 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Protocol>
class resolver_service :
  public service_base<resolver_service<Protocol> >,
  public resolver_service_base
{
public:


  typedef socket_ops::shared_cancel_token_type implementation_type;


  typedef typename Protocol::endpoint endpoint_type;


  typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;


  typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;


  resolver_service(boost::asio::io_context& io_context)
    : service_base<resolver_service<Protocol> >(io_context),
      resolver_service_base(io_context)
  {
  }


  void shutdown()
  {
    this->base_shutdown();
  }


  void notify_fork(boost::asio::io_context::fork_event fork_ev)
  {
    this->base_notify_fork(fork_ev);
  }


  results_type resolve(implementation_type&, const query_type& query,
      boost::system::error_code& ec)
  {
    boost::asio::detail::addrinfo_type* address_info = 0;

    socket_ops::getaddrinfo(query.host_name().c_str(),
        query.service_name().c_str(), query.hints(), &address_info, ec);
    auto_addrinfo auto_address_info(address_info);

    return ec ? results_type() : results_type::create(
        address_info, query.host_name(), query.service_name());
  }


  template <typename Handler>
  void async_resolve(implementation_type& impl,
      const query_type& query, Handler& handler)
  {

    typedef resolve_query_op<Protocol, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl, query, io_context_impl_, handler);

    (void)0
                                                       ;

    start_resolve_op(p.p);
    p.v = p.p = 0;
  }


  results_type resolve(implementation_type&,
      const endpoint_type& endpoint, boost::system::error_code& ec)
  {
    char host_name[1025];
    char service_name[32];
    socket_ops::sync_getnameinfo(endpoint.data(), endpoint.size(),
        host_name, 1025, service_name, 32,
        endpoint.protocol().type(), ec);

    return ec ? results_type() : results_type::create(
        endpoint, host_name, service_name);
  }


  template <typename Handler>
  void async_resolve(implementation_type& impl,
      const endpoint_type& endpoint, Handler& handler)
  {

    typedef resolve_endpoint_op<Protocol, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl, endpoint, io_context_impl_, handler);

    (void)0
                                                       ;

    start_resolve_op(p.p);
    p.v = p.p = 0;
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 144 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/resolver_service.hpp" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
template <typename InternetProtocol
    >
class basic_resolver
  : protected basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >,
    public resolver_base
{
public:

  typedef io_context::executor_type executor_type;


  typedef InternetProtocol protocol_type;


  typedef typename InternetProtocol::endpoint endpoint_type;



  typedef basic_resolver_query<InternetProtocol> query;


  typedef basic_resolver_iterator<InternetProtocol> iterator;



  typedef basic_resolver_results<InternetProtocol> results_type;
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  explicit basic_resolver(boost::asio::io_context& io_context)
    : basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >(io_context)
  {
  }
# 116 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  basic_resolver(basic_resolver&& other)
    : basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >(std::move(other))
  {
  }
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  basic_resolver& operator=(basic_resolver&& other)
  {
    basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::operator=(std::move(other));
    return *this;
  }
# 146 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  ~basic_resolver()
  {
  }
# 163 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::get_io_context();
  }
# 177 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::get_executor();
  }
# 196 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  void cancel()
  {
    return this->get_service().cancel(this->get_implementation());
  }
# 214 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const query& q)
  {
    boost::system::error_code ec;
    results_type r = this->get_service().resolve(
        this->get_implementation(), q, ec);
    boost::asio::detail::throw_error(ec, "resolve");
    return r;
  }
# 235 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const query& q, boost::system::error_code& ec)
  {
    return this->get_service().resolve(this->get_implementation(), q, ec);
  }
# 274 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(boost::asio::string_view host,
      boost::asio::string_view service)
  {
    return resolve(host, service, resolver_base::flags());
  }
# 313 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(boost::asio::string_view host,
      boost::asio::string_view service, boost::system::error_code& ec)
  {
    return resolve(host, service, resolver_base::flags(), ec);
  }
# 356 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(boost::asio::string_view host,
      boost::asio::string_view service, resolver_base::flags resolve_flags)
  {
    boost::system::error_code ec;
    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
        static_cast<std::string>(service), resolve_flags);
    results_type r = this->get_service().resolve(
        this->get_implementation(), q, ec);
    boost::asio::detail::throw_error(ec, "resolve");
    return r;
  }
# 405 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(boost::asio::string_view host,
      boost::asio::string_view service, resolver_base::flags resolve_flags,
      boost::system::error_code& ec)
  {
    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
        static_cast<std::string>(service), resolve_flags);
    return this->get_service().resolve(this->get_implementation(), q, ec);
  }
# 450 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const protocol_type& protocol,
      boost::asio::string_view host, boost::asio::string_view service)
  {
    return resolve(protocol, host, service, resolver_base::flags());
  }
# 492 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const protocol_type& protocol,
      boost::asio::string_view host, boost::asio::string_view service,
      boost::system::error_code& ec)
  {
    return resolve(protocol, host, service, resolver_base::flags(), ec);
  }
# 539 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const protocol_type& protocol,
      boost::asio::string_view host, boost::asio::string_view service,
      resolver_base::flags resolve_flags)
  {
    boost::system::error_code ec;
    basic_resolver_query<protocol_type> q(
        protocol, static_cast<std::string>(host),
        static_cast<std::string>(service), resolve_flags);
    results_type r = this->get_service().resolve(
        this->get_implementation(), q, ec);
    boost::asio::detail::throw_error(ec, "resolve");
    return r;
  }
# 593 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const protocol_type& protocol,
      boost::asio::string_view host, boost::asio::string_view service,
      resolver_base::flags resolve_flags, boost::system::error_code& ec)
  {
    basic_resolver_query<protocol_type> q(
        protocol, static_cast<std::string>(host),
        static_cast<std::string>(service), resolve_flags);
    return this->get_service().resolve(this->get_implementation(), q, ec);
  }
# 627 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  template <typename ResolveHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type

  async_resolve(const query& q,
      ResolveHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
                                               type_check;





    boost::asio::async_completion<ResolveHandler,
      void (boost::system::error_code, results_type)> init(handler);

    this->get_service().async_resolve(
        this->get_implementation(), q, init.completion_handler);

    return init.result.get();

  }
# 695 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  template <typename ResolveHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type

  async_resolve(boost::asio::string_view host,
      boost::asio::string_view service,
      ResolveHandler&& handler)
  {
    return async_resolve(host, service, resolver_base::flags(),
        static_cast<ResolveHandler&&>(handler));
  }
# 752 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  template <typename ResolveHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type

  async_resolve(boost::asio::string_view host,
      boost::asio::string_view service,
      resolver_base::flags resolve_flags,
      ResolveHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
                                               type_check;

    basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
        static_cast<std::string>(service), resolve_flags);





    boost::asio::async_completion<ResolveHandler,
      void (boost::system::error_code, results_type)> init(handler);

    this->get_service().async_resolve(
        this->get_implementation(), q, init.completion_handler);

    return init.result.get();

  }
# 827 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  template <typename ResolveHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type

  async_resolve(const protocol_type& protocol,
      boost::asio::string_view host, boost::asio::string_view service,
      ResolveHandler&& handler)
  {
    return async_resolve(protocol, host, service, resolver_base::flags(),
        static_cast<ResolveHandler&&>(handler));
  }
# 887 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  template <typename ResolveHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type

  async_resolve(const protocol_type& protocol,
      boost::asio::string_view host, boost::asio::string_view service,
      resolver_base::flags resolve_flags,
      ResolveHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
                                               type_check;

    basic_resolver_query<protocol_type> q(
        protocol, static_cast<std::string>(host),
        static_cast<std::string>(service), resolve_flags);





    boost::asio::async_completion<ResolveHandler,
      void (boost::system::error_code, results_type)> init(handler);

    this->get_service().async_resolve(
        this->get_implementation(), q, init.completion_handler);

    return init.result.get();

  }
# 932 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const endpoint_type& e)
  {
    boost::system::error_code ec;
    results_type i = this->get_service().resolve(
        this->get_implementation(), e, ec);
    boost::asio::detail::throw_error(ec, "resolve");
    return i;
  }
# 955 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  results_type resolve(const endpoint_type& e, boost::system::error_code& ec)
  {
    return this->get_service().resolve(this->get_implementation(), e, ec);
  }
# 984 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 3 4
  template <typename ResolveHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type

  async_resolve(const endpoint_type& e,
      ResolveHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
                                               type_check;





    boost::asio::async_completion<ResolveHandler,
      void (boost::system::error_code, results_type)> init(handler);

    this->get_service().async_resolve(
        this->get_implementation(), e, init.completion_handler);

    return init.result.get();

  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1015 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/host_name.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/host_name.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/host_name.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {


inline std::string host_name();


inline std::string host_name(boost::system::error_code& ec);

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/host_name.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/host_name.ipp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/host_name.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/host_name.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/host_name.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/host_name.ipp" 2 3 4

namespace boost {
namespace asio {
namespace ip {

std::string host_name()
{
  char name[1024];
  boost::system::error_code ec;
  if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
  {
    boost::asio::detail::throw_error(ec);
    return std::string();
  }
  return std::string(name);
}

std::string host_name(boost::system::error_code& ec)
{
  char name[1024];
  if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
    return std::string();
  return std::string(name);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/impl/host_name.ipp" 2 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/host_name.hpp" 2 3 4
# 85 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/icmp.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/icmp.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/icmp.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/icmp.hpp" 3 4
class icmp
{
public:

  typedef basic_endpoint<icmp> endpoint;


  static icmp v4()
  {
    return icmp(IPPROTO_ICMP,
        2);
  }


  static icmp v6()
  {
    return icmp(IPPROTO_ICMPV6,
        10);
  }


  int type() const
  {
    return SOCK_RAW;
  }


  int protocol() const
  {
    return protocol_;
  }


  int family() const
  {
    return family_;
  }


  typedef basic_raw_socket<icmp> socket;


  typedef basic_resolver<icmp> resolver;


  friend bool operator==(const icmp& p1, const icmp& p2)
  {
    return p1.protocol_ == p2.protocol_ && p1.family_ == p2.family_;
  }


  friend bool operator!=(const icmp& p1, const icmp& p2)
  {
    return p1.protocol_ != p2.protocol_ || p1.family_ != p2.family_;
  }

private:

  explicit icmp(int protocol_id, int protocol_family)
    : protocol_(protocol_id),
      family_(protocol_family)
  {
  }

  int protocol_;
  int family_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 116 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/icmp.hpp" 2 3 4
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/socket_option.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/socket_option.hpp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
namespace detail {
namespace socket_option {


template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_enable_loopback
{
public:







  typedef int ipv4_value_type;
  typedef int ipv6_value_type;



  multicast_enable_loopback()
    : ipv4_value_(0),
      ipv6_value_(0)
  {
  }


  explicit multicast_enable_loopback(bool v)
    : ipv4_value_(v ? 1 : 0),
      ipv6_value_(v ? 1 : 0)
  {
  }


  multicast_enable_loopback& operator=(bool v)
  {
    ipv4_value_ = v ? 1 : 0;
    ipv6_value_ = v ? 1 : 0;
    return *this;
  }


  bool value() const
  {
    return !!ipv4_value_;
  }


  operator bool() const
  {
    return !!ipv4_value_;
  }


  bool operator!() const
  {
    return !ipv4_value_;
  }


  template <typename Protocol>
  int level(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Level;
    return IPv4_Level;
  }


  template <typename Protocol>
  int name(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Name;
    return IPv4_Name;
  }


  template <typename Protocol>
  void* data(const Protocol& protocol)
  {
    if (protocol.family() == 10)
      return &ipv6_value_;
    return &ipv4_value_;
  }


  template <typename Protocol>
  const void* data(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return &ipv6_value_;
    return &ipv4_value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return sizeof(ipv6_value_);
    return sizeof(ipv4_value_);
  }


  template <typename Protocol>
  void resize(const Protocol& protocol, std::size_t s)
  {
    if (protocol.family() == 10)
    {
      if (s != sizeof(ipv6_value_))
      {
        std::length_error ex("multicast_enable_loopback socket option resize");
        boost::asio::detail::throw_exception(ex);
      }
      ipv4_value_ = ipv6_value_ ? 1 : 0;
    }
    else
    {
      if (s != sizeof(ipv4_value_))
      {
        std::length_error ex("multicast_enable_loopback socket option resize");
        boost::asio::detail::throw_exception(ex);
      }
      ipv6_value_ = ipv4_value_ ? 1 : 0;
    }
  }

private:
  ipv4_value_type ipv4_value_;
  ipv6_value_type ipv6_value_;
};


template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class unicast_hops
{
public:

  unicast_hops()
    : value_(0)
  {
  }


  explicit unicast_hops(int v)
    : value_(v)
  {
  }


  unicast_hops& operator=(int v)
  {
    value_ = v;
    return *this;
  }


  int value() const
  {
    return value_;
  }


  template <typename Protocol>
  int level(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Level;
    return IPv4_Level;
  }


  template <typename Protocol>
  int name(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Name;
    return IPv4_Name;
  }


  template <typename Protocol>
  int* data(const Protocol&)
  {
    return &value_;
  }


  template <typename Protocol>
  const int* data(const Protocol&) const
  {
    return &value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol&) const
  {
    return sizeof(value_);
  }


  template <typename Protocol>
  void resize(const Protocol&, std::size_t s)
  {
    if (s != sizeof(value_))
    {
      std::length_error ex("unicast hops socket option resize");
      boost::asio::detail::throw_exception(ex);
    }




  }

private:
  int value_;
};


template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_hops
{
public:



  typedef unsigned char ipv4_value_type;

  typedef int ipv6_value_type;


  multicast_hops()
    : ipv4_value_(0),
      ipv6_value_(0)
  {
  }


  explicit multicast_hops(int v)
  {
    if (v < 0 || v > 255)
    {
      std::out_of_range ex("multicast hops value out of range");
      boost::asio::detail::throw_exception(ex);
    }
    ipv4_value_ = (ipv4_value_type)v;
    ipv6_value_ = v;
  }


  multicast_hops& operator=(int v)
  {
    if (v < 0 || v > 255)
    {
      std::out_of_range ex("multicast hops value out of range");
      boost::asio::detail::throw_exception(ex);
    }
    ipv4_value_ = (ipv4_value_type)v;
    ipv6_value_ = v;
    return *this;
  }


  int value() const
  {
    return ipv6_value_;
  }


  template <typename Protocol>
  int level(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Level;
    return IPv4_Level;
  }


  template <typename Protocol>
  int name(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Name;
    return IPv4_Name;
  }


  template <typename Protocol>
  void* data(const Protocol& protocol)
  {
    if (protocol.family() == 10)
      return &ipv6_value_;
    return &ipv4_value_;
  }


  template <typename Protocol>
  const void* data(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return &ipv6_value_;
    return &ipv4_value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return sizeof(ipv6_value_);
    return sizeof(ipv4_value_);
  }


  template <typename Protocol>
  void resize(const Protocol& protocol, std::size_t s)
  {
    if (protocol.family() == 10)
    {
      if (s != sizeof(ipv6_value_))
      {
        std::length_error ex("multicast hops socket option resize");
        boost::asio::detail::throw_exception(ex);
      }
      if (ipv6_value_ < 0)
        ipv4_value_ = 0;
      else if (ipv6_value_ > 255)
        ipv4_value_ = 255;
      else
        ipv4_value_ = (ipv4_value_type)ipv6_value_;
    }
    else
    {
      if (s != sizeof(ipv4_value_))
      {
        std::length_error ex("multicast hops socket option resize");
        boost::asio::detail::throw_exception(ex);
      }
      ipv6_value_ = ipv4_value_;
    }
  }

private:
  ipv4_value_type ipv4_value_;
  ipv6_value_type ipv6_value_;
};


template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class multicast_request
{
public:

  multicast_request()
    : ipv4_value_(),
      ipv6_value_()
  {
  }


  explicit multicast_request(const address& multicast_address)
    : ipv4_value_(),
      ipv6_value_()
  {
    if (multicast_address.is_v6())
    {
      using namespace std;
      address_v6 ipv6_address = multicast_address.to_v6();
      address_v6::bytes_type bytes = ipv6_address.to_bytes();
      memcpy(ipv6_value_.ipv6mr_multiaddr.__in6_u.__u6_addr8, bytes.data(), 16);
      ipv6_value_.ipv6mr_interface = ipv6_address.scope_id();
    }
    else
    {
      ipv4_value_.imr_multiaddr.s_addr =
        boost::asio::detail::socket_ops::host_to_network_long(
            multicast_address.to_v4().to_uint());
      ipv4_value_.imr_interface.s_addr =
        boost::asio::detail::socket_ops::host_to_network_long(
            address_v4::any().to_uint());
    }
  }


  explicit multicast_request(const address_v4& multicast_address,
      const address_v4& network_interface = address_v4::any())
    : ipv6_value_()
  {
    ipv4_value_.imr_multiaddr.s_addr =
      boost::asio::detail::socket_ops::host_to_network_long(
          multicast_address.to_uint());
    ipv4_value_.imr_interface.s_addr =
      boost::asio::detail::socket_ops::host_to_network_long(
          network_interface.to_uint());
  }


  explicit multicast_request(
      const address_v6& multicast_address,
      unsigned long network_interface = 0)
    : ipv4_value_()
  {
    using namespace std;
    address_v6::bytes_type bytes = multicast_address.to_bytes();
    memcpy(ipv6_value_.ipv6mr_multiaddr.__in6_u.__u6_addr8, bytes.data(), 16);
    if (network_interface)
      ipv6_value_.ipv6mr_interface = network_interface;
    else
      ipv6_value_.ipv6mr_interface = multicast_address.scope_id();
  }


  template <typename Protocol>
  int level(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Level;
    return IPv4_Level;
  }


  template <typename Protocol>
  int name(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Name;
    return IPv4_Name;
  }


  template <typename Protocol>
  const void* data(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return &ipv6_value_;
    return &ipv4_value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return sizeof(ipv6_value_);
    return sizeof(ipv4_value_);
  }

private:
  boost::asio::detail::in4_mreq_type ipv4_value_;
  boost::asio::detail::in6_mreq_type ipv6_value_;
};


template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
class network_interface
{
public:

  network_interface()
  {
    ipv4_value_.s_addr =
      boost::asio::detail::socket_ops::host_to_network_long(
          address_v4::any().to_uint());
    ipv6_value_ = 0;
  }


  explicit network_interface(const address_v4& ipv4_interface)
  {
    ipv4_value_.s_addr =
      boost::asio::detail::socket_ops::host_to_network_long(
          ipv4_interface.to_uint());
    ipv6_value_ = 0;
  }


  explicit network_interface(unsigned int ipv6_interface)
  {
    ipv4_value_.s_addr =
      boost::asio::detail::socket_ops::host_to_network_long(
          address_v4::any().to_uint());
    ipv6_value_ = ipv6_interface;
  }


  template <typename Protocol>
  int level(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Level;
    return IPv4_Level;
  }


  template <typename Protocol>
  int name(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return IPv6_Name;
    return IPv4_Name;
  }


  template <typename Protocol>
  const void* data(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return &ipv6_value_;
    return &ipv4_value_;
  }


  template <typename Protocol>
  std::size_t size(const Protocol& protocol) const
  {
    if (protocol.family() == 10)
      return sizeof(ipv6_value_);
    return sizeof(ipv4_value_);
  }

private:
  boost::asio::detail::in4_addr_type ipv4_value_;
  unsigned int ipv6_value_;
};

}
}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 567 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
namespace multicast {
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 3 4
typedef boost::asio::ip::detail::socket_option::multicast_request<
  IPPROTO_IP,
  35,
  IPPROTO_IPV6,
  20> join_group;
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 3 4
typedef boost::asio::ip::detail::socket_option::multicast_request<
  IPPROTO_IP,
  36,
  IPPROTO_IPV6,
  21> leave_group;
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 3 4
typedef boost::asio::ip::detail::socket_option::network_interface<
  IPPROTO_IP,
  32,
  IPPROTO_IPV6,
  17> outbound_interface;
# 142 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 3 4
typedef boost::asio::ip::detail::socket_option::multicast_hops<
  IPPROTO_IP,
  33,
  IPPROTO_IPV6,
  18> hops;
# 179 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 3 4
typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
  IPPROTO_IP,
  34,
  IPPROTO_IPV6,
  19> enable_loopback;


}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 192 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/multicast.hpp" 2 3 4
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/resolver_service.hpp" 1 3 4
# 90 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/tcp.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/tcp.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/tcp.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/tcp.hpp" 3 4
class tcp
{
public:

  typedef basic_endpoint<tcp> endpoint;


  static tcp v4()
  {
    return tcp(2);
  }


  static tcp v6()
  {
    return tcp(10);
  }


  int type() const
  {
    return SOCK_STREAM;
  }


  int protocol() const
  {
    return IPPROTO_TCP;
  }


  int family() const
  {
    return family_;
  }


  typedef basic_stream_socket<tcp> socket;


  typedef basic_socket_acceptor<tcp> acceptor;


  typedef basic_resolver<tcp> resolver;



  typedef basic_socket_iostream<tcp> iostream;
# 125 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/tcp.hpp" 3 4
  typedef boost::asio::detail::socket_option::boolean<
    IPPROTO_TCP, 1> no_delay;



  friend bool operator==(const tcp& p1, const tcp& p2)
  {
    return p1.family_ == p2.family_;
  }


  friend bool operator!=(const tcp& p1, const tcp& p2)
  {
    return p1.family_ != p2.family_;
  }

private:

  explicit tcp(int protocol_family)
    : family_(protocol_family)
  {
  }

  int family_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/tcp.hpp" 2 3 4
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/udp.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/udp.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/udp.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/udp.hpp" 3 4
class udp
{
public:

  typedef basic_endpoint<udp> endpoint;


  static udp v4()
  {
    return udp(2);
  }


  static udp v6()
  {
    return udp(10);
  }


  int type() const
  {
    return SOCK_DGRAM;
  }


  int protocol() const
  {
    return IPPROTO_UDP;
  }


  int family() const
  {
    return family_;
  }


  typedef basic_datagram_socket<udp> socket;


  typedef basic_resolver<udp> resolver;


  friend bool operator==(const udp& p1, const udp& p2)
  {
    return p1.family_ == p2.family_;
  }


  friend bool operator!=(const udp& p1, const udp& p2)
  {
    return p1.family_ != p2.family_;
  }

private:

  explicit udp(int protocol_family)
    : family_(protocol_family)
  {
  }

  int family_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/udp.hpp" 2 3 4
# 92 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/unicast.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/unicast.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/unicast.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
namespace unicast {
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/unicast.hpp" 3 4
typedef boost::asio::ip::detail::socket_option::unicast_hops<
  IPPROTO_IP,
  2,
  IPPROTO_IPV6,
  16> hops;


}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/unicast.hpp" 2 3 4
# 93 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/v6_only.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/v6_only.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/v6_only.hpp" 2 3 4

namespace boost {
namespace asio {
namespace ip {
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/v6_only.hpp" 3 4
typedef boost::asio::detail::socket_option::boolean<
    IPPROTO_IPV6, 26> v6_only;






}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/ip/v6_only.hpp" 2 3 4
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_read_buffered.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_read_buffered.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_read_buffered.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail {

template <typename Stream>
char is_read_buffered_helper(buffered_stream<Stream>* s);

template <typename Stream>
char is_read_buffered_helper(buffered_read_stream<Stream>* s);

struct is_read_buffered_big_type { char data[10]; };
is_read_buffered_big_type is_read_buffered_helper(...);

}



template <typename Stream>
class is_read_buffered
{
public:





  static const bool value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1
                                                                       ;

};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_read_buffered.hpp" 2 3 4
# 96 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_write_buffered.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_write_buffered.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_write_buffered.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail {

template <typename Stream>
char is_write_buffered_helper(buffered_stream<Stream>* s);

template <typename Stream>
char is_write_buffered_helper(buffered_write_stream<Stream>* s);

struct is_write_buffered_big_type { char data[10]; };
is_write_buffered_big_type is_write_buffered_helper(...);

}



template <typename Stream>
class is_write_buffered
{
public:





  static const bool value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1
                                                                        ;

};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/is_write_buffered.hpp" 2 3 4
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/basic_endpoint.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/basic_endpoint.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/endpoint.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/endpoint.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/endpoint.hpp" 2 3 4

namespace boost {
namespace asio {
namespace local {
namespace detail {


class endpoint
{
public:

  inline endpoint();


  inline endpoint(const char* path_name);


  inline endpoint(const std::string& path_name);


  endpoint(const endpoint& other)
    : data_(other.data_),
      path_length_(other.path_length_)
  {
  }


  endpoint& operator=(const endpoint& other)
  {
    data_ = other.data_;
    path_length_ = other.path_length_;
    return *this;
  }


  boost::asio::detail::socket_addr_type* data()
  {
    return &data_.base;
  }


  const boost::asio::detail::socket_addr_type* data() const
  {
    return &data_.base;
  }


  std::size_t size() const
  {
    return path_length_
      + __builtin_offsetof (boost::asio::detail::sockaddr_un_type, sun_path);
  }


  inline void resize(std::size_t size);


  std::size_t capacity() const
  {
    return sizeof(boost::asio::detail::sockaddr_un_type);
  }


  inline std::string path() const;


  inline void path(const char* p);


  inline void path(const std::string& p);


  inline friend bool operator==(
      const endpoint& e1, const endpoint& e2);


  inline friend bool operator<(
      const endpoint& e1, const endpoint& e2);

private:

  union data_union
  {
    boost::asio::detail::socket_addr_type base;
    boost::asio::detail::sockaddr_un_type local;
  } data_;


  std::size_t path_length_;


  inline void init(const char* path, std::size_t path_length);
};

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/endpoint.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/impl/endpoint.ipp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/impl/endpoint.ipp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/endpoint.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4

namespace boost {
namespace asio {
namespace local {
namespace detail {

endpoint::endpoint()
{
  init("", 0);
}

endpoint::endpoint(const char* path_name)
{
  using namespace std;
  init(path_name, strlen(path_name));
}

endpoint::endpoint(const std::string& path_name)
{
  init(path_name.data(), path_name.length());
}

void endpoint::resize(std::size_t new_size)
{
  if (new_size > sizeof(boost::asio::detail::sockaddr_un_type))
  {
    boost::system::error_code ec(boost::asio::error::invalid_argument);
    boost::asio::detail::throw_error(ec);
  }
  else if (new_size == 0)
  {
    path_length_ = 0;
  }
  else
  {
    path_length_ = new_size
      - __builtin_offsetof (boost::asio::detail::sockaddr_un_type, sun_path);


    if (path_length_ > 0 && data_.local.sun_path[path_length_ - 1] == 0)
      --path_length_;
  }
}

std::string endpoint::path() const
{
  return std::string(data_.local.sun_path, path_length_);
}

void endpoint::path(const char* p)
{
  using namespace std;
  init(p, strlen(p));
}

void endpoint::path(const std::string& p)
{
  init(p.data(), p.length());
}

bool operator==(const endpoint& e1, const endpoint& e2)
{
  return e1.path() == e2.path();
}

bool operator<(const endpoint& e1, const endpoint& e2)
{
  return e1.path() < e2.path();
}

void endpoint::init(const char* path_name, std::size_t path_length)
{
  if (path_length > sizeof(data_.local.sun_path) - 1)
  {

    boost::system::error_code ec(boost::asio::error::name_too_long);
    boost::asio::detail::throw_error(ec);
  }

  using namespace std;
  data_.local = boost::asio::detail::sockaddr_un_type();
  data_.local.sun_family = 1;
  if (path_length > 0)
    memcpy(data_.local.sun_path, path_name, path_length);
  path_length_ = path_length;



  if (path_length > 0 && data_.local.sun_path[0] == 0)
    data_.local.sun_path[path_length] = 0;
}

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
# 131 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/basic_endpoint.hpp" 2 3 4





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/basic_endpoint.hpp" 2 3 4

namespace boost {
namespace asio {
namespace local {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/basic_endpoint.hpp" 3 4
template <typename Protocol>
class basic_endpoint
{
public:

  typedef Protocol protocol_type;






  typedef boost::asio::detail::socket_addr_type data_type;



  basic_endpoint()
  {
  }


  basic_endpoint(const char* path_name)
    : impl_(path_name)
  {
  }


  basic_endpoint(const std::string& path_name)
    : impl_(path_name)
  {
  }


  basic_endpoint(const basic_endpoint& other)
    : impl_(other.impl_)
  {
  }



  basic_endpoint(basic_endpoint&& other)
    : impl_(other.impl_)
  {
  }



  basic_endpoint& operator=(const basic_endpoint& other)
  {
    impl_ = other.impl_;
    return *this;
  }



  basic_endpoint& operator=(basic_endpoint&& other)
  {
    impl_ = other.impl_;
    return *this;
  }



  protocol_type protocol() const
  {
    return protocol_type();
  }


  data_type* data()
  {
    return impl_.data();
  }


  const data_type* data() const
  {
    return impl_.data();
  }


  std::size_t size() const
  {
    return impl_.size();
  }


  void resize(std::size_t new_size)
  {
    impl_.resize(new_size);
  }


  std::size_t capacity() const
  {
    return impl_.capacity();
  }


  std::string path() const
  {
    return impl_.path();
  }


  void path(const char* p)
  {
    impl_.path(p);
  }


  void path(const std::string& p)
  {
    impl_.path(p);
  }


  friend bool operator==(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return e1.impl_ == e2.impl_;
  }


  friend bool operator!=(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return !(e1.impl_ == e2.impl_);
  }


  friend bool operator<(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return e1.impl_ < e2.impl_;
  }


  friend bool operator>(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return e2.impl_ < e1.impl_;
  }


  friend bool operator<=(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return !(e2 < e1);
  }


  friend bool operator>=(const basic_endpoint<Protocol>& e1,
      const basic_endpoint<Protocol>& e2)
  {
    return !(e1 < e2);
  }

private:

  boost::asio::local::detail::endpoint impl_;
};
# 223 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/basic_endpoint.hpp" 3 4
template <typename Elem, typename Traits, typename Protocol>
std::basic_ostream<Elem, Traits>& operator<<(
    std::basic_ostream<Elem, Traits>& os,
    const basic_endpoint<Protocol>& endpoint)
{
  os << endpoint.path();
  return os;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 237 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/basic_endpoint.hpp" 2 3 4
# 98 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/connect_pair.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/connect_pair.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/connect_pair.hpp" 2 3 4

namespace boost {
namespace asio {
namespace local {


template <typename Protocol >
void connect_pair(
    basic_socket<Protocol >& socket1,
    basic_socket<Protocol >& socket2);


template <typename Protocol >
boost::system::error_code connect_pair(
    basic_socket<Protocol >& socket1,
    basic_socket<Protocol >& socket2,
    boost::system::error_code& ec);

template <typename Protocol >
inline void connect_pair(
    basic_socket<Protocol >& socket1,
    basic_socket<Protocol >& socket2)
{
  boost::system::error_code ec;
  connect_pair(socket1, socket2, ec);
  boost::asio::detail::throw_error(ec, "connect_pair");
}

template <typename Protocol >
inline boost::system::error_code connect_pair(
    basic_socket<Protocol >& socket1,
    basic_socket<Protocol >& socket2,
    boost::system::error_code& ec)
{

  boost::asio::local::basic_endpoint<Protocol>* tmp
    = static_cast<typename Protocol::endpoint*>(0);
  (void)tmp;

  Protocol protocol;
  boost::asio::detail::socket_type sv[2];
  if (boost::asio::detail::socket_ops::socketpair(protocol.family(),
        protocol.type(), protocol.protocol(), sv, ec)
      == boost::asio::detail::socket_error_retval)
    return ec;

  socket1.assign(protocol, sv[0], ec);
  if (ec)
  {
    boost::system::error_code temp_ec;
    boost::asio::detail::socket_ops::state_type state[2] = { 0, 0 };
    boost::asio::detail::socket_ops::close(sv[0], state[0], true, temp_ec);
    boost::asio::detail::socket_ops::close(sv[1], state[1], true, temp_ec);
    return ec;
  }

  socket2.assign(protocol, sv[1], ec);
  if (ec)
  {
    boost::system::error_code temp_ec;
    socket1.close(temp_ec);
    boost::asio::detail::socket_ops::state_type state = 0;
    boost::asio::detail::socket_ops::close(sv[1], state, true, temp_ec);
    return ec;
  }

  return ec;
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/connect_pair.hpp" 2 3 4
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/datagram_protocol.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/datagram_protocol.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/datagram_protocol.hpp" 2 3 4

namespace boost {
namespace asio {
namespace local {
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/datagram_protocol.hpp" 3 4
class datagram_protocol
{
public:

  int type() const
  {
    return SOCK_DGRAM;
  }


  int protocol() const
  {
    return 0;
  }


  int family() const
  {
    return 1;
  }


  typedef basic_endpoint<datagram_protocol> endpoint;


  typedef basic_datagram_socket<datagram_protocol> socket;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/datagram_protocol.hpp" 2 3 4
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/stream_protocol.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/stream_protocol.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/stream_protocol.hpp" 2 3 4

namespace boost {
namespace asio {
namespace local {
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/stream_protocol.hpp" 3 4
class stream_protocol
{
public:

  int type() const
  {
    return SOCK_STREAM;
  }


  int protocol() const
  {
    return 0;
  }


  int family() const
  {
    return 1;
  }


  typedef basic_endpoint<stream_protocol> endpoint;


  typedef basic_stream_socket<stream_protocol> socket;


  typedef basic_socket_acceptor<stream_protocol> acceptor;



  typedef basic_socket_iostream<stream_protocol> iostream;

};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/local/stream_protocol.hpp" 2 3 4
# 101 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/packaged_task.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/packaged_task.hpp" 3 4
# 1 "/usr/include/c++/10/future" 1 3 4
# 32 "/usr/include/c++/10/future" 3 4
       
# 33 "/usr/include/c++/10/future" 3
# 43 "/usr/include/c++/10/future" 3
# 1 "/usr/include/c++/10/bits/atomic_futex.h" 1 3
# 33 "/usr/include/c++/10/bits/atomic_futex.h" 3
       
# 34 "/usr/include/c++/10/bits/atomic_futex.h" 3
# 47 "/usr/include/c++/10/bits/atomic_futex.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  struct __atomic_futex_unsigned_base
  {

    bool
    _M_futex_wait_until(unsigned *__addr, unsigned __val, bool __has_timeout,
 chrono::seconds __s, chrono::nanoseconds __ns);


    static void _M_futex_notify_all(unsigned* __addr);
  };

  template <unsigned _Waiter_bit = 0x80000000>
  class __atomic_futex_unsigned : __atomic_futex_unsigned_base
  {
    typedef chrono::system_clock __clock_t;


    atomic<unsigned> _M_data;

  public:
    explicit
    __atomic_futex_unsigned(unsigned __data) : _M_data(__data)
    { }

    inline __attribute__((__always_inline__)) unsigned
    _M_load(memory_order __mo)
    {
      return _M_data.load(__mo) & ~_Waiter_bit;
    }

  private:





    unsigned
    _M_load_and_test_until(unsigned __assumed, unsigned __operand,
 bool __equal, memory_order __mo, bool __has_timeout,
 chrono::seconds __s, chrono::nanoseconds __ns)
    {
      for (;;)
 {





   _M_data.fetch_or(_Waiter_bit, memory_order_relaxed);
   bool __ret = _M_futex_wait_until((unsigned*)(void*)&_M_data,
        __assumed | _Waiter_bit,
        __has_timeout, __s, __ns);

   __assumed = _M_load(__mo);
   if (!__ret || ((__operand == __assumed) == __equal))
     return __assumed;

 }
    }





    unsigned
    _M_load_and_test(unsigned __assumed, unsigned __operand,
 bool __equal, memory_order __mo)
    {
      return _M_load_and_test_until(__assumed, __operand, __equal, __mo,
        false, {}, {});
    }






    template<typename _Dur>
    unsigned
    _M_load_and_test_until_impl(unsigned __assumed, unsigned __operand,
 bool __equal, memory_order __mo,
 const chrono::time_point<__clock_t, _Dur>& __atime)
    {
      auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
      auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

      return _M_load_and_test_until(__assumed, __operand, __equal, __mo,
   true, __s.time_since_epoch(), __ns);
    }

  public:

    inline __attribute__((__always_inline__)) unsigned
    _M_load_when_not_equal(unsigned __val, memory_order __mo)
    {
      unsigned __i = _M_load(__mo);
      if ((__i & ~_Waiter_bit) != __val)
 return (__i & ~_Waiter_bit);

      return _M_load_and_test(__i, __val, false, __mo);
    }

    inline __attribute__((__always_inline__)) void
    _M_load_when_equal(unsigned __val, memory_order __mo)
    {
      unsigned __i = _M_load(__mo);
      if ((__i & ~_Waiter_bit) == __val)
 return;

      _M_load_and_test(__i, __val, true, __mo);
    }


    template<typename _Rep, typename _Period>
      inline __attribute__((__always_inline__)) bool
      _M_load_when_equal_for(unsigned __val, memory_order __mo,
   const chrono::duration<_Rep, _Period>& __rtime)
      {
 return _M_load_when_equal_until(__val, __mo,
     __clock_t::now() + __rtime);
      }


    template<typename _Clock, typename _Duration>
      inline __attribute__((__always_inline__)) bool
      _M_load_when_equal_until(unsigned __val, memory_order __mo,
   const chrono::time_point<_Clock, _Duration>& __atime)
      {

 const typename _Clock::time_point __c_entry = _Clock::now();
 const __clock_t::time_point __s_entry = __clock_t::now();
 const auto __delta = __atime - __c_entry;
 const auto __s_atime = __s_entry + __delta;
 return _M_load_when_equal_until(__val, __mo, __s_atime);
      }


    template<typename _Duration>
    inline __attribute__((__always_inline__)) bool
    _M_load_when_equal_until(unsigned __val, memory_order __mo,
 const chrono::time_point<__clock_t, _Duration>& __atime)
    {
      unsigned __i = _M_load(__mo);
      if ((__i & ~_Waiter_bit) == __val)
 return true;

      __i = _M_load_and_test_until_impl(__i, __val, true, __mo, __atime);
      return (__i & ~_Waiter_bit) == __val;
    }

    inline __attribute__((__always_inline__)) void
    _M_store_notify_all(unsigned __val, memory_order __mo)
    {
      unsigned* __futex = (unsigned *)(void *)&_M_data;
      if (_M_data.exchange(__val, __mo) & _Waiter_bit)
 _M_futex_notify_all(__futex);
    }
  };
# 287 "/usr/include/c++/10/bits/atomic_futex.h" 3

}
# 44 "/usr/include/c++/10/future" 2 3
# 53 "/usr/include/c++/10/future" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 66 "/usr/include/c++/10/future" 3
  enum class future_errc
  {
    future_already_retrieved = 1,
    promise_already_satisfied,
    no_state,
    broken_promise
  };


  template<>
    struct is_error_code_enum<future_errc> : public true_type { };


  const error_category&
  future_category() noexcept;


  inline error_code
  make_error_code(future_errc __errc) noexcept
  { return error_code(static_cast<int>(__errc), future_category()); }


  inline error_condition
  make_error_condition(future_errc __errc) noexcept
  { return error_condition(static_cast<int>(__errc), future_category()); }





  class future_error : public logic_error
  {
  public:
    explicit
    future_error(future_errc __errc)
    : future_error(std::make_error_code(__errc))
    { }

    virtual ~future_error() noexcept;

    virtual const char*
    what() const noexcept;

    const error_code&
    code() const noexcept { return _M_code; }

  private:
    explicit
    future_error(error_code __ec)
    : logic_error("std::future_error: " + __ec.message()), _M_code(__ec)
    { }

    friend void __throw_future_error(int);

    error_code _M_code;
  };


  template<typename _Res>
    class future;

  template<typename _Res>
    class shared_future;

  template<typename _Signature>
    class packaged_task;

  template<typename _Res>
    class promise;


  enum class launch
  {
    async = 1,
    deferred = 2
  };

  constexpr launch operator&(launch __x, launch __y)
  {
    return static_cast<launch>(
 static_cast<int>(__x) & static_cast<int>(__y));
  }

  constexpr launch operator|(launch __x, launch __y)
  {
    return static_cast<launch>(
 static_cast<int>(__x) | static_cast<int>(__y));
  }

  constexpr launch operator^(launch __x, launch __y)
  {
    return static_cast<launch>(
 static_cast<int>(__x) ^ static_cast<int>(__y));
  }

  constexpr launch operator~(launch __x)
  { return static_cast<launch>(~static_cast<int>(__x)); }

  inline launch& operator&=(launch& __x, launch __y)
  { return __x = __x & __y; }

  inline launch& operator|=(launch& __x, launch __y)
  { return __x = __x | __y; }

  inline launch& operator^=(launch& __x, launch __y)
  { return __x = __x ^ __y; }


  enum class future_status
  {
    ready,
    timeout,
    deferred
  };



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

  template<typename _Fn, typename... _Args>
    future<__async_result_of<_Fn, _Args...>>
    async(launch __policy, _Fn&& __fn, _Args&&... __args);

  template<typename _Fn, typename... _Args>
    future<__async_result_of<_Fn, _Args...>>
    async(_Fn&& __fn, _Args&&... __args);




  struct __future_base
  {

    struct _Result_base
    {
      exception_ptr _M_error;

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


      virtual void _M_destroy() = 0;

      struct _Deleter
      {
 void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
      };

    protected:
      _Result_base();
      virtual ~_Result_base();
    };


    template<typename _Res>
      using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>;


    template<typename _Res>
      struct _Result : _Result_base
      {
      private:
 __gnu_cxx::__aligned_buffer<_Res> _M_storage;
 bool _M_initialized;

      public:
 typedef _Res result_type;

 _Result() noexcept : _M_initialized() { }

 ~_Result()
 {
   if (_M_initialized)
     _M_value().~_Res();
 }


 _Res&
 _M_value() noexcept { return *_M_storage._M_ptr(); }

 void
 _M_set(const _Res& __res)
 {
   ::new (_M_storage._M_addr()) _Res(__res);
   _M_initialized = true;
 }

 void
 _M_set(_Res&& __res)
 {
   ::new (_M_storage._M_addr()) _Res(std::move(__res));
   _M_initialized = true;
 }

      private:
 void _M_destroy() { delete this; }
    };


    template<typename _Res, typename _Alloc>
      struct _Result_alloc final : _Result<_Res>, _Alloc
      {
 using __allocator_type = __alloc_rebind<_Alloc, _Result_alloc>;

        explicit
 _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
 { }

      private:
 void _M_destroy()
 {
   __allocator_type __a(*this);
   __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
   this->~_Result_alloc();
 }
      };


    template<typename _Res, typename _Allocator>
      static _Ptr<_Result_alloc<_Res, _Allocator>>
      _S_allocate_result(const _Allocator& __a)
      {
 using __result_type = _Result_alloc<_Res, _Allocator>;
 typename __result_type::__allocator_type __a2(__a);
 auto __guard = std::__allocate_guarded(__a2);
 __result_type* __p = ::new((void*)__guard.get()) __result_type{__a};
 __guard = nullptr;
 return _Ptr<__result_type>(__p);
      }


    template<typename _Res, typename _Tp>
      static _Ptr<_Result<_Res>>
      _S_allocate_result(const std::allocator<_Tp>& __a)
      {
 return _Ptr<_Result<_Res>>(new _Result<_Res>);
      }




    class _State_baseV2
    {
      typedef _Ptr<_Result_base> _Ptr_type;

      enum _Status : unsigned {
 __not_ready,
 __ready
      };

      _Ptr_type _M_result;
      __atomic_futex_unsigned<> _M_status;
      atomic_flag _M_retrieved = { 0 };
      once_flag _M_once;

    public:
      _State_baseV2() noexcept : _M_result(), _M_status(_Status::__not_ready)
 { }
      _State_baseV2(const _State_baseV2&) = delete;
      _State_baseV2& operator=(const _State_baseV2&) = delete;
      virtual ~_State_baseV2() = default;

      _Result_base&
      wait()
      {

 _M_complete_async();


 _M_status._M_load_when_equal(_Status::__ready, memory_order_acquire);
 return *_M_result;
      }

      template<typename _Rep, typename _Period>
        future_status
        wait_for(const chrono::duration<_Rep, _Period>& __rel)
        {


   if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
     return future_status::ready;
   if (_M_is_deferred_future())
     return future_status::deferred;
   if (_M_status._M_load_when_equal_for(_Status::__ready,
       memory_order_acquire, __rel))
     {
# 363 "/usr/include/c++/10/future" 3
       _M_complete_async();

       return future_status::ready;
     }
   return future_status::timeout;
 }

      template<typename _Clock, typename _Duration>
        future_status
        wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
        {


   if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
     return future_status::ready;
   if (_M_is_deferred_future())
     return future_status::deferred;
   if (_M_status._M_load_when_equal_until(_Status::__ready,
       memory_order_acquire, __abs))
     {



       _M_complete_async();

       return future_status::ready;
     }
   return future_status::timeout;
 }



      void
      _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
      {
 bool __did_set = false;


 call_once(_M_once, &_State_baseV2::_M_do_set, this,
    std::__addressof(__res), std::__addressof(__did_set));
 if (__did_set)

   _M_status._M_store_notify_all(_Status::__ready,
     memory_order_release);
 else if (!__ignore_failure)
          __throw_future_error(int(future_errc::promise_already_satisfied));
      }




      void
      _M_set_delayed_result(function<_Ptr_type()> __res,
       weak_ptr<_State_baseV2> __self)
      {
 bool __did_set = false;
 unique_ptr<_Make_ready> __mr{new _Make_ready};


 call_once(_M_once, &_State_baseV2::_M_do_set, this,
    std::__addressof(__res), std::__addressof(__did_set));
 if (!__did_set)
          __throw_future_error(int(future_errc::promise_already_satisfied));
 __mr->_M_shared_state = std::move(__self);
 __mr->_M_set();
 __mr.release();
      }


      void
      _M_break_promise(_Ptr_type __res)
      {
 if (static_cast<bool>(__res))
   {
     __res->_M_error =
       make_exception_ptr(future_error(future_errc::broken_promise));




     _M_result.swap(__res);

     _M_status._M_store_notify_all(_Status::__ready,
       memory_order_release);
   }
      }


      void
      _M_set_retrieved_flag()
      {
 if (_M_retrieved.test_and_set())
   __throw_future_error(int(future_errc::future_already_retrieved));
      }

      template<typename _Res, typename _Arg>
        struct _Setter;


      template<typename _Res, typename _Arg>
        struct _Setter<_Res, _Arg&>
        {


          static_assert(is_same<_Res, _Arg&>::value
              || is_same<const _Res, _Arg>::value,
              "Invalid specialisation");


          typename promise<_Res>::_Ptr_type operator()() const
          {
            _M_promise->_M_storage->_M_set(*_M_arg);
            return std::move(_M_promise->_M_storage);
          }
          promise<_Res>* _M_promise;
          _Arg* _M_arg;
        };


      template<typename _Res>
        struct _Setter<_Res, _Res&&>
        {

          typename promise<_Res>::_Ptr_type operator()() const
          {
            _M_promise->_M_storage->_M_set(std::move(*_M_arg));
            return std::move(_M_promise->_M_storage);
          }
          promise<_Res>* _M_promise;
          _Res* _M_arg;
        };


      template<typename _Res>
 struct _Setter<_Res, void>
 {
   static_assert(is_void<_Res>::value, "Only used for promise<void>");

   typename promise<_Res>::_Ptr_type operator()() const
   { return std::move(_M_promise->_M_storage); }

   promise<_Res>* _M_promise;
 };

      struct __exception_ptr_tag { };


      template<typename _Res>
        struct _Setter<_Res, __exception_ptr_tag>
        {

          typename promise<_Res>::_Ptr_type operator()() const
          {
            _M_promise->_M_storage->_M_error = *_M_ex;
            return std::move(_M_promise->_M_storage);
          }

          promise<_Res>* _M_promise;
          exception_ptr* _M_ex;
        };

      template<typename _Res, typename _Arg>
        static _Setter<_Res, _Arg&&>
        __setter(promise<_Res>* __prom, _Arg&& __arg)
        {
   _S_check(__prom->_M_future);
          return _Setter<_Res, _Arg&&>{ __prom, std::__addressof(__arg) };
        }

      template<typename _Res>
        static _Setter<_Res, __exception_ptr_tag>
        __setter(exception_ptr& __ex, promise<_Res>* __prom)
        {
   _S_check(__prom->_M_future);
          return _Setter<_Res, __exception_ptr_tag>{ __prom, &__ex };
        }

      template<typename _Res>
 static _Setter<_Res, void>
 __setter(promise<_Res>* __prom)
 {
   _S_check(__prom->_M_future);
   return _Setter<_Res, void>{ __prom };
 }

      template<typename _Tp>
        static void
        _S_check(const shared_ptr<_Tp>& __p)
        {
          if (!static_cast<bool>(__p))
            __throw_future_error((int)future_errc::no_state);
        }

    private:

      void
      _M_do_set(function<_Ptr_type()>* __f, bool* __did_set)
      {
        _Ptr_type __res = (*__f)();



 *__did_set = true;
        _M_result.swap(__res);
      }


      virtual void _M_complete_async() { }


      virtual bool _M_is_deferred_future() const { return false; }

      struct _Make_ready final : __at_thread_exit_elt
      {
 weak_ptr<_State_baseV2> _M_shared_state;
 static void _S_run(void*);
 void _M_set();
      };
    };





    using _State_base = _State_baseV2;
    class _Async_state_commonV2;


    template<typename _BoundFn,
      typename _Res = decltype(std::declval<_BoundFn&>()())>
      class _Deferred_state;

    template<typename _BoundFn,
      typename _Res = decltype(std::declval<_BoundFn&>()())>
      class _Async_state_impl;

    template<typename _Signature>
      class _Task_state_base;

    template<typename _Fn, typename _Alloc, typename _Signature>
      class _Task_state;

    template<typename _BoundFn>
      static std::shared_ptr<_State_base>
      _S_make_deferred_state(_BoundFn&& __fn);

    template<typename _BoundFn>
      static std::shared_ptr<_State_base>
      _S_make_async_state(_BoundFn&& __fn);

    template<typename _Res_ptr, typename _Fn,
      typename _Res = typename _Res_ptr::element_type::result_type>
      struct _Task_setter;

    template<typename _Res_ptr, typename _BoundFn>
      static _Task_setter<_Res_ptr, _BoundFn>
      _S_task_setter(_Res_ptr& __ptr, _BoundFn& __call)
      {
 return { std::__addressof(__ptr), std::__addressof(__call) };
      }
  };


  template<typename _Res>
    struct __future_base::_Result<_Res&> : __future_base::_Result_base
    {
      typedef _Res& result_type;

      _Result() noexcept : _M_value_ptr() { }

      void
      _M_set(_Res& __res) noexcept
      { _M_value_ptr = std::addressof(__res); }

      _Res& _M_get() noexcept { return *_M_value_ptr; }

    private:
      _Res* _M_value_ptr;

      void _M_destroy() { delete this; }
    };


  template<>
    struct __future_base::_Result<void> : __future_base::_Result_base
    {
      typedef void result_type;

    private:
      void _M_destroy() { delete this; }
    };




  template<typename _Res, typename _Arg>
    struct __is_location_invariant
    <__future_base::_State_base::_Setter<_Res, _Arg>>
    : true_type { };


  template<typename _Res_ptr, typename _Fn, typename _Res>
    struct __is_location_invariant
    <__future_base::_Task_setter<_Res_ptr, _Fn, _Res>>
    : true_type { };


  template<typename _Res>
    class __basic_future : public __future_base
    {
    protected:
      typedef shared_ptr<_State_base> __state_type;
      typedef __future_base::_Result<_Res>& __result_type;

    private:
      __state_type _M_state;

    public:

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

      bool
      valid() const noexcept { return static_cast<bool>(_M_state); }

      void
      wait() const
      {
        _State_base::_S_check(_M_state);
        _M_state->wait();
      }

      template<typename _Rep, typename _Period>
        future_status
        wait_for(const chrono::duration<_Rep, _Period>& __rel) const
        {
          _State_base::_S_check(_M_state);
          return _M_state->wait_for(__rel);
        }

      template<typename _Clock, typename _Duration>
        future_status
        wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
        {
          _State_base::_S_check(_M_state);
          return _M_state->wait_until(__abs);
        }

    protected:

      __result_type
      _M_get_result() const
      {
        _State_base::_S_check(_M_state);
        _Result_base& __res = _M_state->wait();
        if (!(__res._M_error == 0))
          rethrow_exception(__res._M_error);
        return static_cast<__result_type>(__res);
      }

      void _M_swap(__basic_future& __that) noexcept
      {
        _M_state.swap(__that._M_state);
      }


      explicit
      __basic_future(const __state_type& __state) : _M_state(__state)
      {
        _State_base::_S_check(_M_state);
        _M_state->_M_set_retrieved_flag();
      }


      explicit
      __basic_future(const shared_future<_Res>&) noexcept;


      explicit
      __basic_future(shared_future<_Res>&&) noexcept;


      explicit
      __basic_future(future<_Res>&&) noexcept;

      constexpr __basic_future() noexcept : _M_state() { }

      struct _Reset
      {
        explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { }
        ~_Reset() { _M_fut._M_state.reset(); }
        __basic_future& _M_fut;
      };
    };



  template<typename _Res>
    class future : public __basic_future<_Res>
    {
      friend class promise<_Res>;
      template<typename> friend class packaged_task;
      template<typename _Fn, typename... _Args>
        friend future<__async_result_of<_Fn, _Args...>>
        async(launch, _Fn&&, _Args&&...);

      typedef __basic_future<_Res> _Base_type;
      typedef typename _Base_type::__state_type __state_type;

      explicit
      future(const __state_type& __state) : _Base_type(__state) { }

    public:
      constexpr future() noexcept : _Base_type() { }


      future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }


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

      future& operator=(future&& __fut) noexcept
      {
        future(std::move(__fut))._M_swap(*this);
        return *this;
      }


      _Res
      get()
      {
        typename _Base_type::_Reset __reset(*this);
        return std::move(this->_M_get_result()._M_value());
      }

      shared_future<_Res> share() noexcept;
    };


  template<typename _Res>
    class future<_Res&> : public __basic_future<_Res&>
    {
      friend class promise<_Res&>;
      template<typename> friend class packaged_task;
      template<typename _Fn, typename... _Args>
        friend future<__async_result_of<_Fn, _Args...>>
        async(launch, _Fn&&, _Args&&...);

      typedef __basic_future<_Res&> _Base_type;
      typedef typename _Base_type::__state_type __state_type;

      explicit
      future(const __state_type& __state) : _Base_type(__state) { }

    public:
      constexpr future() noexcept : _Base_type() { }


      future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }


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

      future& operator=(future&& __fut) noexcept
      {
        future(std::move(__fut))._M_swap(*this);
        return *this;
      }


      _Res&
      get()
      {
        typename _Base_type::_Reset __reset(*this);
        return this->_M_get_result()._M_get();
      }

      shared_future<_Res&> share() noexcept;
    };


  template<>
    class future<void> : public __basic_future<void>
    {
      friend class promise<void>;
      template<typename> friend class packaged_task;
      template<typename _Fn, typename... _Args>
        friend future<__async_result_of<_Fn, _Args...>>
        async(launch, _Fn&&, _Args&&...);

      typedef __basic_future<void> _Base_type;
      typedef typename _Base_type::__state_type __state_type;

      explicit
      future(const __state_type& __state) : _Base_type(__state) { }

    public:
      constexpr future() noexcept : _Base_type() { }


      future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }


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

      future& operator=(future&& __fut) noexcept
      {
        future(std::move(__fut))._M_swap(*this);
        return *this;
      }


      void
      get()
      {
        typename _Base_type::_Reset __reset(*this);
        this->_M_get_result();
      }

      shared_future<void> share() noexcept;
    };



  template<typename _Res>
    class shared_future : public __basic_future<_Res>
    {
      typedef __basic_future<_Res> _Base_type;

    public:
      constexpr shared_future() noexcept : _Base_type() { }


      shared_future(const shared_future& __sf) noexcept : _Base_type(__sf) { }


      shared_future(future<_Res>&& __uf) noexcept
      : _Base_type(std::move(__uf))
      { }


      shared_future(shared_future&& __sf) noexcept
      : _Base_type(std::move(__sf))
      { }

      shared_future& operator=(const shared_future& __sf) noexcept
      {
        shared_future(__sf)._M_swap(*this);
        return *this;
      }

      shared_future& operator=(shared_future&& __sf) noexcept
      {
        shared_future(std::move(__sf))._M_swap(*this);
        return *this;
      }


      const _Res&
      get() const { return this->_M_get_result()._M_value(); }
    };


  template<typename _Res>
    class shared_future<_Res&> : public __basic_future<_Res&>
    {
      typedef __basic_future<_Res&> _Base_type;

    public:
      constexpr shared_future() noexcept : _Base_type() { }


      shared_future(const shared_future& __sf) : _Base_type(__sf) { }


      shared_future(future<_Res&>&& __uf) noexcept
      : _Base_type(std::move(__uf))
      { }


      shared_future(shared_future&& __sf) noexcept
      : _Base_type(std::move(__sf))
      { }

      shared_future& operator=(const shared_future& __sf)
      {
        shared_future(__sf)._M_swap(*this);
        return *this;
      }

      shared_future& operator=(shared_future&& __sf) noexcept
      {
        shared_future(std::move(__sf))._M_swap(*this);
        return *this;
      }


      _Res&
      get() const { return this->_M_get_result()._M_get(); }
    };


  template<>
    class shared_future<void> : public __basic_future<void>
    {
      typedef __basic_future<void> _Base_type;

    public:
      constexpr shared_future() noexcept : _Base_type() { }


      shared_future(const shared_future& __sf) : _Base_type(__sf) { }


      shared_future(future<void>&& __uf) noexcept
      : _Base_type(std::move(__uf))
      { }


      shared_future(shared_future&& __sf) noexcept
      : _Base_type(std::move(__sf))
      { }

      shared_future& operator=(const shared_future& __sf)
      {
        shared_future(__sf)._M_swap(*this);
        return *this;
      }

      shared_future& operator=(shared_future&& __sf) noexcept
      {
        shared_future(std::move(__sf))._M_swap(*this);
        return *this;
      }


      void
      get() const { this->_M_get_result(); }
    };


  template<typename _Res>
    inline __basic_future<_Res>::
    __basic_future(const shared_future<_Res>& __sf) noexcept
    : _M_state(__sf._M_state)
    { }

  template<typename _Res>
    inline __basic_future<_Res>::
    __basic_future(shared_future<_Res>&& __sf) noexcept
    : _M_state(std::move(__sf._M_state))
    { }

  template<typename _Res>
    inline __basic_future<_Res>::
    __basic_future(future<_Res>&& __uf) noexcept
    : _M_state(std::move(__uf._M_state))
    { }



  template<typename _Res>
    inline shared_future<_Res>
    future<_Res>::share() noexcept
    { return shared_future<_Res>(std::move(*this)); }

  template<typename _Res>
    inline shared_future<_Res&>
    future<_Res&>::share() noexcept
    { return shared_future<_Res&>(std::move(*this)); }

  inline shared_future<void>
  future<void>::share() noexcept
  { return shared_future<void>(std::move(*this)); }


  template<typename _Res>
    class promise
    {
      typedef __future_base::_State_base _State;
      typedef __future_base::_Result<_Res> _Res_type;
      typedef __future_base::_Ptr<_Res_type> _Ptr_type;
      template<typename, typename> friend class _State::_Setter;
      friend _State;

      shared_ptr<_State> _M_future;
      _Ptr_type _M_storage;

    public:
      promise()
      : _M_future(std::make_shared<_State>()),
 _M_storage(new _Res_type())
      { }

      promise(promise&& __rhs) noexcept
      : _M_future(std::move(__rhs._M_future)),
 _M_storage(std::move(__rhs._M_storage))
      { }

      template<typename _Allocator>
        promise(allocator_arg_t, const _Allocator& __a)
        : _M_future(std::allocate_shared<_State>(__a)),
   _M_storage(__future_base::_S_allocate_result<_Res>(__a))
        { }

      template<typename _Allocator>
        promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
        : _M_future(std::move(__rhs._M_future)),
   _M_storage(std::move(__rhs._M_storage))
        { }

      promise(const promise&) = delete;

      ~promise()
      {
        if (static_cast<bool>(_M_future) && !_M_future.unique())
          _M_future->_M_break_promise(std::move(_M_storage));
      }


      promise&
      operator=(promise&& __rhs) noexcept
      {
        promise(std::move(__rhs)).swap(*this);
        return *this;
      }

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

      void
      swap(promise& __rhs) noexcept
      {
        _M_future.swap(__rhs._M_future);
        _M_storage.swap(__rhs._M_storage);
      }


      future<_Res>
      get_future()
      { return future<_Res>(_M_future); }


      void
      set_value(const _Res& __r)
      { _M_future->_M_set_result(_State::__setter(this, __r)); }

      void
      set_value(_Res&& __r)
      { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); }

      void
      set_exception(exception_ptr __p)
      { _M_future->_M_set_result(_State::__setter(__p, this)); }

      void
      set_value_at_thread_exit(const _Res& __r)
      {
 _M_future->_M_set_delayed_result(_State::__setter(this, __r),
      _M_future);
      }

      void
      set_value_at_thread_exit(_Res&& __r)
      {
 _M_future->_M_set_delayed_result(
     _State::__setter(this, std::move(__r)), _M_future);
      }

      void
      set_exception_at_thread_exit(exception_ptr __p)
      {
 _M_future->_M_set_delayed_result(_State::__setter(__p, this),
      _M_future);
      }
    };

  template<typename _Res>
    inline void
    swap(promise<_Res>& __x, promise<_Res>& __y) noexcept
    { __x.swap(__y); }

  template<typename _Res, typename _Alloc>
    struct uses_allocator<promise<_Res>, _Alloc>
    : public true_type { };



  template<typename _Res>
    class promise<_Res&>
    {
      typedef __future_base::_State_base _State;
      typedef __future_base::_Result<_Res&> _Res_type;
      typedef __future_base::_Ptr<_Res_type> _Ptr_type;
      template<typename, typename> friend class _State::_Setter;
      friend _State;

      shared_ptr<_State> _M_future;
      _Ptr_type _M_storage;

    public:
      promise()
      : _M_future(std::make_shared<_State>()),
 _M_storage(new _Res_type())
      { }

      promise(promise&& __rhs) noexcept
      : _M_future(std::move(__rhs._M_future)),
 _M_storage(std::move(__rhs._M_storage))
      { }

      template<typename _Allocator>
        promise(allocator_arg_t, const _Allocator& __a)
        : _M_future(std::allocate_shared<_State>(__a)),
   _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
        { }

      template<typename _Allocator>
        promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
        : _M_future(std::move(__rhs._M_future)),
   _M_storage(std::move(__rhs._M_storage))
        { }

      promise(const promise&) = delete;

      ~promise()
      {
        if (static_cast<bool>(_M_future) && !_M_future.unique())
          _M_future->_M_break_promise(std::move(_M_storage));
      }


      promise&
      operator=(promise&& __rhs) noexcept
      {
        promise(std::move(__rhs)).swap(*this);
        return *this;
      }

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

      void
      swap(promise& __rhs) noexcept
      {
        _M_future.swap(__rhs._M_future);
        _M_storage.swap(__rhs._M_storage);
      }


      future<_Res&>
      get_future()
      { return future<_Res&>(_M_future); }


      void
      set_value(_Res& __r)
      { _M_future->_M_set_result(_State::__setter(this, __r)); }

      void
      set_exception(exception_ptr __p)
      { _M_future->_M_set_result(_State::__setter(__p, this)); }

      void
      set_value_at_thread_exit(_Res& __r)
      {
 _M_future->_M_set_delayed_result(_State::__setter(this, __r),
      _M_future);
      }

      void
      set_exception_at_thread_exit(exception_ptr __p)
      {
 _M_future->_M_set_delayed_result(_State::__setter(__p, this),
      _M_future);
      }
    };


  template<>
    class promise<void>
    {
      typedef __future_base::_State_base _State;
      typedef __future_base::_Result<void> _Res_type;
      typedef __future_base::_Ptr<_Res_type> _Ptr_type;
      template<typename, typename> friend class _State::_Setter;
      friend _State;

      shared_ptr<_State> _M_future;
      _Ptr_type _M_storage;

    public:
      promise()
      : _M_future(std::make_shared<_State>()),
 _M_storage(new _Res_type())
      { }

      promise(promise&& __rhs) noexcept
      : _M_future(std::move(__rhs._M_future)),
 _M_storage(std::move(__rhs._M_storage))
      { }

      template<typename _Allocator>
        promise(allocator_arg_t, const _Allocator& __a)
        : _M_future(std::allocate_shared<_State>(__a)),
   _M_storage(__future_base::_S_allocate_result<void>(__a))
        { }



      template<typename _Allocator>
        promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
        : _M_future(std::move(__rhs._M_future)),
   _M_storage(std::move(__rhs._M_storage))
        { }

      promise(const promise&) = delete;

      ~promise()
      {
        if (static_cast<bool>(_M_future) && !_M_future.unique())
          _M_future->_M_break_promise(std::move(_M_storage));
      }


      promise&
      operator=(promise&& __rhs) noexcept
      {
        promise(std::move(__rhs)).swap(*this);
        return *this;
      }

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

      void
      swap(promise& __rhs) noexcept
      {
        _M_future.swap(__rhs._M_future);
        _M_storage.swap(__rhs._M_storage);
      }


      future<void>
      get_future()
      { return future<void>(_M_future); }


      void
      set_value()
      { _M_future->_M_set_result(_State::__setter(this)); }

      void
      set_exception(exception_ptr __p)
      { _M_future->_M_set_result(_State::__setter(__p, this)); }

      void
      set_value_at_thread_exit()
      { _M_future->_M_set_delayed_result(_State::__setter(this), _M_future); }

      void
      set_exception_at_thread_exit(exception_ptr __p)
      {
 _M_future->_M_set_delayed_result(_State::__setter(__p, this),
      _M_future);
      }
    };

  template<typename _Ptr_type, typename _Fn, typename _Res>
    struct __future_base::_Task_setter
    {

      _Ptr_type operator()() const
      {
 try
   {
     (*_M_result)->_M_set((*_M_fn)());
   }
 catch(const __cxxabiv1::__forced_unwind&)
   {
     throw;
   }
 catch(...)
   {
     (*_M_result)->_M_error = current_exception();
   }
 return std::move(*_M_result);
      }
      _Ptr_type* _M_result;
      _Fn* _M_fn;
    };

  template<typename _Ptr_type, typename _Fn>
    struct __future_base::_Task_setter<_Ptr_type, _Fn, void>
    {
      _Ptr_type operator()() const
      {
 try
   {
     (*_M_fn)();
   }
 catch(const __cxxabiv1::__forced_unwind&)
   {
     throw;
   }
 catch(...)
   {
     (*_M_result)->_M_error = current_exception();
   }
 return std::move(*_M_result);
      }
      _Ptr_type* _M_result;
      _Fn* _M_fn;
    };


  template<typename _Res, typename... _Args>
    struct __future_base::_Task_state_base<_Res(_Args...)>
    : __future_base::_State_base
    {
      typedef _Res _Res_type;

      template<typename _Alloc>
 _Task_state_base(const _Alloc& __a)
 : _M_result(_S_allocate_result<_Res>(__a))
 { }


      virtual void
      _M_run(_Args&&... __args) = 0;


      virtual void
      _M_run_delayed(_Args&&... __args, weak_ptr<_State_base>) = 0;

      virtual shared_ptr<_Task_state_base>
      _M_reset() = 0;

      typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
      _Ptr_type _M_result;
    };


  template<typename _Fn, typename _Alloc, typename _Res, typename... _Args>
    struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final
    : __future_base::_Task_state_base<_Res(_Args...)>
    {
      template<typename _Fn2>
 _Task_state(_Fn2&& __fn, const _Alloc& __a)
 : _Task_state_base<_Res(_Args...)>(__a),
   _M_impl(std::forward<_Fn2>(__fn), __a)
 { }

    private:
      virtual void
      _M_run(_Args&&... __args)
      {
 auto __boundfn = [&] () -> _Res {
     return std::__invoke_r<_Res>(_M_impl._M_fn,
      std::forward<_Args>(__args)...);
 };
 this->_M_set_result(_S_task_setter(this->_M_result, __boundfn));
      }

      virtual void
      _M_run_delayed(_Args&&... __args, weak_ptr<_State_base> __self)
      {
 auto __boundfn = [&] () -> _Res {
     return std::__invoke_r<_Res>(_M_impl._M_fn,
      std::forward<_Args>(__args)...);
 };
 this->_M_set_delayed_result(_S_task_setter(this->_M_result, __boundfn),
        std::move(__self));
      }

      virtual shared_ptr<_Task_state_base<_Res(_Args...)>>
      _M_reset();

      struct _Impl : _Alloc
      {
 template<typename _Fn2>
   _Impl(_Fn2&& __fn, const _Alloc& __a)
   : _Alloc(__a), _M_fn(std::forward<_Fn2>(__fn)) { }
 _Fn _M_fn;
      } _M_impl;
    };

  template<typename _Signature, typename _Fn,
    typename _Alloc = std::allocator<int>>
    static shared_ptr<__future_base::_Task_state_base<_Signature>>
    __create_task_state(_Fn&& __fn, const _Alloc& __a = _Alloc())
    {
      typedef typename decay<_Fn>::type _Fn2;
      typedef __future_base::_Task_state<_Fn2, _Alloc, _Signature> _State;
      return std::allocate_shared<_State>(__a, std::forward<_Fn>(__fn), __a);
    }

  template<typename _Fn, typename _Alloc, typename _Res, typename... _Args>
    shared_ptr<__future_base::_Task_state_base<_Res(_Args...)>>
    __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)>::_M_reset()
    {
      return __create_task_state<_Res(_Args...)>(std::move(_M_impl._M_fn),
       static_cast<_Alloc&>(_M_impl));
    }


  template<typename _Res, typename... _ArgTypes>
    class packaged_task<_Res(_ArgTypes...)>
    {
      typedef __future_base::_Task_state_base<_Res(_ArgTypes...)> _State_type;
      shared_ptr<_State_type> _M_state;



      template<typename _Fn, typename _Fn2 = __remove_cvref_t<_Fn>>
 using __not_same
   = typename enable_if<!is_same<packaged_task, _Fn2>::value>::type;

    public:

      packaged_task() noexcept { }

      template<typename _Fn, typename = __not_same<_Fn>>
 explicit
 packaged_task(_Fn&& __fn)
 : _M_state(
     __create_task_state<_Res(_ArgTypes...)>(std::forward<_Fn>(__fn)))
 { }
# 1519 "/usr/include/c++/10/future" 3
      ~packaged_task()
      {
        if (static_cast<bool>(_M_state) && !_M_state.unique())
   _M_state->_M_break_promise(std::move(_M_state->_M_result));
      }


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


      packaged_task(packaged_task&& __other) noexcept
      { this->swap(__other); }

      packaged_task& operator=(packaged_task&& __other) noexcept
      {
 packaged_task(std::move(__other)).swap(*this);
 return *this;
      }

      void
      swap(packaged_task& __other) noexcept
      { _M_state.swap(__other._M_state); }

      bool
      valid() const noexcept
      { return static_cast<bool>(_M_state); }


      future<_Res>
      get_future()
      { return future<_Res>(_M_state); }


      void
      operator()(_ArgTypes... __args)
      {
 __future_base::_State_base::_S_check(_M_state);
 _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
      }

      void
      make_ready_at_thread_exit(_ArgTypes... __args)
      {
 __future_base::_State_base::_S_check(_M_state);
 _M_state->_M_run_delayed(std::forward<_ArgTypes>(__args)..., _M_state);
      }

      void
      reset()
      {
 __future_base::_State_base::_S_check(_M_state);
 packaged_task __tmp;
 __tmp._M_state = _M_state;
 _M_state = _M_state->_M_reset();
      }
    };


  template<typename _Res, typename... _ArgTypes>
    inline void
    swap(packaged_task<_Res(_ArgTypes...)>& __x,
  packaged_task<_Res(_ArgTypes...)>& __y) noexcept
    { __x.swap(__y); }
# 1594 "/usr/include/c++/10/future" 3
  template<typename _BoundFn, typename _Res>
    class __future_base::_Deferred_state final
    : public __future_base::_State_base
    {
    public:
      explicit
      _Deferred_state(_BoundFn&& __fn)
      : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
      { }

    private:
      typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
      _Ptr_type _M_result;
      _BoundFn _M_fn;


      virtual void
      _M_complete_async()
      {






        _M_set_result(_S_task_setter(_M_result, _M_fn), true);
      }



      virtual bool _M_is_deferred_future() const { return true; }
    };


  class __future_base::_Async_state_commonV2
    : public __future_base::_State_base
  {
  protected:
    ~_Async_state_commonV2() = default;
# 1649 "/usr/include/c++/10/future" 3
    virtual void _M_complete_async() { _M_join(); }

    void _M_join() { std::call_once(_M_once, &thread::join, &_M_thread); }

    thread _M_thread;
    once_flag _M_once;
  };



  template<typename _BoundFn, typename _Res>
    class __future_base::_Async_state_impl final
    : public __future_base::_Async_state_commonV2
    {
    public:
      explicit
      _Async_state_impl(_BoundFn&& __fn)
      : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
      {
 _M_thread = std::thread{ [this] {
     try
       {
  _M_set_result(_S_task_setter(_M_result, _M_fn));
       }
     catch(const __cxxabiv1::__forced_unwind&)
       {

  if (static_cast<bool>(_M_result))
    this->_M_break_promise(std::move(_M_result));
  throw;
       }
        } };
      }




      ~_Async_state_impl() { if (_M_thread.joinable()) _M_thread.join(); }

    private:
      typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
      _Ptr_type _M_result;
      _BoundFn _M_fn;
    };

  template<typename _BoundFn>
    inline std::shared_ptr<__future_base::_State_base>
    __future_base::_S_make_deferred_state(_BoundFn&& __fn)
    {
      typedef typename remove_reference<_BoundFn>::type __fn_type;
      typedef _Deferred_state<__fn_type> __state_type;
      return std::make_shared<__state_type>(std::move(__fn));
    }

  template<typename _BoundFn>
    inline std::shared_ptr<__future_base::_State_base>
    __future_base::_S_make_async_state(_BoundFn&& __fn)
    {
      typedef typename remove_reference<_BoundFn>::type __fn_type;
      typedef _Async_state_impl<__fn_type> __state_type;
      return std::make_shared<__state_type>(std::move(__fn));
    }



  template<typename _Fn, typename... _Args>
    [[__nodiscard__]] future<__async_result_of<_Fn, _Args...>>
    async(launch __policy, _Fn&& __fn, _Args&&... __args)
    {
      std::shared_ptr<__future_base::_State_base> __state;
      if ((__policy & launch::async) == launch::async)
 {
   try
     {
       __state = __future_base::_S_make_async_state(
    std::thread::__make_invoker(std::forward<_Fn>(__fn),
           std::forward<_Args>(__args)...)
    );
     }

   catch(const system_error& __e)
     {
       if (__e.code() != errc::resource_unavailable_try_again
    || (__policy & launch::deferred) != launch::deferred)
  throw;
     }

 }
      if (!__state)
 {
   __state = __future_base::_S_make_deferred_state(
       std::thread::__make_invoker(std::forward<_Fn>(__fn),
       std::forward<_Args>(__args)...));
 }
      return future<__async_result_of<_Fn, _Args...>>(__state);
    }


  template<typename _Fn, typename... _Args>
    [[__nodiscard__]] inline future<__async_result_of<_Fn, _Args...>>
    async(_Fn&& __fn, _Args&&... __args)
    {
      return std::async(launch::async|launch::deferred,
   std::forward<_Fn>(__fn),
   std::forward<_Args>(__args)...);
    }






}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/packaged_task.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/packaged_task.hpp" 2 3 4

namespace boost {
namespace asio {





template <typename Result, typename... Args, typename Signature>
class async_result<std::packaged_task<Result(Args...)>, Signature>
{
public:

  typedef std::packaged_task<Result(Args...)> completion_handler_type;



  typedef std::future<Result> return_type;


  explicit async_result(completion_handler_type& h)
    : future_(h.get_future())
  {
  }


  return_type get()
  {
    return std::move(future_);
  }

private:
  return_type future_;
};
# 120 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/packaged_task.hpp" 3 4
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/packaged_task.hpp" 2 3 4
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/placeholders.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/placeholders.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/placeholders.hpp" 2 3 4

namespace boost {
namespace asio {
namespace placeholders {
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/placeholders.hpp" 3 4
inline boost::arg<1> error()
{
  return boost::arg<1>();
}

inline boost::arg<2> bytes_transferred()
{
  return boost::arg<2>();
}

inline boost::arg<2> iterator()
{
  return boost::arg<2>();
}

inline boost::arg<2> results()
{
  return boost::arg<2>();
}

inline boost::arg<2> endpoint()
{
  return boost::arg<2>();
}

inline boost::arg<2> signal_number()
{
  return boost::arg<2>();
}
# 147 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/placeholders.hpp" 3 4
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/placeholders.hpp" 2 3 4
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/basic_descriptor.hpp" 1 3 4
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/basic_stream_descriptor.hpp" 1 3 4
# 105 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_ops.hpp" 1 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_ops.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {


enum
{

  user_set_non_blocking = 1,


  internal_non_blocking = 2,


  non_blocking = user_set_non_blocking | internal_non_blocking,


  possible_dup = 4
};

typedef unsigned char state_type;

template <typename ReturnType>
inline ReturnType error_wrapper(ReturnType return_value,
    boost::system::error_code& ec)
{
  ec = boost::system::error_code((*__errno_location ()),
      boost::asio::error::get_system_category());
  return return_value;
}

inline int open(const char* path, int flags,
    boost::system::error_code& ec);

inline int close(int d, state_type& state,
    boost::system::error_code& ec);

inline bool set_user_non_blocking(int d,
    state_type& state, bool value, boost::system::error_code& ec);

inline bool set_internal_non_blocking(int d,
    state_type& state, bool value, boost::system::error_code& ec);

typedef iovec buf;

inline std::size_t sync_read(int d, state_type state, buf* bufs,
    std::size_t count, bool all_empty, boost::system::error_code& ec);

inline bool non_blocking_read(int d, buf* bufs, std::size_t count,
    boost::system::error_code& ec, std::size_t& bytes_transferred);

inline std::size_t sync_write(int d, state_type state,
    const buf* bufs, std::size_t count, bool all_empty,
    boost::system::error_code& ec);

inline bool non_blocking_write(int d,
    const buf* bufs, std::size_t count,
    boost::system::error_code& ec, std::size_t& bytes_transferred);

inline int ioctl(int d, state_type& state, long cmd,
    ioctl_arg_type* arg, boost::system::error_code& ec);

inline int fcntl(int d, int cmd, boost::system::error_code& ec);

inline int fcntl(int d, int cmd,
    long arg, boost::system::error_code& ec);

inline int poll_read(int d,
    state_type state, boost::system::error_code& ec);

inline int poll_write(int d,
    state_type state, boost::system::error_code& ec);

inline int poll_error(int d,
    state_type state, boost::system::error_code& ec);

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
# 1 "/usr/include/c++/10/cerrno" 1 3 4
# 39 "/usr/include/c++/10/cerrno" 3 4
       
# 40 "/usr/include/c++/10/cerrno" 3
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_ops.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {
namespace descriptor_ops {

int open(const char* path, int flags, boost::system::error_code& ec)
{
  (*__errno_location ()) = 0;
  int result = error_wrapper(::open(path, flags), ec);
  if (result >= 0)
    ec = boost::system::error_code();
  return result;
}

int close(int d, state_type& state, boost::system::error_code& ec)
{
  int result = 0;
  if (d != -1)
  {
    (*__errno_location ()) = 0;
    result = error_wrapper(::close(d), ec);

    if (result != 0
        && (ec == boost::asio::error::would_block
          || ec == boost::asio::error::try_again))
    {
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
      ioctl_arg_type arg = 0;
      ::ioctl(d, 0x5421, &arg);

      state &= ~non_blocking;

      (*__errno_location ()) = 0;
      result = error_wrapper(::close(d), ec);
    }
  }

  if (result == 0)
    ec = boost::system::error_code();
  return result;
}

bool set_user_non_blocking(int d, state_type& state,
    bool value, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return false;
  }

  (*__errno_location ()) = 0;
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
  ioctl_arg_type arg = (value ? 1 : 0);
  int result = error_wrapper(::ioctl(d, 0x5421, &arg), ec);


  if (result >= 0)
  {
    ec = boost::system::error_code();
    if (value)
      state |= user_set_non_blocking;
    else
    {



      state &= ~(user_set_non_blocking | internal_non_blocking);
    }
    return true;
  }

  return false;
}

bool set_internal_non_blocking(int d, state_type& state,
    bool value, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return false;
  }

  if (!value && (state & user_set_non_blocking))
  {



    ec = boost::asio::error::invalid_argument;
    return false;
  }

  (*__errno_location ()) = 0;
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
  ioctl_arg_type arg = (value ? 1 : 0);
  int result = error_wrapper(::ioctl(d, 0x5421, &arg), ec);


  if (result >= 0)
  {
    ec = boost::system::error_code();
    if (value)
      state |= internal_non_blocking;
    else
      state &= ~internal_non_blocking;
    return true;
  }

  return false;
}

std::size_t sync_read(int d, state_type state, buf* bufs,
    std::size_t count, bool all_empty, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }


  if (all_empty)
  {
    ec = boost::system::error_code();
    return 0;
  }


  for (;;)
  {

    (*__errno_location ()) = 0;
    signed_size_type bytes = error_wrapper(::readv(
          d, bufs, static_cast<int>(count)), ec);


    if (bytes > 0)
      return bytes;


    if (bytes == 0)
    {
      ec = boost::asio::error::eof;
      return 0;
    }


    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;


    if (descriptor_ops::poll_read(d, 0, ec) < 0)
      return 0;
  }
}

bool non_blocking_read(int d, buf* bufs, std::size_t count,
    boost::system::error_code& ec, std::size_t& bytes_transferred)
{
  for (;;)
  {

    (*__errno_location ()) = 0;
    signed_size_type bytes = error_wrapper(::readv(
          d, bufs, static_cast<int>(count)), ec);


    if (bytes == 0)
    {
      ec = boost::asio::error::eof;
      return true;
    }


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
      return false;


    if (bytes > 0)
    {
      ec = boost::system::error_code();
      bytes_transferred = bytes;
    }
    else
      bytes_transferred = 0;

    return true;
  }
}

std::size_t sync_write(int d, state_type state, const buf* bufs,
    std::size_t count, bool all_empty, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return 0;
  }


  if (all_empty)
  {
    ec = boost::system::error_code();
    return 0;
  }


  for (;;)
  {

    (*__errno_location ()) = 0;
    signed_size_type bytes = error_wrapper(::writev(
          d, bufs, static_cast<int>(count)), ec);


    if (bytes > 0)
      return bytes;


    if ((state & user_set_non_blocking)
        || (ec != boost::asio::error::would_block
          && ec != boost::asio::error::try_again))
      return 0;


    if (descriptor_ops::poll_write(d, 0, ec) < 0)
      return 0;
  }
}

bool non_blocking_write(int d, const buf* bufs, std::size_t count,
    boost::system::error_code& ec, std::size_t& bytes_transferred)
{
  for (;;)
  {

    (*__errno_location ()) = 0;
    signed_size_type bytes = error_wrapper(::writev(
          d, bufs, static_cast<int>(count)), ec);


    if (ec == boost::asio::error::interrupted)
      continue;


    if (ec == boost::asio::error::would_block
        || ec == boost::asio::error::try_again)
      return false;


    if (bytes >= 0)
    {
      ec = boost::system::error_code();
      bytes_transferred = bytes;
    }
    else
      bytes_transferred = 0;

    return true;
  }
}

int ioctl(int d, state_type& state, long cmd,
    ioctl_arg_type* arg, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return -1;
  }

  (*__errno_location ()) = 0;
  int result = error_wrapper(::ioctl(d, cmd, arg), ec);

  if (result >= 0)
  {
    ec = boost::system::error_code();







    if (cmd == static_cast<long>(0x5421))
    {
      if (*arg)
      {
        state |= user_set_non_blocking;
      }
      else
      {



        state &= ~(user_set_non_blocking | internal_non_blocking);
      }
    }
  }

  return result;
}

int fcntl(int d, int cmd, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return -1;
  }

  (*__errno_location ()) = 0;
  int result = error_wrapper(::fcntl(d, cmd), ec);
  if (result != -1)
    ec = boost::system::error_code();
  return result;
}

int fcntl(int d, int cmd, long arg, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return -1;
  }

  (*__errno_location ()) = 0;
  int result = error_wrapper(::fcntl(d, cmd, arg), ec);
  if (result != -1)
    ec = boost::system::error_code();
  return result;
}

int poll_read(int d, state_type state, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return -1;
  }

  pollfd fds;
  fds.fd = d;
  fds.events = 0x001;
  fds.revents = 0;
  int timeout = (state & user_set_non_blocking) ? 0 : -1;
  (*__errno_location ()) = 0;
  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
  if (result == 0)
    ec = (state & user_set_non_blocking)
      ? boost::asio::error::would_block : boost::system::error_code();
  else if (result > 0)
    ec = boost::system::error_code();
  return result;
}

int poll_write(int d, state_type state, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return -1;
  }

  pollfd fds;
  fds.fd = d;
  fds.events = 0x004;
  fds.revents = 0;
  int timeout = (state & user_set_non_blocking) ? 0 : -1;
  (*__errno_location ()) = 0;
  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
  if (result == 0)
    ec = (state & user_set_non_blocking)
      ? boost::asio::error::would_block : boost::system::error_code();
  else if (result > 0)
    ec = boost::system::error_code();
  return result;
}

int poll_error(int d, state_type state, boost::system::error_code& ec)
{
  if (d == -1)
  {
    ec = boost::asio::error::bad_descriptor;
    return -1;
  }

  pollfd fds;
  fds.fd = d;
  fds.events = 0x002 | 0x008 | 0x010;
  fds.revents = 0;
  int timeout = (state & user_set_non_blocking) ? 0 : -1;
  (*__errno_location ()) = 0;
  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
  if (result == 0)
    ec = (state & user_set_non_blocking)
      ? boost::asio::error::would_block : boost::system::error_code();
  else if (result > 0)
    ec = boost::system::error_code();
  return result;
}

}
}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 471 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
# 117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_read_op.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_read_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_read_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename MutableBufferSequence>
class descriptor_read_op_base : public reactor_op
{
public:
  descriptor_read_op_base(int descriptor,
      const MutableBufferSequence& buffers, func_type complete_func)
    : reactor_op(&descriptor_read_op_base::do_perform, complete_func),
      descriptor_(descriptor),
      buffers_(buffers)
  {
  }

  static status do_perform(reactor_op* base)
  {
    descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));

    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(o->buffers_);

    status result = descriptor_ops::non_blocking_read(o->descriptor_,
        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
      ? done : not_done;

    (void)0
                                         ;

    return result;
  }

private:
  int descriptor_;
  MutableBufferSequence buffers_;
};

template <typename MutableBufferSequence, typename Handler>
class descriptor_read_op
  : public descriptor_read_op_base<MutableBufferSequence>
{
public:
  struct ptr { Handler* h; descriptor_read_op* v; descriptor_read_op* p; ~ptr() { reset(); } static descriptor_read_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_read_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~descriptor_read_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_read_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<descriptor_read_op*>(v), 1); v = 0; } } };

  descriptor_read_op(int descriptor,
      const MutableBufferSequence& buffers, Handler& handler)
    : descriptor_read_op_base<MutableBufferSequence>(
        descriptor, buffers, &descriptor_read_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_read_op.hpp" 2 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_write_op.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_write_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_write_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename ConstBufferSequence>
class descriptor_write_op_base : public reactor_op
{
public:
  descriptor_write_op_base(int descriptor,
      const ConstBufferSequence& buffers, func_type complete_func)
    : reactor_op(&descriptor_write_op_base::do_perform, complete_func),
      descriptor_(descriptor),
      buffers_(buffers)
  {
  }

  static status do_perform(reactor_op* base)
  {
    descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));

    buffer_sequence_adapter<boost::asio::const_buffer,
        ConstBufferSequence> bufs(o->buffers_);

    status result = descriptor_ops::non_blocking_write(o->descriptor_,
        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
      ? done : not_done;

    (void)0
                                         ;

    return result;
  }

private:
  int descriptor_;
  ConstBufferSequence buffers_;
};

template <typename ConstBufferSequence, typename Handler>
class descriptor_write_op
  : public descriptor_write_op_base<ConstBufferSequence>
{
public:
  struct ptr { Handler* h; descriptor_write_op* v; descriptor_write_op* p; ~ptr() { reset(); } static descriptor_write_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_write_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~descriptor_write_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_write_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<descriptor_write_op*>(v), 1); v = 0; } } };

  descriptor_write_op(int descriptor,
      const ConstBufferSequence& buffers, Handler& handler)
    : descriptor_write_op_base<ConstBufferSequence>(
        descriptor, buffers, &descriptor_write_op::do_complete),
      handler_(static_cast<Handler&&>(handler))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
    handler_work<Handler> w(o->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, std::size_t>
      handler(o->handler_, o->ec_, o->bytes_transferred_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/descriptor_write_op.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor_base.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor_base.hpp" 2 3 4

namespace boost {
namespace asio {
namespace posix {



class descriptor_base
{
public:




  enum wait_type
  {

    wait_read,


    wait_write,


    wait_error
  };
# 73 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor_base.hpp" 3 4
  typedef boost::asio::detail::io_control::bytes_readable bytes_readable;


protected:

  ~descriptor_base()
  {
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor_base.hpp" 2 3 4
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class reactive_descriptor_service :
  public service_base<reactive_descriptor_service>
{
public:

  typedef int native_handle_type;


  class implementation_type
    : private boost::asio::detail::noncopyable
  {
  public:

    implementation_type()
      : descriptor_(-1),
        state_(0)
    {
    }

  private:

    friend class reactive_descriptor_service;


    int descriptor_;


    descriptor_ops::state_type state_;


    reactor::per_descriptor_data reactor_data_;
  };


  inline reactive_descriptor_service(
      boost::asio::io_context& io_context);


  inline void shutdown();


  inline void construct(implementation_type& impl);


  inline void move_construct(implementation_type& impl,
      implementation_type& other_impl);


  inline void move_assign(implementation_type& impl,
      reactive_descriptor_service& other_service,
      implementation_type& other_impl);


  inline void destroy(implementation_type& impl);


  inline boost::system::error_code assign(implementation_type& impl,
      const native_handle_type& native_descriptor,
      boost::system::error_code& ec);


  bool is_open(const implementation_type& impl) const
  {
    return impl.descriptor_ != -1;
  }


  inline boost::system::error_code close(implementation_type& impl,
      boost::system::error_code& ec);


  native_handle_type native_handle(const implementation_type& impl) const
  {
    return impl.descriptor_;
  }


  inline native_handle_type release(implementation_type& impl);


  inline boost::system::error_code cancel(implementation_type& impl,
      boost::system::error_code& ec);


  template <typename IO_Control_Command>
  boost::system::error_code io_control(implementation_type& impl,
      IO_Control_Command& command, boost::system::error_code& ec)
  {
    descriptor_ops::ioctl(impl.descriptor_, impl.state_,
        command.name(), static_cast<ioctl_arg_type*>(command.data()), ec);
    return ec;
  }


  bool non_blocking(const implementation_type& impl) const
  {
    return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
  }


  boost::system::error_code non_blocking(implementation_type& impl,
      bool mode, boost::system::error_code& ec)
  {
    descriptor_ops::set_user_non_blocking(
        impl.descriptor_, impl.state_, mode, ec);
    return ec;
  }


  bool native_non_blocking(const implementation_type& impl) const
  {
    return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
  }


  boost::system::error_code native_non_blocking(implementation_type& impl,
      bool mode, boost::system::error_code& ec)
  {
    descriptor_ops::set_internal_non_blocking(
        impl.descriptor_, impl.state_, mode, ec);
    return ec;
  }



  boost::system::error_code wait(implementation_type& impl,
      posix::descriptor_base::wait_type w, boost::system::error_code& ec)
  {
    switch (w)
    {
    case posix::descriptor_base::wait_read:
      descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
      break;
    case posix::descriptor_base::wait_write:
      descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
      break;
    case posix::descriptor_base::wait_error:
      descriptor_ops::poll_error(impl.descriptor_, impl.state_, ec);
      break;
    default:
      ec = boost::asio::error::invalid_argument;
      break;
    }

    return ec;
  }



  template <typename Handler>
  void async_wait(implementation_type& impl,
      posix::descriptor_base::wait_type w, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_wait_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                 ;

    int op_type;
    switch (w)
    {
    case posix::descriptor_base::wait_read:
        op_type = reactor::read_op;
        break;
    case posix::descriptor_base::wait_write:
        op_type = reactor::write_op;
        break;
    case posix::descriptor_base::wait_error:
        op_type = reactor::except_op;
        break;
      default:
        p.p->ec_ = boost::asio::error::invalid_argument;
        reactor_.post_immediate_completion(p.p, is_continuation);
        p.v = p.p = 0;
        return;
    }

    start_op(impl, op_type, p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }


  template <typename ConstBufferSequence>
  size_t write_some(implementation_type& impl,
      const ConstBufferSequence& buffers, boost::system::error_code& ec)
  {
    buffer_sequence_adapter<boost::asio::const_buffer,
        ConstBufferSequence> bufs(buffers);

    return descriptor_ops::sync_write(impl.descriptor_, impl.state_,
        bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
  }


  size_t write_some(implementation_type& impl,
      const null_buffers&, boost::system::error_code& ec)
  {

    descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);

    return 0;
  }



  template <typename ConstBufferSequence, typename Handler>
  void async_write_some(implementation_type& impl,
      const ConstBufferSequence& buffers, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef descriptor_write_op<ConstBufferSequence, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.descriptor_, buffers, handler);

    (void)0
                                                       ;

    start_op(impl, reactor::write_op, p.p, is_continuation, true,
        buffer_sequence_adapter<boost::asio::const_buffer,
          ConstBufferSequence>::all_empty(buffers));
    p.v = p.p = 0;
  }


  template <typename Handler>
  void async_write_some(implementation_type& impl,
      const null_buffers&, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_null_buffers_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                                     ;

    start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }


  template <typename MutableBufferSequence>
  size_t read_some(implementation_type& impl,
      const MutableBufferSequence& buffers, boost::system::error_code& ec)
  {
    buffer_sequence_adapter<boost::asio::mutable_buffer,
        MutableBufferSequence> bufs(buffers);

    return descriptor_ops::sync_read(impl.descriptor_, impl.state_,
        bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
  }


  size_t read_some(implementation_type& impl,
      const null_buffers&, boost::system::error_code& ec)
  {

    descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);

    return 0;
  }



  template <typename MutableBufferSequence, typename Handler>
  void async_read_some(implementation_type& impl,
      const MutableBufferSequence& buffers, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef descriptor_read_op<MutableBufferSequence, Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.descriptor_, buffers, handler);

    (void)0
                                                      ;

    start_op(impl, reactor::read_op, p.p, is_continuation, true,
        buffer_sequence_adapter<boost::asio::mutable_buffer,
          MutableBufferSequence>::all_empty(buffers));
    p.v = p.p = 0;
  }


  template <typename Handler>
  void async_read_some(implementation_type& impl,
      const null_buffers&, Handler& handler)
  {
    bool is_continuation =
      boost_asio_handler_cont_helpers::is_continuation(handler);


    typedef reactive_null_buffers_op<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                                    ;

    start_op(impl, reactor::read_op, p.p, is_continuation, false, false);
    p.v = p.p = 0;
  }

private:

  inline void start_op(implementation_type& impl, int op_type,
      reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);


  reactor& reactor_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

reactive_descriptor_service::reactive_descriptor_service(
    boost::asio::io_context& io_context)
  : service_base<reactive_descriptor_service>(io_context),
    reactor_(boost::asio::use_service<reactor>(io_context))
{
  reactor_.init_task();
}

void reactive_descriptor_service::shutdown()
{
}

void reactive_descriptor_service::construct(
    reactive_descriptor_service::implementation_type& impl)
{
  impl.descriptor_ = -1;
  impl.state_ = 0;
}

void reactive_descriptor_service::move_construct(
    reactive_descriptor_service::implementation_type& impl,
    reactive_descriptor_service::implementation_type& other_impl)
{
  impl.descriptor_ = other_impl.descriptor_;
  other_impl.descriptor_ = -1;

  impl.state_ = other_impl.state_;
  other_impl.state_ = 0;

  reactor_.move_descriptor(impl.descriptor_,
      impl.reactor_data_, other_impl.reactor_data_);
}

void reactive_descriptor_service::move_assign(
    reactive_descriptor_service::implementation_type& impl,
    reactive_descriptor_service& other_service,
    reactive_descriptor_service::implementation_type& other_impl)
{
  destroy(impl);

  impl.descriptor_ = other_impl.descriptor_;
  other_impl.descriptor_ = -1;

  impl.state_ = other_impl.state_;
  other_impl.state_ = 0;

  other_service.reactor_.move_descriptor(impl.descriptor_,
      impl.reactor_data_, other_impl.reactor_data_);
}

void reactive_descriptor_service::destroy(
    reactive_descriptor_service::implementation_type& impl)
{
  if (is_open(impl))
  {
    (void)0
                                                          ;

    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
        (impl.state_ & descriptor_ops::possible_dup) == 0);

    boost::system::error_code ignored_ec;
    descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);

    reactor_.cleanup_descriptor_data(impl.reactor_data_);
  }
}

boost::system::error_code reactive_descriptor_service::assign(
    reactive_descriptor_service::implementation_type& impl,
    const native_handle_type& native_descriptor, boost::system::error_code& ec)
{
  if (is_open(impl))
  {
    ec = boost::asio::error::already_open;
    return ec;
  }

  if (int err = reactor_.register_descriptor(
        native_descriptor, impl.reactor_data_))
  {
    ec = boost::system::error_code(err,
        boost::asio::error::get_system_category());
    return ec;
  }

  impl.descriptor_ = native_descriptor;
  impl.state_ = descriptor_ops::possible_dup;
  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code reactive_descriptor_service::close(
    reactive_descriptor_service::implementation_type& impl,
    boost::system::error_code& ec)
{
  if (is_open(impl))
  {
    (void)0
                                                          ;

    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
        (impl.state_ & descriptor_ops::possible_dup) == 0);

    descriptor_ops::close(impl.descriptor_, impl.state_, ec);

    reactor_.cleanup_descriptor_data(impl.reactor_data_);
  }
  else
  {
    ec = boost::system::error_code();
  }







  construct(impl);

  return ec;
}

reactive_descriptor_service::native_handle_type
reactive_descriptor_service::release(
    reactive_descriptor_service::implementation_type& impl)
{
  native_handle_type descriptor = impl.descriptor_;

  if (is_open(impl))
  {
    (void)0
                                                            ;

    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false);
    reactor_.cleanup_descriptor_data(impl.reactor_data_);
    construct(impl);
  }

  return descriptor;
}

boost::system::error_code reactive_descriptor_service::cancel(
    reactive_descriptor_service::implementation_type& impl,
    boost::system::error_code& ec)
{
  if (!is_open(impl))
  {
    ec = boost::asio::error::bad_descriptor;
    return ec;
  }

  (void)0
                                                         ;

  reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
  ec = boost::system::error_code();
  return ec;
}

void reactive_descriptor_service::start_op(
    reactive_descriptor_service::implementation_type& impl,
    int op_type, reactor_op* op, bool is_continuation,
    bool is_non_blocking, bool noop)
{
  if (!noop)
  {
    if ((impl.state_ & descriptor_ops::non_blocking) ||
        descriptor_ops::set_internal_non_blocking(
          impl.descriptor_, impl.state_, true, op->ec_))
    {
      reactor_.start_op(op_type, impl.descriptor_,
          impl.reactor_data_, op, is_continuation, is_non_blocking);
      return;
    }
  }

  reactor_.post_immediate_completion(op, is_continuation);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 219 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4
# 384 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 2 3 4
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 41 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 2 3 4

namespace boost {
namespace asio {
namespace posix {
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
class descriptor
  : protected basic_io_object<boost::asio::detail::reactive_descriptor_service>,
    public descriptor_base
{
public:

  typedef io_context::executor_type executor_type;





  typedef boost::asio::detail::reactive_descriptor_service::native_handle_type native_handle_type;



  typedef descriptor lowest_layer_type;
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  explicit descriptor(boost::asio::io_context& io_context)
    : basic_io_object<boost::asio::detail::reactive_descriptor_service>(io_context)
  {
  }
# 99 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  descriptor(boost::asio::io_context& io_context,
      const native_handle_type& native_descriptor)
    : basic_io_object<boost::asio::detail::reactive_descriptor_service>(io_context)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        native_descriptor, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 120 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  descriptor(descriptor&& other)
    : basic_io_object<boost::asio::detail::reactive_descriptor_service>(std::move(other))
  {
  }
# 135 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  descriptor& operator=(descriptor&& other)
  {
    basic_io_object<boost::asio::detail::reactive_descriptor_service>::operator=(std::move(other));
    return *this;
  }
# 152 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<boost::asio::detail::reactive_descriptor_service>::get_io_context();
  }
# 166 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<boost::asio::detail::reactive_descriptor_service>::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<boost::asio::detail::reactive_descriptor_service>::get_executor();
  }
# 187 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  lowest_layer_type& lowest_layer()
  {
    return *this;
  }
# 201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  const lowest_layer_type& lowest_layer() const
  {
    return *this;
  }
# 214 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  void assign(const native_handle_type& native_descriptor)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        native_descriptor, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 230 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::system::error_code assign(const native_handle_type& native_descriptor,
      boost::system::error_code& ec)
  {
    this->get_service().assign(
        this->get_implementation(), native_descriptor, ec);
    return ec;
  }


  bool is_open() const
  {
    return this->get_service().is_open(this->get_implementation());
  }
# 253 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  void close()
  {
    boost::system::error_code ec;
    this->get_service().close(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "close");
  }
# 269 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::system::error_code close(boost::system::error_code& ec)
  {
    this->get_service().close(this->get_implementation(), ec);
    return ec;
  }







  native_handle_type native_handle()
  {
    return this->get_service().native_handle(this->get_implementation());
  }
# 296 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  native_handle_type release()
  {
    return this->get_service().release(this->get_implementation());
  }
# 309 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  void cancel()
  {
    boost::system::error_code ec;
    this->get_service().cancel(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel");
  }
# 324 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::system::error_code cancel(boost::system::error_code& ec)
  {
    this->get_service().cancel(this->get_implementation(), ec);
    return ec;
  }
# 352 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  template <typename IoControlCommand>
  void io_control(IoControlCommand& command)
  {
    boost::system::error_code ec;
    this->get_service().io_control(this->get_implementation(), command, ec);
    boost::asio::detail::throw_error(ec, "io_control");
  }
# 387 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  template <typename IoControlCommand>
  boost::system::error_code io_control(IoControlCommand& command,
      boost::system::error_code& ec)
  {
    this->get_service().io_control(this->get_implementation(), command, ec);
    return ec;
  }
# 406 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  bool non_blocking() const
  {
    return this->get_service().non_blocking(this->get_implementation());
  }
# 424 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  void non_blocking(bool mode)
  {
    boost::system::error_code ec;
    this->get_service().non_blocking(this->get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, "non_blocking");
  }
# 444 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::system::error_code non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    this->get_service().non_blocking(this->get_implementation(), mode, ec);
    return ec;
  }
# 465 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  bool native_non_blocking() const
  {
    return this->get_service().native_non_blocking(
        this->get_implementation());
  }
# 486 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  void native_non_blocking(bool mode)
  {
    boost::system::error_code ec;
    this->get_service().native_non_blocking(
        this->get_implementation(), mode, ec);
    boost::asio::detail::throw_error(ec, "native_non_blocking");
  }
# 509 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::system::error_code native_non_blocking(
      bool mode, boost::system::error_code& ec)
  {
    this->get_service().native_non_blocking(
        this->get_implementation(), mode, ec);
    return ec;
  }
# 533 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  void wait(wait_type w)
  {
    boost::system::error_code ec;
    this->get_service().wait(this->get_implementation(), w, ec);
    boost::asio::detail::throw_error(ec, "wait");
  }
# 559 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  boost::system::error_code wait(wait_type w, boost::system::error_code& ec)
  {
    this->get_service().wait(this->get_implementation(), w, ec);
    return ec;
  }
# 603 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 3 4
  template <typename WaitHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type

  async_wait(wait_type w, WaitHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;

    async_completion<WaitHandler,
      void (boost::system::error_code)> init(handler);

    this->get_service().async_wait(
        this->get_implementation(), w, init.completion_handler);

    return init.result.get();
  }

protected:






  ~descriptor()
  {
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 638 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/descriptor.hpp" 2 3 4
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
namespace boost {
namespace asio {
namespace posix {
# 48 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
class stream_descriptor
  : public descriptor
{
public:
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  explicit stream_descriptor(boost::asio::io_context& io_context)
    : descriptor(io_context)
  {
  }
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  stream_descriptor(boost::asio::io_context& io_context,
      const native_handle_type& native_descriptor)
    : descriptor(io_context, native_descriptor)
  {
  }
# 97 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  stream_descriptor(stream_descriptor&& other)
    : descriptor(std::move(other))
  {
  }
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  stream_descriptor& operator=(stream_descriptor&& other)
  {
    descriptor::operator=(std::move(other));
    return *this;
  }
# 147 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().write_some(
        this->get_implementation(), buffers, ec);
    boost::asio::detail::throw_error(ec, "write_some");
    return s;
  }
# 173 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return this->get_service().write_some(
        this->get_implementation(), buffers, ec);
  }
# 216 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_write_some(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

    boost::asio::async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_write_some(
        this->get_implementation(), buffers, init.completion_handler);

    return init.result.get();
  }
# 263 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().read_some(
        this->get_implementation(), buffers, ec);
    boost::asio::detail::throw_error(ec, "read_some");
    return s;
  }
# 290 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return this->get_service().read_some(
        this->get_implementation(), buffers, ec);
  }
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_read_some(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

    boost::asio::async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_read_some(
        this->get_implementation(), buffers, init.completion_handler);

    return init.result.get();
  }
};


}
}
}
# 108 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/posix/stream_descriptor_service.hpp" 1 3 4
# 109 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/raw_socket_service.hpp" 1 3 4
# 111 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 2 3 4

namespace boost {
namespace asio {
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type* = 0);
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename MutableBufferSequence>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type* = 0);
# 172 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename MutableBufferSequence,
  typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type* = 0);
# 219 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename MutableBufferSequence,
    typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type* = 0);
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 287 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer,
    typename CompletionCondition>
std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 377 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer,
    typename CompletionCondition>
std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 415 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
# 444 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
    boost::system::error_code& ec);
# 483 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename Allocator,
    typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition);
# 524 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename SyncReadStream, typename Allocator,
    typename CompletionCondition>
std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition, boost::system::error_code& ec);
# 601 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename AsyncReadStream, typename MutableBufferSequence,
    typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
    ReadHandler&& handler,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type* = 0);
# 674 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename AsyncReadStream, typename MutableBufferSequence,
    typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition,
    ReadHandler&& handler,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type* = 0);
# 735 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    ReadHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 804 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename AsyncReadStream, typename DynamicBuffer,
    typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    ReadHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type* = 0);
# 867 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
    ReadHandler&& handler);
# 929 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 3 4
template <typename AsyncReadStream, typename Allocator,
    typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition,
    ReadHandler&& handler);






}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 946 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  template <typename SyncReadStream, typename MutableBufferSequence,
      typename MutableBufferIterator, typename CompletionCondition>
  std::size_t read_buffer_sequence(SyncReadStream& s,
      const MutableBufferSequence& buffers, const MutableBufferIterator&,
      CompletionCondition completion_condition, boost::system::error_code& ec)
  {
    ec = boost::system::error_code();
    boost::asio::detail::consuming_buffers<mutable_buffer,
        MutableBufferSequence, MutableBufferIterator> tmp(buffers);
    while (!tmp.empty())
    {
      if (std::size_t max_size = detail::adapt_completion_condition_result(
            completion_condition(ec, tmp.total_consumed())))
        tmp.consume(s.read_some(tmp.prepare(max_size), ec));
      else
        break;
    }
    return tmp.total_consumed();;
  }
}

template <typename SyncReadStream, typename MutableBufferSequence,
    typename CompletionCondition>
std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type*)
{
  return detail::read_buffer_sequence(s, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
}

template <typename SyncReadStream, typename MutableBufferSequence>
inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "read");
  return bytes_transferred;
}

template <typename SyncReadStream, typename MutableBufferSequence>
inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type*)
{
  return read(s, buffers, transfer_all(), ec);
}

template <typename SyncReadStream, typename MutableBufferSequence,
    typename CompletionCondition>
inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
  boost::asio::detail::throw_error(ec, "read");
  return bytes_transferred;
}

template <typename SyncReadStream, typename DynamicBuffer,
    typename CompletionCondition>
std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  typename decay<DynamicBuffer>::type b(
      static_cast<DynamicBuffer&&>(buffers));

  ec = boost::system::error_code();
  std::size_t total_transferred = 0;
  std::size_t max_size = detail::adapt_completion_condition_result(
        completion_condition(ec, total_transferred));
  std::size_t bytes_available = std::min<std::size_t>(
        std::max<std::size_t>(512, b.capacity() - b.size()),
        std::min<std::size_t>(max_size, b.max_size() - b.size()));
  while (bytes_available > 0)
  {
    std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);
    b.commit(bytes_transferred);
    total_transferred += bytes_transferred;
    max_size = detail::adapt_completion_condition_result(
          completion_condition(ec, total_transferred));
    bytes_available = std::min<std::size_t>(
          std::max<std::size_t>(512, b.capacity() - b.size()),
          std::min<std::size_t>(max_size, b.max_size() - b.size()));
  }
  return total_transferred;
}

template <typename SyncReadStream, typename DynamicBuffer>
inline std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read(s,
      static_cast<DynamicBuffer&&>(buffers), transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "read");
  return bytes_transferred;
}

template <typename SyncReadStream, typename DynamicBuffer>
inline std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::system::error_code& ec,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  return read(s, static_cast<DynamicBuffer&&>(buffers),
      transfer_all(), ec);
}

template <typename SyncReadStream, typename DynamicBuffer,
    typename CompletionCondition>
inline std::size_t read(SyncReadStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read(s,
      static_cast<DynamicBuffer&&>(buffers),
      completion_condition, ec);
  boost::asio::detail::throw_error(ec, "read");
  return bytes_transferred;
}




template <typename SyncReadStream, typename Allocator,
    typename CompletionCondition>
inline std::size_t read(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition, boost::system::error_code& ec)
{
  return read(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec);
}

template <typename SyncReadStream, typename Allocator>
inline std::size_t read(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b)
{
  return read(s, basic_streambuf_ref<Allocator>(b));
}

template <typename SyncReadStream, typename Allocator>
inline std::size_t read(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::system::error_code& ec)
{
  return read(s, basic_streambuf_ref<Allocator>(b), ec);
}

template <typename SyncReadStream, typename Allocator,
    typename CompletionCondition>
inline std::size_t read(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition)
{
  return read(s, basic_streambuf_ref<Allocator>(b), completion_condition);
}




namespace detail
{
  template <typename AsyncReadStream, typename MutableBufferSequence,
      typename MutableBufferIterator, typename CompletionCondition,
      typename ReadHandler>
  class read_op
    : detail::base_from_completion_cond<CompletionCondition>
  {
  public:
    read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
        CompletionCondition completion_condition, ReadHandler& handler)
      : detail::base_from_completion_cond<
          CompletionCondition>(completion_condition),
        stream_(stream),
        buffers_(buffers),
        start_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_op(const read_op& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        stream_(other.stream_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(other.handler_)
    {
    }

    read_op(read_op&& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        stream_(other.stream_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, buffers_.total_consumed());
        do
        {
          stream_.async_read_some(buffers_.prepare(max_size),
              static_cast<read_op&&>(*this));
          return; default:
          buffers_.consume(bytes_transferred);
          if ((!ec && bytes_transferred == 0) || buffers_.empty())
            break;
          max_size = this->check_for_completion(ec, buffers_.total_consumed());
        } while (max_size > 0);

        handler_(ec, buffers_.total_consumed());
      }
    }


    AsyncReadStream& stream_;
    boost::asio::detail::consuming_buffers<mutable_buffer,
        MutableBufferSequence, MutableBufferIterator> buffers_;
    int start_;
    ReadHandler handler_;
  };

  template <typename AsyncReadStream, typename MutableBufferSequence,
      typename MutableBufferIterator, typename CompletionCondition,
      typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename MutableBufferSequence,
      typename MutableBufferIterator, typename CompletionCondition,
      typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename MutableBufferSequence,
      typename MutableBufferIterator, typename CompletionCondition,
      typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename MutableBufferSequence,
      typename MutableBufferIterator, typename CompletionCondition,
      typename ReadHandler>
  inline void start_read_buffer_sequence_op(AsyncReadStream& stream,
      const MutableBufferSequence& buffers, const MutableBufferIterator&,
      CompletionCondition completion_condition, ReadHandler& handler)
  {
    detail::read_op<AsyncReadStream, MutableBufferSequence,
      MutableBufferIterator, CompletionCondition, ReadHandler>(
        stream, buffers, completion_condition, handler)(
          boost::system::error_code(), 0, 1);
  }
}



template <typename AsyncReadStream, typename MutableBufferSequence,
    typename MutableBufferIterator, typename CompletionCondition,
    typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::read_op<AsyncReadStream, MutableBufferSequence,
      MutableBufferIterator, CompletionCondition, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::read_op<AsyncReadStream, MutableBufferSequence,
        MutableBufferIterator, CompletionCondition, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncReadStream, typename MutableBufferSequence,
    typename MutableBufferIterator, typename CompletionCondition,
    typename ReadHandler, typename Executor>
struct associated_executor<
    detail::read_op<AsyncReadStream, MutableBufferSequence,
      MutableBufferIterator, CompletionCondition, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::read_op<AsyncReadStream, MutableBufferSequence,
        MutableBufferIterator, CompletionCondition, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncReadStream, typename MutableBufferSequence,
    typename CompletionCondition, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition,
    ReadHandler&& handler,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_read_buffer_sequence_op(s, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition,
      init.completion_handler);

  return init.result.get();
}

template <typename AsyncReadStream, typename MutableBufferSequence,
    typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
    ReadHandler&& handler,
    typename enable_if<
      is_mutable_buffer_sequence<MutableBufferSequence>::value
    >::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_read_buffer_sequence_op(s, buffers,
      boost::asio::buffer_sequence_begin(buffers), transfer_all(),
      init.completion_handler);

  return init.result.get();
}

namespace detail
{
  template <typename AsyncReadStream, typename DynamicBuffer,
      typename CompletionCondition, typename ReadHandler>
  class read_dynbuf_op
    : detail::base_from_completion_cond<CompletionCondition>
  {
  public:
    template <typename BufferSequence>
    read_dynbuf_op(AsyncReadStream& stream,
        BufferSequence&& buffers,
        CompletionCondition completion_condition, ReadHandler& handler)
      : detail::base_from_completion_cond<
          CompletionCondition>(completion_condition),
        stream_(stream),
        buffers_(static_cast<BufferSequence&&>(buffers)),
        start_(0),
        total_transferred_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_dynbuf_op(const read_dynbuf_op& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        stream_(other.stream_),
        buffers_(other.buffers_),
        start_(other.start_),
        total_transferred_(other.total_transferred_),
        handler_(other.handler_)
    {
    }

    read_dynbuf_op(read_dynbuf_op&& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        stream_(other.stream_),
        buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
        start_(other.start_),
        total_transferred_(other.total_transferred_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size, bytes_available;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, total_transferred_);
        bytes_available = std::min<std::size_t>(
              std::max<std::size_t>(512,
                buffers_.capacity() - buffers_.size()),
              std::min<std::size_t>(max_size,
                buffers_.max_size() - buffers_.size()));
        for (;;)
        {
          stream_.async_read_some(buffers_.prepare(bytes_available),
              static_cast<read_dynbuf_op&&>(*this));
          return; default:
          total_transferred_ += bytes_transferred;
          buffers_.commit(bytes_transferred);
          max_size = this->check_for_completion(ec, total_transferred_);
          bytes_available = std::min<std::size_t>(
                std::max<std::size_t>(512,
                  buffers_.capacity() - buffers_.size()),
                std::min<std::size_t>(max_size,
                  buffers_.max_size() - buffers_.size()));
          if ((!ec && bytes_transferred == 0) || bytes_available == 0)
            break;
        }

        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
      }
    }


    AsyncReadStream& stream_;
    DynamicBuffer buffers_;
    int start_;
    std::size_t total_transferred_;
    ReadHandler handler_;
  };

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename CompletionCondition, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
        CompletionCondition, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename CompletionCondition, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
        CompletionCondition, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename CompletionCondition,
      typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename CompletionCondition,
      typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_dynbuf_op<AsyncReadStream, DynamicBuffer,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename AsyncReadStream, typename DynamicBuffer,
    typename CompletionCondition, typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::read_dynbuf_op<AsyncReadStream,
      DynamicBuffer, CompletionCondition, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::read_dynbuf_op<AsyncReadStream,
        DynamicBuffer, CompletionCondition, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncReadStream, typename DynamicBuffer,
    typename CompletionCondition, typename ReadHandler, typename Executor>
struct associated_executor<
    detail::read_dynbuf_op<AsyncReadStream,
      DynamicBuffer, CompletionCondition, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::read_dynbuf_op<AsyncReadStream,
        DynamicBuffer, CompletionCondition, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    ReadHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{
  return async_read(s,
      static_cast<DynamicBuffer&&>(buffers),
      transfer_all(), static_cast<ReadHandler&&>(handler));
}

template <typename AsyncReadStream, typename DynamicBuffer,
    typename CompletionCondition, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    CompletionCondition completion_condition,
    ReadHandler&& handler,
    typename enable_if<
      is_dynamic_buffer<typename decay<DynamicBuffer>::type>::value
    >::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::read_dynbuf_op<AsyncReadStream,
    typename decay<DynamicBuffer>::type,
      CompletionCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                   >(
          s, static_cast<DynamicBuffer&&>(buffers),
            completion_condition, init.completion_handler)(
              boost::system::error_code(), 0, 1);

  return init.result.get();
}




template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
    ReadHandler&& handler)
{
  return async_read(s, basic_streambuf_ref<Allocator>(b),
      static_cast<ReadHandler&&>(handler));
}

template <typename AsyncReadStream, typename Allocator,
    typename CompletionCondition, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition,
    ReadHandler&& handler)
{
  return async_read(s, basic_streambuf_ref<Allocator>(b),
      completion_condition, static_cast<ReadHandler&&>(handler));
}




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 716 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read.hpp" 2 3 4
# 948 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read.hpp" 2 3 4
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 2 3 4

namespace boost {
namespace asio {
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers);
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    boost::system::error_code& ec);
# 181 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition);
# 230 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec);
# 267 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, basic_streambuf<Allocator>& b);
# 299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename Allocator>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, basic_streambuf<Allocator>& b,
    boost::system::error_code& ec);
# 341 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename Allocator,
    typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition);
# 385 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename SyncRandomAccessReadDevice, typename Allocator,
    typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition, boost::system::error_code& ec);
# 462 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
    const MutableBufferSequence& buffers,
    ReadHandler&& handler);
# 535 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition,
    ReadHandler&& handler);
# 592 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename AsyncRandomAccessReadDevice, typename Allocator,
    typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
    basic_streambuf<Allocator>& b, ReadHandler&& handler);
# 652 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 3 4
template <typename AsyncRandomAccessReadDevice, typename Allocator,
    typename CompletionCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d,
    uint64_t offset, basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition,
    ReadHandler&& handler);






}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 670 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_at.hpp" 1 3 4
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_at.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_at.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
      typename MutableBufferIterator, typename CompletionCondition>
  std::size_t read_at_buffer_sequence(SyncRandomAccessReadDevice& d,
      uint64_t offset, const MutableBufferSequence& buffers,
      const MutableBufferIterator&, CompletionCondition completion_condition,
      boost::system::error_code& ec)
  {
    ec = boost::system::error_code();
    boost::asio::detail::consuming_buffers<mutable_buffer,
        MutableBufferSequence, MutableBufferIterator> tmp(buffers);
    while (!tmp.empty())
    {
      if (std::size_t max_size = detail::adapt_completion_condition_result(
            completion_condition(ec, tmp.total_consumed())))
      {
        tmp.consume(d.read_some_at(offset + tmp.total_consumed(),
              tmp.prepare(max_size), ec));
      }
      else
        break;
    }
    return tmp.total_consumed();;
  }
}

template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec)
{
  return detail::read_at_buffer_sequence(d, offset, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
}

template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
inline std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_at(
      d, offset, buffers, transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "read_at");
  return bytes_transferred;
}

template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
inline std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    boost::system::error_code& ec)
{
  return read_at(d, offset, buffers, transfer_all(), ec);
}

template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename CompletionCondition>
inline std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_at(
      d, offset, buffers, completion_condition, ec);
  boost::asio::detail::throw_error(ec, "read_at");
  return bytes_transferred;
}




template <typename SyncRandomAccessReadDevice, typename Allocator,
    typename CompletionCondition>
std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition, boost::system::error_code& ec)
{
  ec = boost::system::error_code();
  std::size_t total_transferred = 0;
  std::size_t max_size = detail::adapt_completion_condition_result(
        completion_condition(ec, total_transferred));
  std::size_t bytes_available = read_size_helper(b, max_size);
  while (bytes_available > 0)
  {
    std::size_t bytes_transferred = d.read_some_at(
        offset + total_transferred, b.prepare(bytes_available), ec);
    b.commit(bytes_transferred);
    total_transferred += bytes_transferred;
    max_size = detail::adapt_completion_condition_result(
          completion_condition(ec, total_transferred));
    bytes_available = read_size_helper(b, max_size);
  }
  return total_transferred;
}

template <typename SyncRandomAccessReadDevice, typename Allocator>
inline std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_at(
      d, offset, b, transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "read_at");
  return bytes_transferred;
}

template <typename SyncRandomAccessReadDevice, typename Allocator>
inline std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    boost::system::error_code& ec)
{
  return read_at(d, offset, b, transfer_all(), ec);
}

template <typename SyncRandomAccessReadDevice, typename Allocator,
    typename CompletionCondition>
inline std::size_t read_at(SyncRandomAccessReadDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_at(
      d, offset, b, completion_condition, ec);
  boost::asio::detail::throw_error(ec, "read_at");
  return bytes_transferred;
}




namespace detail
{
  template <typename AsyncRandomAccessReadDevice,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  class read_at_op
    : detail::base_from_completion_cond<CompletionCondition>
  {
  public:
    read_at_op(AsyncRandomAccessReadDevice& device,
        uint64_t offset, const MutableBufferSequence& buffers,
        CompletionCondition completion_condition, ReadHandler& handler)
      : detail::base_from_completion_cond<
          CompletionCondition>(completion_condition),
        device_(device),
        offset_(offset),
        buffers_(buffers),
        start_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_at_op(const read_at_op& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        device_(other.device_),
        offset_(other.offset_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(other.handler_)
    {
    }

    read_at_op(read_at_op&& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        device_(other.device_),
        offset_(other.offset_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, buffers_.total_consumed());
        do
        {
          device_.async_read_some_at(
              offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
              static_cast<read_at_op&&>(*this));
          return; default:
          buffers_.consume(bytes_transferred);
          if ((!ec && bytes_transferred == 0) || buffers_.empty())
            break;
          max_size = this->check_for_completion(ec, buffers_.total_consumed());
        } while (max_size > 0);

        handler_(ec, buffers_.total_consumed());
      }
    }


    AsyncRandomAccessReadDevice& device_;
    uint64_t offset_;
    boost::asio::detail::consuming_buffers<mutable_buffer,
        MutableBufferSequence, MutableBufferIterator> buffers_;
    int start_;
    ReadHandler handler_;
  };

  template <typename AsyncRandomAccessReadDevice,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncRandomAccessReadDevice,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncRandomAccessReadDevice,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncRandomAccessReadDevice,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncRandomAccessReadDevice,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
        MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename AsyncRandomAccessReadDevice,
      typename MutableBufferSequence, typename MutableBufferIterator,
      typename CompletionCondition, typename ReadHandler>
  inline void start_read_at_buffer_sequence_op(AsyncRandomAccessReadDevice& d,
      uint64_t offset, const MutableBufferSequence& buffers,
      const MutableBufferIterator&, CompletionCondition completion_condition,
      ReadHandler& handler)
  {
    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
      MutableBufferIterator, CompletionCondition, ReadHandler>(
        d, offset, buffers, completion_condition, handler)(
          boost::system::error_code(), 0, 1);
  }
}



template <typename AsyncRandomAccessReadDevice,
    typename MutableBufferSequence, typename MutableBufferIterator,
    typename CompletionCondition, typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
    MutableBufferIterator, CompletionCondition, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::read_at_op<AsyncRandomAccessReadDevice,
      MutableBufferSequence, MutableBufferIterator,
      CompletionCondition, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncRandomAccessReadDevice,
    typename MutableBufferSequence, typename MutableBufferIterator,
    typename CompletionCondition, typename ReadHandler, typename Executor>
struct associated_executor<
    detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
    MutableBufferIterator, CompletionCondition, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::read_at_op<AsyncRandomAccessReadDevice,
      MutableBufferSequence, MutableBufferIterator,
      CompletionCondition, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename CompletionCondition, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    CompletionCondition completion_condition,
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_read_at_buffer_sequence_op(d, offset, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition,
      init.completion_handler);

  return init.result.get();
}

template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
    typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d,
    uint64_t offset, const MutableBufferSequence& buffers,
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_read_at_buffer_sequence_op(d, offset, buffers,
      boost::asio::buffer_sequence_begin(buffers), transfer_all(),
      init.completion_handler);

  return init.result.get();
}




namespace detail
{
  template <typename AsyncRandomAccessReadDevice, typename Allocator,
      typename CompletionCondition, typename ReadHandler>
  class read_at_streambuf_op
    : detail::base_from_completion_cond<CompletionCondition>
  {
  public:
    read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
        uint64_t offset, basic_streambuf<Allocator>& streambuf,
        CompletionCondition completion_condition, ReadHandler& handler)
      : detail::base_from_completion_cond<
          CompletionCondition>(completion_condition),
        device_(device),
        offset_(offset),
        streambuf_(streambuf),
        start_(0),
        total_transferred_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_at_streambuf_op(const read_at_streambuf_op& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        device_(other.device_),
        offset_(other.offset_),
        streambuf_(other.streambuf_),
        start_(other.start_),
        total_transferred_(other.total_transferred_),
        handler_(other.handler_)
    {
    }

    read_at_streambuf_op(read_at_streambuf_op&& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        device_(other.device_),
        offset_(other.offset_),
        streambuf_(other.streambuf_),
        start_(other.start_),
        total_transferred_(other.total_transferred_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size, bytes_available;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, total_transferred_);
        bytes_available = read_size_helper(streambuf_, max_size);
        for (;;)
        {
          device_.async_read_some_at(offset_ + total_transferred_,
              streambuf_.prepare(bytes_available),
              static_cast<read_at_streambuf_op&&>(*this));
          return; default:
          total_transferred_ += bytes_transferred;
          streambuf_.commit(bytes_transferred);
          max_size = this->check_for_completion(ec, total_transferred_);
          bytes_available = read_size_helper(streambuf_, max_size);
          if ((!ec && bytes_transferred == 0) || bytes_available == 0)
            break;
        }

        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
      }
    }


    AsyncRandomAccessReadDevice& device_;
    uint64_t offset_;
    boost::asio::basic_streambuf<Allocator>& streambuf_;
    int start_;
    std::size_t total_transferred_;
    ReadHandler handler_;
  };

  template <typename AsyncRandomAccessReadDevice, typename Allocator,
      typename CompletionCondition, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncRandomAccessReadDevice, typename Allocator,
      typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncRandomAccessReadDevice, typename Allocator,
      typename CompletionCondition, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncRandomAccessReadDevice,
      typename Allocator, typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncRandomAccessReadDevice,
      typename Allocator, typename CompletionCondition, typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
        CompletionCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename AsyncRandomAccessReadDevice, typename Allocator,
    typename CompletionCondition, typename ReadHandler, typename Allocator1>
struct associated_allocator<
    detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
      Allocator, CompletionCondition, ReadHandler>,
    Allocator1>
{
  typedef typename associated_allocator<ReadHandler, Allocator1>::type type;

  static type get(
      const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
        Allocator, CompletionCondition, ReadHandler>& h,
      const Allocator1& a = Allocator1()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator1>::get(h.handler_, a);
  }
};

template <typename AsyncRandomAccessReadDevice, typename Executor,
    typename CompletionCondition, typename ReadHandler, typename Executor1>
struct associated_executor<
    detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
      Executor, CompletionCondition, ReadHandler>,
    Executor1>
{
  typedef typename associated_executor<ReadHandler, Executor1>::type type;

  static type get(
      const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
        Executor, CompletionCondition, ReadHandler>& h,
      const Executor1& ex = Executor1()) noexcept
  {
    return associated_executor<ReadHandler, Executor1>::get(h.handler_, ex);
  }
};



template <typename AsyncRandomAccessReadDevice, typename Allocator,
    typename CompletionCondition, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition,
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
    CompletionCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                    >(
        d, offset, b, completion_condition, init.completion_handler)(
          boost::system::error_code(), 0, 1);

  return init.result.get();
}

template <typename AsyncRandomAccessReadDevice, typename Allocator,
    typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_at(AsyncRandomAccessReadDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
    detail::transfer_all_t, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                    >(
        d, offset, b, transfer_all(), init.completion_handler)(
          boost::system::error_code(), 0, 1);

  return init.result.get();
}




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 641 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_at.hpp" 2 3 4
# 672 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_at.hpp" 2 3 4
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/regex_fwd.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/regex_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex_fwd.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex_fwd.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 1 3 4
# 42 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/user.hpp" 1 3 4
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/predef.h" 1 3 4
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 2 3 4
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config/cwchar.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config/cwchar.hpp" 3 4
# 1 "/usr/include/c++/10/cwchar" 1 3 4
# 39 "/usr/include/c++/10/cwchar" 3 4
       
# 40 "/usr/include/c++/10/cwchar" 3
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config/cwchar.hpp" 2 3 4
# 1 "/usr/include/c++/10/cwctype" 1 3 4
# 39 "/usr/include/c++/10/cwctype" 3 4
       
# 40 "/usr/include/c++/10/cwctype" 3
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config/cwchar.hpp" 2 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config/cwchar.hpp" 3 4
namespace std{


extern "C"{
# 201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config/cwchar.hpp" 3 4
}


}
# 137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 2 3 4
# 249 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/config/auto_link.hpp" 1 3 4
# 250 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 2 3 4
# 432 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/config.hpp" 3 4
namespace boost{ namespace re_detail_106700{

 void* get_mem_block();
 void put_mem_block(void*);

}}
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex_fwd.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/v4/regex_fwd.hpp" 1 3 4
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/v4/regex_fwd.hpp" 3 4
namespace boost{

template <class charT>
class cpp_regex_traits;
template <class charT>
struct c_regex_traits;
template <class charT>
class w32_regex_traits;





template <class charT, class implementationT = cpp_regex_traits<charT> >
struct regex_traits;





template <class charT, class traits = regex_traits<charT> >
class basic_regex;

typedef basic_regex<char, regex_traits<char> > regex;

typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;


}
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex_fwd.hpp" 2 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/regex_fwd.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/v4/match_flags.hpp" 1 3 4
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/v4/match_flags.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/cstdint.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/regex/v4/match_flags.hpp" 2 3 4




namespace boost{
   namespace regex_constants{


typedef enum _match_flags
{
   match_default = 0,
   match_not_bol = 1,
   match_not_eol = match_not_bol << 1,
   match_not_bob = match_not_eol << 1,
   match_not_eob = match_not_bob << 1,
   match_not_bow = match_not_eob << 1,
   match_not_eow = match_not_bow << 1,
   match_not_dot_newline = match_not_eow << 1,
   match_not_dot_null = match_not_dot_newline << 1,
   match_prev_avail = match_not_dot_null << 1,
   match_init = match_prev_avail << 1,
   match_any = match_init << 1,
   match_not_null = match_any << 1,
   match_continuous = match_not_null << 1,

   match_partial = match_continuous << 1,

   match_stop = match_partial << 1,
   match_not_initial_null = match_stop,
   match_all = match_stop << 1,
   match_perl = match_all << 1,
   match_posix = match_perl << 1,
   match_nosubs = match_posix << 1,
   match_extra = match_nosubs << 1,
   match_single_line = match_extra << 1,
   match_unused1 = match_single_line << 1,
   match_unused2 = match_unused1 << 1,
   match_unused3 = match_unused2 << 1,
   match_max = match_unused3,

   format_perl = 0,
   format_default = 0,
   format_sed = match_max << 1,
   format_all = format_sed << 1,
   format_no_copy = format_all << 1,
   format_first_only = format_no_copy << 1,
   format_is_if = format_first_only << 1,
   format_literal = format_is_if << 1,

   match_not_any = match_not_bol | match_not_eol | match_not_bob
      | match_not_eob | match_not_bow | match_not_eow | match_not_dot_newline
      | match_not_dot_null | match_prev_avail | match_init | match_not_null
      | match_continuous | match_partial | match_stop | match_not_initial_null
      | match_stop | match_all | match_perl | match_posix | match_nosubs
      | match_extra | match_single_line | match_unused1 | match_unused2
      | match_unused3 | match_max | format_perl | format_default | format_sed
      | format_all | format_no_copy | format_first_only | format_is_if
      | format_literal


} match_flags;




typedef match_flags match_flag_type;



inline match_flags operator&(match_flags m1, match_flags m2)
{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }
inline match_flags operator|(match_flags m1, match_flags m2)
{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }
inline match_flags operator^(match_flags m1, match_flags m2)
{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }
inline match_flags operator~(match_flags m1)
{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }
inline match_flags& operator&=(match_flags& m1, match_flags m2)
{ m1 = m1&m2; return m1; }
inline match_flags& operator|=(match_flags& m1, match_flags m2)
{ m1 = m1|m2; return m1; }
inline match_flags& operator^=(match_flags& m1, match_flags m2)
{ m1 = m1^m2; return m1; }




}



using regex_constants::match_flag_type;
using regex_constants::match_default;
using regex_constants::match_not_bol;
using regex_constants::match_not_eol;
using regex_constants::match_not_bob;
using regex_constants::match_not_eob;
using regex_constants::match_not_bow;
using regex_constants::match_not_eow;
using regex_constants::match_not_dot_newline;
using regex_constants::match_not_dot_null;
using regex_constants::match_prev_avail;

using regex_constants::match_any;
using regex_constants::match_not_null;
using regex_constants::match_continuous;
using regex_constants::match_partial;

using regex_constants::match_all;
using regex_constants::match_perl;
using regex_constants::match_posix;
using regex_constants::match_nosubs;
using regex_constants::match_extra;
using regex_constants::match_single_line;

using regex_constants::format_all;
using regex_constants::format_sed;
using regex_constants::format_perl;
using regex_constants::format_default;
using regex_constants::format_no_copy;
using regex_constants::format_first_only;


}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/regex_fwd.hpp" 2 3 4

namespace boost {

template <class BidiIterator>
struct sub_match;

template <class BidiIterator, class Allocator>
class match_results;

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  char (&has_result_type_helper(...))[2];

  template <typename T>
  char has_result_type_helper(T*, typename T::result_type* = 0);

  template <typename T>
  struct has_result_type
  {
    enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
  };
}



template <typename T>
struct is_match_condition
{




  enum
  {
    value = boost::asio::is_function<
        typename boost::asio::remove_pointer<T>::type>::value
      || detail::has_result_type<T>::value
  };

};
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers, char delim);
# 168 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    char delim, boost::system::error_code& ec);
# 224 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::asio::string_view delim);
# 263 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::asio::string_view delim,
    boost::system::error_code& ec);
# 327 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    const boost::regex& expr);
# 368 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    const boost::regex& expr, boost::system::error_code& ec);
# 478 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream,
    typename DynamicBuffer, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    MatchCondition match_condition,
    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
# 538 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream,
    typename DynamicBuffer, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    MatchCondition match_condition, boost::system::error_code& ec,
    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
# 595 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, char delim);
# 629 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, char delim,
    boost::system::error_code& ec);
# 682 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::asio::string_view delim);
# 717 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::asio::string_view delim, boost::system::error_code& ec);
# 775 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
# 812 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
    boost::system::error_code& ec);
# 920 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
# 976 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename SyncReadStream, typename Allocator, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    MatchCondition match_condition, boost::system::error_code& ec,
    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
# 1077 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    char delim, ReadHandler&& handler);
# 1167 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::asio::string_view delim,
    ReadHandler&& handler);
# 1265 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    const boost::regex& expr,
    ReadHandler&& handler);
# 1405 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream, typename DynamicBuffer,
    typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    MatchCondition match_condition, ReadHandler&& handler,
    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
# 1494 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    char delim, ReadHandler&& handler);
# 1579 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::asio::string_view delim,
    ReadHandler&& handler);
# 1672 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
    ReadHandler&& handler);
# 1805 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 3 4
template <typename AsyncReadStream, typename Allocator,
    typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    MatchCondition match_condition, ReadHandler&& handler,
    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);






}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1823 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_until.hpp" 1 3 4
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_until.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_until.hpp" 2 3 4

namespace boost {
namespace asio {

template <typename SyncReadStream, typename DynamicBuffer>
inline std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers, char delim)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_until(s,
      static_cast<DynamicBuffer&&>(buffers), delim, ec);
  boost::asio::detail::throw_error(ec, "read_until");
  return bytes_transferred;
}

template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    char delim, boost::system::error_code& ec)
{
  typename decay<DynamicBuffer>::type b(
      static_cast<DynamicBuffer&&>(buffers));

  std::size_t search_position = 0;
  for (;;)
  {

    typedef typename DynamicBuffer::const_buffers_type buffers_type;
    typedef buffers_iterator<buffers_type> iterator;
    buffers_type data_buffers = b.data();
    iterator begin = iterator::begin(data_buffers);
    iterator start_pos = begin + search_position;
    iterator end = iterator::end(data_buffers);


    iterator iter = std::find(start_pos, end, delim);
    if (iter != end)
    {

      ec = boost::system::error_code();
      return iter - begin + 1;
    }
    else
    {

      search_position = end - begin;
    }


    if (b.size() == b.max_size())
    {
      ec = error::not_found;
      return 0;
    }


    std::size_t bytes_to_read = std::min<std::size_t>(
          std::max<std::size_t>(512, b.capacity() - b.size()),
          std::min<std::size_t>(65536, b.max_size() - b.size()));
    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
    if (ec)
      return 0;
  }
}

template <typename SyncReadStream, typename DynamicBuffer>
inline std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::asio::string_view delim)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_until(s,
      static_cast<DynamicBuffer&&>(buffers), delim, ec);
  boost::asio::detail::throw_error(ec, "read_until");
  return bytes_transferred;
}

namespace detail
{






  template <typename Iterator1, typename Iterator2>
  std::pair<Iterator1, bool> partial_search(
      Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
  {
    for (Iterator1 iter1 = first1; iter1 != last1; ++iter1)
    {
      Iterator1 test_iter1 = iter1;
      Iterator2 test_iter2 = first2;
      for (;; ++test_iter1, ++test_iter2)
      {
        if (test_iter2 == last2)
          return std::make_pair(iter1, true);
        if (test_iter1 == last1)
        {
          if (test_iter2 != first2)
            return std::make_pair(iter1, false);
          else
            break;
        }
        if (*test_iter1 != *test_iter2)
          break;
      }
    }
    return std::make_pair(last1, false);
  }
}

template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::asio::string_view delim, boost::system::error_code& ec)
{
  typename decay<DynamicBuffer>::type b(
      static_cast<DynamicBuffer&&>(buffers));

  std::size_t search_position = 0;
  for (;;)
  {

    typedef typename DynamicBuffer::const_buffers_type buffers_type;
    typedef buffers_iterator<buffers_type> iterator;
    buffers_type data_buffers = b.data();
    iterator begin = iterator::begin(data_buffers);
    iterator start_pos = begin + search_position;
    iterator end = iterator::end(data_buffers);


    std::pair<iterator, bool> result = detail::partial_search(
        start_pos, end, delim.begin(), delim.end());
    if (result.first != end)
    {
      if (result.second)
      {

        ec = boost::system::error_code();
        return result.first - begin + delim.length();
      }
      else
      {

        search_position = result.first - begin;
      }
    }
    else
    {

      search_position = end - begin;
    }


    if (b.size() == b.max_size())
    {
      ec = error::not_found;
      return 0;
    }


    std::size_t bytes_to_read = std::min<std::size_t>(
          std::max<std::size_t>(512, b.capacity() - b.size()),
          std::min<std::size_t>(65536, b.max_size() - b.size()));
    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
    if (ec)
      return 0;
  }
}




template <typename SyncReadStream, typename DynamicBuffer>
inline std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    const boost::regex& expr)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_until(s,
      static_cast<DynamicBuffer&&>(buffers), expr, ec);
  boost::asio::detail::throw_error(ec, "read_until");
  return bytes_transferred;
}

template <typename SyncReadStream, typename DynamicBuffer>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    const boost::regex& expr, boost::system::error_code& ec)
{
  typename decay<DynamicBuffer>::type b(
      static_cast<DynamicBuffer&&>(buffers));

  std::size_t search_position = 0;
  for (;;)
  {

    typedef typename DynamicBuffer::const_buffers_type buffers_type;
    typedef buffers_iterator<buffers_type> iterator;
    buffers_type data_buffers = b.data();
    iterator begin = iterator::begin(data_buffers);
    iterator start_pos = begin + search_position;
    iterator end = iterator::end(data_buffers);


    boost::match_results<iterator,
      typename std::vector<boost::sub_match<iterator> >::allocator_type>
        match_results;
    if (regex_search(start_pos, end, match_results, expr,
          boost::match_default | boost::match_partial))
    {
      if (match_results[0].matched)
      {

        ec = boost::system::error_code();
        return match_results[0].second - begin;
      }
      else
      {

        search_position = match_results[0].first - begin;
      }
    }
    else
    {

      search_position = end - begin;
    }


    if (b.size() == b.max_size())
    {
      ec = error::not_found;
      return 0;
    }


    std::size_t bytes_to_read = read_size_helper(b, 65536);
    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
    if (ec)
      return 0;
  }
}



template <typename SyncReadStream,
    typename DynamicBuffer, typename MatchCondition>
inline std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    MatchCondition match_condition,
    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = read_until(s,
      static_cast<DynamicBuffer&&>(buffers),
      match_condition, ec);
  boost::asio::detail::throw_error(ec, "read_until");
  return bytes_transferred;
}

template <typename SyncReadStream,
    typename DynamicBuffer, typename MatchCondition>
std::size_t read_until(SyncReadStream& s,
    DynamicBuffer&& buffers,
    MatchCondition match_condition, boost::system::error_code& ec,
    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
{
  typename decay<DynamicBuffer>::type b(
      static_cast<DynamicBuffer&&>(buffers));

  std::size_t search_position = 0;
  for (;;)
  {

    typedef typename DynamicBuffer::const_buffers_type buffers_type;
    typedef buffers_iterator<buffers_type> iterator;
    buffers_type data_buffers = b.data();
    iterator begin = iterator::begin(data_buffers);
    iterator start_pos = begin + search_position;
    iterator end = iterator::end(data_buffers);


    std::pair<iterator, bool> result = match_condition(start_pos, end);
    if (result.second)
    {

      ec = boost::system::error_code();
      return result.first - begin;
    }
    else if (result.first != end)
    {

      search_position = result.first - begin;
    }
    else
    {

      search_position = end - begin;
    }


    if (b.size() == b.max_size())
    {
      ec = error::not_found;
      return 0;
    }


    std::size_t bytes_to_read = std::min<std::size_t>(
          std::max<std::size_t>(512, b.capacity() - b.size()),
          std::min<std::size_t>(65536, b.max_size() - b.size()));
    b.commit(s.read_some(b.prepare(bytes_to_read), ec));
    if (ec)
      return 0;
  }
}



template <typename SyncReadStream, typename Allocator>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, char delim)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
}

template <typename SyncReadStream, typename Allocator>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, char delim,
    boost::system::error_code& ec)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
}

template <typename SyncReadStream, typename Allocator>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::asio::string_view delim)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
}

template <typename SyncReadStream, typename Allocator>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::asio::string_view delim, boost::system::error_code& ec)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
}



template <typename SyncReadStream, typename Allocator>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), expr);
}

template <typename SyncReadStream, typename Allocator>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
    boost::system::error_code& ec)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), expr, ec);
}



template <typename SyncReadStream, typename Allocator, typename MatchCondition>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition);
}

template <typename SyncReadStream, typename Allocator, typename MatchCondition>
inline std::size_t read_until(SyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    MatchCondition match_condition, boost::system::error_code& ec,
    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
{
  return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition, ec);
}




namespace detail
{
  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  class read_until_delim_op
  {
  public:
    template <typename BufferSequence>
    read_until_delim_op(AsyncReadStream& stream,
        BufferSequence&& buffers,
        char delim, ReadHandler& handler)
      : stream_(stream),
        buffers_(static_cast<BufferSequence&&>(buffers)),
        delim_(delim),
        start_(0),
        search_position_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_until_delim_op(const read_until_delim_op& other)
      : stream_(other.stream_),
        buffers_(other.buffers_),
        delim_(other.delim_),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(other.handler_)
    {
    }

    read_until_delim_op(read_until_delim_op&& other)
      : stream_(other.stream_),
        buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
        delim_(other.delim_),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
      std::size_t bytes_to_read;
      switch (start_ = start)
      {
      case 1:
        for (;;)
        {
          {

            typedef typename DynamicBuffer::const_buffers_type
              buffers_type;
            typedef buffers_iterator<buffers_type> iterator;
            buffers_type data_buffers = buffers_.data();
            iterator begin = iterator::begin(data_buffers);
            iterator start_pos = begin + search_position_;
            iterator end = iterator::end(data_buffers);


            iterator iter = std::find(start_pos, end, delim_);
            if (iter != end)
            {

              search_position_ = iter - begin + 1;
              bytes_to_read = 0;
            }


            else if (buffers_.size() == buffers_.max_size())
            {
              search_position_ = not_found;
              bytes_to_read = 0;
            }


            else
            {

              search_position_ = end - begin;
              bytes_to_read = std::min<std::size_t>(
                    std::max<std::size_t>(512,
                      buffers_.capacity() - buffers_.size()),
                    std::min<std::size_t>(65536,
                      buffers_.max_size() - buffers_.size()));
            }
          }


          if (!start && bytes_to_read == 0)
            break;


          stream_.async_read_some(buffers_.prepare(bytes_to_read),
              static_cast<read_until_delim_op&&>(*this));
          return; default:
          buffers_.commit(bytes_transferred);
          if (ec || bytes_transferred == 0)
            break;
        }

        const boost::system::error_code result_ec =
          (search_position_ == not_found)
          ? error::not_found : ec;

        const std::size_t result_n =
          (ec || search_position_ == not_found)
          ? 0 : search_position_;

        handler_(result_ec, result_n);
      }
    }


    AsyncReadStream& stream_;
    DynamicBuffer buffers_;
    char delim_;
    int start_;
    std::size_t search_position_;
    ReadHandler handler_;
  };

  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_until_delim_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_until_delim_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_until_delim_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_until_delim_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_until_delim_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename AsyncReadStream, typename DynamicBuffer,
    typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::read_until_delim_op<AsyncReadStream,
      DynamicBuffer, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::read_until_delim_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncReadStream, typename DynamicBuffer,
    typename ReadHandler, typename Executor>
struct associated_executor<
    detail::read_until_delim_op<AsyncReadStream,
      DynamicBuffer, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::read_until_delim_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    char delim, ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::read_until_delim_op<AsyncReadStream,
    typename decay<DynamicBuffer>::type,
      typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                      >(
          s, static_cast<DynamicBuffer&&>(buffers),
            delim, init.completion_handler)(boost::system::error_code(), 0, 1);

  return init.result.get();
}

namespace detail
{
  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  class read_until_delim_string_op
  {
  public:
    template <typename BufferSequence>
    read_until_delim_string_op(AsyncReadStream& stream,
        BufferSequence&& buffers,
        const std::string& delim, ReadHandler& handler)
      : stream_(stream),
        buffers_(static_cast<BufferSequence&&>(buffers)),
        delim_(delim),
        start_(0),
        search_position_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_until_delim_string_op(const read_until_delim_string_op& other)
      : stream_(other.stream_),
        buffers_(other.buffers_),
        delim_(other.delim_),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(other.handler_)
    {
    }

    read_until_delim_string_op(read_until_delim_string_op&& other)
      : stream_(other.stream_),
        buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
        delim_(static_cast<std::string&&>(other.delim_)),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
      std::size_t bytes_to_read;
      switch (start_ = start)
      {
      case 1:
        for (;;)
        {
          {

            typedef typename DynamicBuffer::const_buffers_type
              buffers_type;
            typedef buffers_iterator<buffers_type> iterator;
            buffers_type data_buffers = buffers_.data();
            iterator begin = iterator::begin(data_buffers);
            iterator start_pos = begin + search_position_;
            iterator end = iterator::end(data_buffers);


            std::pair<iterator, bool> result = detail::partial_search(
                start_pos, end, delim_.begin(), delim_.end());
            if (result.first != end && result.second)
            {

              search_position_ = result.first - begin + delim_.length();
              bytes_to_read = 0;
            }


            else if (buffers_.size() == buffers_.max_size())
            {
              search_position_ = not_found;
              bytes_to_read = 0;
            }


            else
            {
              if (result.first != end)
              {


                search_position_ = result.first - begin;
              }
              else
              {

                search_position_ = end - begin;
              }

              bytes_to_read = std::min<std::size_t>(
                    std::max<std::size_t>(512,
                      buffers_.capacity() - buffers_.size()),
                    std::min<std::size_t>(65536,
                      buffers_.max_size() - buffers_.size()));
            }
          }


          if (!start && bytes_to_read == 0)
            break;


          stream_.async_read_some(buffers_.prepare(bytes_to_read),
              static_cast<read_until_delim_string_op&&>(*this));
          return; default:
          buffers_.commit(bytes_transferred);
          if (ec || bytes_transferred == 0)
            break;
        }

        const boost::system::error_code result_ec =
          (search_position_ == not_found)
          ? error::not_found : ec;

        const std::size_t result_n =
          (ec || search_position_ == not_found)
          ? 0 : search_position_;

        handler_(result_ec, result_n);
      }
    }


    AsyncReadStream& stream_;
    DynamicBuffer buffers_;
    std::string delim_;
    int start_;
    std::size_t search_position_;
    ReadHandler handler_;
  };

  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_until_delim_string_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_until_delim_string_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_until_delim_string_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_until_delim_string_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_until_delim_string_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename AsyncReadStream, typename DynamicBuffer,
    typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::read_until_delim_string_op<AsyncReadStream,
      DynamicBuffer, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::read_until_delim_string_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncReadStream, typename DynamicBuffer,
    typename ReadHandler, typename Executor>
struct associated_executor<
    detail::read_until_delim_string_op<AsyncReadStream,
      DynamicBuffer, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::read_until_delim_string_op<AsyncReadStream,
        DynamicBuffer, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    boost::asio::string_view delim,
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::read_until_delim_string_op<AsyncReadStream,
    typename decay<DynamicBuffer>::type,
      typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                      >(
          s, static_cast<DynamicBuffer&&>(buffers),
            static_cast<std::string>(delim),
              init.completion_handler)(boost::system::error_code(), 0, 1);

  return init.result.get();
}




namespace detail
{
  template <typename AsyncReadStream, typename DynamicBuffer,
      typename RegEx, typename ReadHandler>
  class read_until_expr_op
  {
  public:
    template <typename BufferSequence>
    read_until_expr_op(AsyncReadStream& stream,
        BufferSequence&& buffers,
        const boost::regex& expr, ReadHandler& handler)
      : stream_(stream),
        buffers_(static_cast<BufferSequence&&>(buffers)),
        expr_(expr),
        start_(0),
        search_position_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_until_expr_op(const read_until_expr_op& other)
      : stream_(other.stream_),
        buffers_(other.buffers_),
        expr_(other.expr_),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(other.handler_)
    {
    }

    read_until_expr_op(read_until_expr_op&& other)
      : stream_(other.stream_),
        buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
        expr_(other.expr_),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
      std::size_t bytes_to_read;
      switch (start_ = start)
      {
      case 1:
        for (;;)
        {
          {

            typedef typename DynamicBuffer::const_buffers_type
              buffers_type;
            typedef buffers_iterator<buffers_type> iterator;
            buffers_type data_buffers = buffers_.data();
            iterator begin = iterator::begin(data_buffers);
            iterator start_pos = begin + search_position_;
            iterator end = iterator::end(data_buffers);


            boost::match_results<iterator,
              typename std::vector<boost::sub_match<iterator> >::allocator_type>
                match_results;
            bool match = regex_search(start_pos, end, match_results, expr_,
                boost::match_default | boost::match_partial);
            if (match && match_results[0].matched)
            {

              search_position_ = match_results[0].second - begin;
              bytes_to_read = 0;
            }


            else if (buffers_.size() == buffers_.max_size())
            {
              search_position_ = not_found;
              bytes_to_read = 0;
            }


            else
            {
              if (match)
              {


                search_position_ = match_results[0].first - begin;
              }
              else
              {

                search_position_ = end - begin;
              }

              bytes_to_read = std::min<std::size_t>(
                    std::max<std::size_t>(512,
                      buffers_.capacity() - buffers_.size()),
                    std::min<std::size_t>(65536,
                      buffers_.max_size() - buffers_.size()));
            }
          }


          if (!start && bytes_to_read == 0)
            break;


          stream_.async_read_some(buffers_.prepare(bytes_to_read),
              static_cast<read_until_expr_op&&>(*this));
          return; default:
          buffers_.commit(bytes_transferred);
          if (ec || bytes_transferred == 0)
            break;
        }

        const boost::system::error_code result_ec =
          (search_position_ == not_found)
          ? error::not_found : ec;

        const std::size_t result_n =
          (ec || search_position_ == not_found)
          ? 0 : search_position_;

        handler_(result_ec, result_n);
      }
    }


    AsyncReadStream& stream_;
    DynamicBuffer buffers_;
    RegEx expr_;
    int start_;
    std::size_t search_position_;
    ReadHandler handler_;
  };

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename RegEx, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_until_expr_op<AsyncReadStream,
        DynamicBuffer, RegEx, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename RegEx, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_until_expr_op<AsyncReadStream,
        DynamicBuffer, RegEx, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename RegEx, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_until_expr_op<AsyncReadStream,
        DynamicBuffer, RegEx, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename RegEx, typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_until_expr_op<AsyncReadStream,
        DynamicBuffer, RegEx, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename RegEx, typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_until_expr_op<AsyncReadStream,
        DynamicBuffer, RegEx, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename AsyncReadStream, typename DynamicBuffer,
    typename RegEx, typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::read_until_expr_op<AsyncReadStream,
      DynamicBuffer, RegEx, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::read_until_expr_op<AsyncReadStream,
        DynamicBuffer, RegEx, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncReadStream, typename DynamicBuffer,
    typename RegEx, typename ReadHandler, typename Executor>
struct associated_executor<
    detail::read_until_expr_op<AsyncReadStream,
      DynamicBuffer, RegEx, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::read_until_expr_op<AsyncReadStream,
        DynamicBuffer, RegEx, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncReadStream,
    typename DynamicBuffer, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    const boost::regex& expr,
    ReadHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::read_until_expr_op<AsyncReadStream,
    typename decay<DynamicBuffer>::type,
      boost::regex, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                      >(
          s, static_cast<DynamicBuffer&&>(buffers),
            expr, init.completion_handler)(boost::system::error_code(), 0, 1);

  return init.result.get();
}



namespace detail
{
  template <typename AsyncReadStream, typename DynamicBuffer,
      typename MatchCondition, typename ReadHandler>
  class read_until_match_op
  {
  public:
    template <typename BufferSequence>
    read_until_match_op(AsyncReadStream& stream,
        BufferSequence&& buffers,
        MatchCondition match_condition, ReadHandler& handler)
      : stream_(stream),
        buffers_(static_cast<BufferSequence&&>(buffers)),
        match_condition_(match_condition),
        start_(0),
        search_position_(0),
        handler_(static_cast<ReadHandler&&>(handler))
    {
    }


    read_until_match_op(const read_until_match_op& other)
      : stream_(other.stream_),
        buffers_(other.buffers_),
        match_condition_(other.match_condition_),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(other.handler_)
    {
    }

    read_until_match_op(read_until_match_op&& other)
      : stream_(other.stream_),
        buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
        match_condition_(other.match_condition_),
        start_(other.start_),
        search_position_(other.search_position_),
        handler_(static_cast<ReadHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
      std::size_t bytes_to_read;
      switch (start_ = start)
      {
      case 1:
        for (;;)
        {
          {

            typedef typename DynamicBuffer::const_buffers_type
              buffers_type;
            typedef buffers_iterator<buffers_type> iterator;
            buffers_type data_buffers = buffers_.data();
            iterator begin = iterator::begin(data_buffers);
            iterator start_pos = begin + search_position_;
            iterator end = iterator::end(data_buffers);


            std::pair<iterator, bool> result = match_condition_(start_pos, end);
            if (result.second)
            {

              search_position_ = result.first - begin;
              bytes_to_read = 0;
            }


            else if (buffers_.size() == buffers_.max_size())
            {
              search_position_ = not_found;
              bytes_to_read = 0;
            }


            else
            {
              if (result.first != end)
              {


                search_position_ = result.first - begin;
              }
              else
              {

                search_position_ = end - begin;
              }

              bytes_to_read = std::min<std::size_t>(
                    std::max<std::size_t>(512,
                      buffers_.capacity() - buffers_.size()),
                    std::min<std::size_t>(65536,
                      buffers_.max_size() - buffers_.size()));
            }
          }


          if (!start && bytes_to_read == 0)
            break;


          stream_.async_read_some(buffers_.prepare(bytes_to_read),
              static_cast<read_until_match_op&&>(*this));
          return; default:
          buffers_.commit(bytes_transferred);
          if (ec || bytes_transferred == 0)
            break;
        }

        const boost::system::error_code result_ec =
          (search_position_ == not_found)
          ? error::not_found : ec;

        const std::size_t result_n =
          (ec || search_position_ == not_found)
          ? 0 : search_position_;

        handler_(result_ec, result_n);
      }
    }


    AsyncReadStream& stream_;
    DynamicBuffer buffers_;
    MatchCondition match_condition_;
    int start_;
    std::size_t search_position_;
    ReadHandler handler_;
  };

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename MatchCondition, typename ReadHandler>
  inline void* asio_handler_allocate(std::size_t size,
      read_until_match_op<AsyncReadStream, DynamicBuffer,
        MatchCondition, ReadHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename MatchCondition, typename ReadHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      read_until_match_op<AsyncReadStream, DynamicBuffer,
        MatchCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncReadStream, typename DynamicBuffer,
      typename MatchCondition, typename ReadHandler>
  inline bool asio_handler_is_continuation(
      read_until_match_op<AsyncReadStream, DynamicBuffer,
        MatchCondition, ReadHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename MatchCondition,
      typename ReadHandler>
  inline void asio_handler_invoke(Function& function,
      read_until_match_op<AsyncReadStream, DynamicBuffer,
        MatchCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncReadStream,
      typename DynamicBuffer, typename MatchCondition,
      typename ReadHandler>
  inline void asio_handler_invoke(const Function& function,
      read_until_match_op<AsyncReadStream, DynamicBuffer,
      MatchCondition, ReadHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }
}



template <typename AsyncReadStream, typename DynamicBuffer,
    typename MatchCondition, typename ReadHandler, typename Allocator>
struct associated_allocator<
    detail::read_until_match_op<AsyncReadStream,
      DynamicBuffer, MatchCondition, ReadHandler>,
    Allocator>
{
  typedef typename associated_allocator<ReadHandler, Allocator>::type type;

  static type get(
      const detail::read_until_match_op<AsyncReadStream,
        DynamicBuffer, MatchCondition, ReadHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncReadStream, typename DynamicBuffer,
    typename MatchCondition, typename ReadHandler, typename Executor>
struct associated_executor<
    detail::read_until_match_op<AsyncReadStream,
      DynamicBuffer, MatchCondition, ReadHandler>,
    Executor>
{
  typedef typename associated_executor<ReadHandler, Executor>::type type;

  static type get(
      const detail::read_until_match_op<AsyncReadStream,
        DynamicBuffer, MatchCondition, ReadHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncReadStream, typename DynamicBuffer,
    typename MatchCondition, typename ReadHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    DynamicBuffer&& buffers,
    MatchCondition match_condition, ReadHandler&& handler,
    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<ReadHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::read_until_match_op<AsyncReadStream,
    typename decay<DynamicBuffer>::type,
      MatchCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                      >(
          s, static_cast<DynamicBuffer&&>(buffers),
            match_condition, init.completion_handler)(
              boost::system::error_code(), 0, 1);

  return init.result.get();
}



template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    char delim, ReadHandler&& handler)
{
  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
      delim, static_cast<ReadHandler&&>(handler));
}

template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    boost::asio::string_view delim,
    ReadHandler&& handler)
{
  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
      delim, static_cast<ReadHandler&&>(handler));
}



template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
    ReadHandler&& handler)
{
  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
      expr, static_cast<ReadHandler&&>(handler));
}



template <typename AsyncReadStream, typename Allocator,
    typename MatchCondition, typename ReadHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_read_until(AsyncReadStream& s,
    boost::asio::basic_streambuf<Allocator>& b,
    MatchCondition match_condition, ReadHandler&& handler,
    typename enable_if<is_match_condition<MatchCondition>::value>::type*)
{
  return async_read_until(s, basic_streambuf_ref<Allocator>(b),
      match_condition, static_cast<ReadHandler&&>(handler));
}




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 1501 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/read_until.hpp" 2 3 4
# 1825 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/read_until.hpp" 2 3 4
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/seq_packet_socket_service.hpp" 1 3 4
# 115 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 3 4
# 1 "/usr/include/termios.h" 1 3 4
# 35 "/usr/include/termios.h" 3 4
extern "C" {



# 1 "/usr/include/bits/termios.h" 1 3 4
# 23 "/usr/include/bits/termios.h" 3 4
typedef unsigned char cc_t;
typedef unsigned int speed_t;
typedef unsigned int tcflag_t;

# 1 "/usr/include/bits/termios-struct.h" 1 3 4
# 24 "/usr/include/bits/termios-struct.h" 3 4
struct termios
  {
    tcflag_t c_iflag;
    tcflag_t c_oflag;
    tcflag_t c_cflag;
    tcflag_t c_lflag;
    cc_t c_line;
    cc_t c_cc[32];
    speed_t c_ispeed;
    speed_t c_ospeed;


  };
# 28 "/usr/include/bits/termios.h" 2 3 4
# 1 "/usr/include/bits/termios-c_cc.h" 1 3 4
# 29 "/usr/include/bits/termios.h" 2 3 4
# 1 "/usr/include/bits/termios-c_iflag.h" 1 3 4
# 30 "/usr/include/bits/termios.h" 2 3 4
# 1 "/usr/include/bits/termios-c_oflag.h" 1 3 4
# 31 "/usr/include/bits/termios.h" 2 3 4
# 53 "/usr/include/bits/termios.h" 3 4
# 1 "/usr/include/bits/termios-baud.h" 1 3 4
# 54 "/usr/include/bits/termios.h" 2 3 4

# 1 "/usr/include/bits/termios-c_cflag.h" 1 3 4
# 56 "/usr/include/bits/termios.h" 2 3 4
# 1 "/usr/include/bits/termios-c_lflag.h" 1 3 4
# 57 "/usr/include/bits/termios.h" 2 3 4
# 74 "/usr/include/bits/termios.h" 3 4
# 1 "/usr/include/bits/termios-tcflow.h" 1 3 4
# 75 "/usr/include/bits/termios.h" 2 3 4

# 1 "/usr/include/bits/termios-misc.h" 1 3 4
# 77 "/usr/include/bits/termios.h" 2 3 4
# 40 "/usr/include/termios.h" 2 3 4
# 48 "/usr/include/termios.h" 3 4
extern speed_t cfgetospeed (const struct termios *__termios_p) throw ();


extern speed_t cfgetispeed (const struct termios *__termios_p) throw ();


extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) throw ();


extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) throw ();



extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) throw ();




extern int tcgetattr (int __fd, struct termios *__termios_p) throw ();



extern int tcsetattr (int __fd, int __optional_actions,
        const struct termios *__termios_p) throw ();




extern void cfmakeraw (struct termios *__termios_p) throw ();



extern int tcsendbreak (int __fd, int __duration) throw ();





extern int tcdrain (int __fd);



extern int tcflush (int __fd, int __queue_selector) throw ();



extern int tcflow (int __fd, int __action) throw ();




extern __pid_t tcgetsid (int __fd) throw ();




# 1 "/usr/include/sys/ttydefaults.h" 1 3 4
# 105 "/usr/include/termios.h" 2 3 4


}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 2 3 4
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 2 3 4

namespace boost {
namespace asio {



class serial_port_base
{
public:




  class baud_rate
  {
  public:
    explicit baud_rate(unsigned int rate = 0);
    unsigned int value() const;
    inline boost::system::error_code store(
        termios& storage,
        boost::system::error_code& ec) const;
    inline boost::system::error_code load(
        const termios& storage,
        boost::system::error_code& ec);
  private:
    unsigned int value_;
  };





  class flow_control
  {
  public:
    enum type { none, software, hardware };
    inline explicit flow_control(type t = none);
    type value() const;
    inline boost::system::error_code store(
        termios& storage,
        boost::system::error_code& ec) const;
    inline boost::system::error_code load(
        const termios& storage,
        boost::system::error_code& ec);
  private:
    type value_;
  };





  class parity
  {
  public:
    enum type { none, odd, even };
    inline explicit parity(type t = none);
    type value() const;
    inline boost::system::error_code store(
        termios& storage,
        boost::system::error_code& ec) const;
    inline boost::system::error_code load(
        const termios& storage,
        boost::system::error_code& ec);
  private:
    type value_;
  };





  class stop_bits
  {
  public:
    enum type { one, onepointfive, two };
    inline explicit stop_bits(type t = one);
    type value() const;
    inline boost::system::error_code store(
        termios& storage,
        boost::system::error_code& ec) const;
    inline boost::system::error_code load(
        const termios& storage,
        boost::system::error_code& ec);
  private:
    type value_;
  };





  class character_size
  {
  public:
    inline explicit character_size(unsigned int t = 8);
    unsigned int value() const;
    inline boost::system::error_code store(
        termios& storage,
        boost::system::error_code& ec) const;
    inline boost::system::error_code load(
        const termios& storage,
        boost::system::error_code& ec);
  private:
    unsigned int value_;
  };

protected:

  ~serial_port_base()
  {
  }
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 158 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.hpp" 2 3 4

namespace boost {
namespace asio {

inline serial_port_base::baud_rate::baud_rate(unsigned int rate)
  : value_(rate)
{
}

inline unsigned int serial_port_base::baud_rate::value() const
{
  return value_;
}

inline serial_port_base::flow_control::type
serial_port_base::flow_control::value() const
{
  return value_;
}

inline serial_port_base::parity::type serial_port_base::parity::value() const
{
  return value_;
}

inline serial_port_base::stop_bits::type
serial_port_base::stop_bits::value() const
{
  return value_;
}

inline unsigned int serial_port_base::character_size::value() const
{
  return value_;
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 60 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.hpp" 2 3 4
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 2 3 4

namespace boost {
namespace asio {

boost::system::error_code serial_port_base::baud_rate::store(
    termios& storage, boost::system::error_code& ec) const
{



  speed_t baud;
  switch (value_)
  {

  case 0: baud = 0000000; break;
  case 50: baud = 0000001; break;
  case 75: baud = 0000002; break;
  case 110: baud = 0000003; break;
  case 134: baud = 0000004; break;
  case 150: baud = 0000005; break;
  case 200: baud = 0000006; break;
  case 300: baud = 0000007; break;
  case 600: baud = 0000010; break;
  case 1200: baud = 0000011; break;
  case 1800: baud = 0000012; break;
  case 2400: baud = 0000013; break;
  case 4800: baud = 0000014; break;
  case 9600: baud = 0000015; break;
  case 19200: baud = 0000016; break;
  case 38400: baud = 0000017; break;
# 75 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  case 57600: baud = 0010001; break;


  case 115200: baud = 0010002; break;


  case 230400: baud = 0010003; break;


  case 460800: baud = 0010004; break;


  case 500000: baud = 0010005; break;


  case 576000: baud = 0010006; break;


  case 921600: baud = 0010007; break;


  case 1000000: baud = 0010010; break;


  case 1152000: baud = 0010011; break;


  case 2000000: baud = 0010013; break;


  case 3000000: baud = 0010015; break;


  case 3500000: baud = 0010016; break;


  case 4000000: baud = 0010017; break;

  default:
    ec = boost::asio::error::invalid_argument;
    return ec;
  }

  ::cfsetspeed(&storage, baud);





  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code serial_port_base::baud_rate::load(
    const termios& storage, boost::system::error_code& ec)
{



  speed_t baud = ::cfgetospeed(&storage);
  switch (baud)
  {

  case 0000000: value_ = 0; break;
  case 0000001: value_ = 50; break;
  case 0000002: value_ = 75; break;
  case 0000003: value_ = 110; break;
  case 0000004: value_ = 134; break;
  case 0000005: value_ = 150; break;
  case 0000006: value_ = 200; break;
  case 0000007: value_ = 300; break;
  case 0000010: value_ = 600; break;
  case 0000011: value_ = 1200; break;
  case 0000012: value_ = 1800; break;
  case 0000013: value_ = 2400; break;
  case 0000014: value_ = 4800; break;
  case 0000015: value_ = 9600; break;
  case 0000016: value_ = 19200; break;
  case 0000017: value_ = 38400; break;
# 162 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  case 0010001: value_ = 57600; break;


  case 0010002: value_ = 115200; break;


  case 0010003: value_ = 230400; break;


  case 0010004: value_ = 460800; break;


  case 0010005: value_ = 500000; break;


  case 0010006: value_ = 576000; break;


  case 0010007: value_ = 921600; break;


  case 0010010: value_ = 1000000; break;


  case 0010011: value_ = 1152000; break;


  case 0010013: value_ = 2000000; break;


  case 0010015: value_ = 3000000; break;


  case 0010016: value_ = 3500000; break;


  case 0010017: value_ = 4000000; break;

  default:
    value_ = 0;
    ec = boost::asio::error::invalid_argument;
    return ec;
  }

  ec = boost::system::error_code();
  return ec;
}

serial_port_base::flow_control::flow_control(
    serial_port_base::flow_control::type t)
  : value_(t)
{
  if (t != none && t != software && t != hardware)
  {
    std::out_of_range ex("invalid flow_control value");
    boost::asio::detail::throw_exception(ex);
  }
}

boost::system::error_code serial_port_base::flow_control::store(
    termios& storage, boost::system::error_code& ec) const
{
# 249 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  switch (value_)
  {
  case none:
    storage.c_iflag &= ~(0010000 | 0002000);

    storage.c_cflag &= ~020000000000;



    break;
  case software:
    storage.c_iflag |= 0010000 | 0002000;

    storage.c_cflag &= ~020000000000;



    break;
  case hardware:

    storage.c_iflag &= ~(0010000 | 0002000);
    storage.c_cflag |= 020000000000;
    break;
# 280 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  default:
    break;
  }

  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code serial_port_base::flow_control::load(
    const termios& storage, boost::system::error_code& ec)
{
# 305 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  if (storage.c_iflag & (0010000 | 0002000))
  {
    value_ = software;
  }

  else if (storage.c_cflag & 020000000000)
  {
    value_ = hardware;
  }






  else
  {
    value_ = none;
  }

  ec = boost::system::error_code();
  return ec;
}

serial_port_base::parity::parity(serial_port_base::parity::type t)
  : value_(t)
{
  if (t != none && t != odd && t != even)
  {
    std::out_of_range ex("invalid parity value");
    boost::asio::detail::throw_exception(ex);
  }
}

boost::system::error_code serial_port_base::parity::store(
    termios& storage, boost::system::error_code& ec) const
{
# 361 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  switch (value_)
  {
  case none:
    storage.c_iflag |= 0000004;
    storage.c_cflag &= ~(0000400 | 0001000);
    break;
  case even:
    storage.c_iflag &= ~(0000004 | 0000010);
    storage.c_iflag |= 0000020;
    storage.c_cflag |= 0000400;
    storage.c_cflag &= ~0001000;
    break;
  case odd:
    storage.c_iflag &= ~(0000004 | 0000010);
    storage.c_iflag |= 0000020;
    storage.c_cflag |= (0000400 | 0001000);
    break;
  default:
    break;
  }

  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code serial_port_base::parity::load(
    const termios& storage, boost::system::error_code& ec)
{
# 403 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  if (storage.c_cflag & 0000400)
  {
    if (storage.c_cflag & 0001000)
    {
      value_ = odd;
    }
    else
    {
      value_ = even;
    }
  }
  else
  {
    value_ = none;
  }

  ec = boost::system::error_code();
  return ec;
}

serial_port_base::stop_bits::stop_bits(
    serial_port_base::stop_bits::type t)
  : value_(t)
{
  if (t != one && t != onepointfive && t != two)
  {
    std::out_of_range ex("invalid stop_bits value");
    boost::asio::detail::throw_exception(ex);
  }
}

boost::system::error_code serial_port_base::stop_bits::store(
    termios& storage, boost::system::error_code& ec) const
{
# 453 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  switch (value_)
  {
  case one:
    storage.c_cflag &= ~0000100;
    break;
  case two:
    storage.c_cflag |= 0000100;
    break;
  default:
    ec = boost::asio::error::operation_not_supported;
    return ec;
  }

  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code serial_port_base::stop_bits::load(
    const termios& storage, boost::system::error_code& ec)
{
# 491 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 3 4
  value_ = (storage.c_cflag & 0000100) ? two : one;

  ec = boost::system::error_code();
  return ec;
}

serial_port_base::character_size::character_size(unsigned int t)
  : value_(t)
{
  if (t < 5 || t > 8)
  {
    std::out_of_range ex("invalid character_size value");
    boost::asio::detail::throw_exception(ex);
  }
}

boost::system::error_code serial_port_base::character_size::store(
    termios& storage, boost::system::error_code& ec) const
{



  storage.c_cflag &= ~0000060;
  switch (value_)
  {
  case 5: storage.c_cflag |= 0000000; break;
  case 6: storage.c_cflag |= 0000020; break;
  case 7: storage.c_cflag |= 0000040; break;
  case 8: storage.c_cflag |= 0000060; break;
  default: break;
  }

  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code serial_port_base::character_size::load(
    const termios& storage, boost::system::error_code& ec)
{



  if ((storage.c_cflag & 0000060) == 0000000) { value_ = 5; }
  else if ((storage.c_cflag & 0000060) == 0000020) { value_ = 6; }
  else if ((storage.c_cflag & 0000060) == 0000040) { value_ = 7; }
  else if ((storage.c_cflag & 0000060) == 0000060) { value_ = 8; }
  else
  {

    value_ = 8;
  }

  ec = boost::system::error_code();
  return ec;
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 551 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
# 164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_base.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 2 3 4
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_serial_port_service.hpp" 1 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_serial_port_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


class reactive_serial_port_service :
  public service_base<reactive_serial_port_service>
{
public:

  typedef reactive_descriptor_service::native_handle_type native_handle_type;


  typedef reactive_descriptor_service::implementation_type implementation_type;

  inline reactive_serial_port_service(
      boost::asio::io_context& io_context);


  inline void shutdown();


  void construct(implementation_type& impl)
  {
    descriptor_service_.construct(impl);
  }


  void move_construct(implementation_type& impl,
      implementation_type& other_impl)
  {
    descriptor_service_.move_construct(impl, other_impl);
  }


  void move_assign(implementation_type& impl,
      reactive_serial_port_service& other_service,
      implementation_type& other_impl)
  {
    descriptor_service_.move_assign(impl,
        other_service.descriptor_service_, other_impl);
  }


  void destroy(implementation_type& impl)
  {
    descriptor_service_.destroy(impl);
  }


  inline boost::system::error_code open(implementation_type& impl,
      const std::string& device, boost::system::error_code& ec);


  boost::system::error_code assign(implementation_type& impl,
      const native_handle_type& native_descriptor,
      boost::system::error_code& ec)
  {
    return descriptor_service_.assign(impl, native_descriptor, ec);
  }


  bool is_open(const implementation_type& impl) const
  {
    return descriptor_service_.is_open(impl);
  }


  boost::system::error_code close(implementation_type& impl,
      boost::system::error_code& ec)
  {
    return descriptor_service_.close(impl, ec);
  }


  native_handle_type native_handle(implementation_type& impl)
  {
    return descriptor_service_.native_handle(impl);
  }


  boost::system::error_code cancel(implementation_type& impl,
      boost::system::error_code& ec)
  {
    return descriptor_service_.cancel(impl, ec);
  }


  template <typename SettableSerialPortOption>
  boost::system::error_code set_option(implementation_type& impl,
      const SettableSerialPortOption& option, boost::system::error_code& ec)
  {
    return do_set_option(impl,
        &reactive_serial_port_service::store_option<SettableSerialPortOption>,
        &option, ec);
  }


  template <typename GettableSerialPortOption>
  boost::system::error_code get_option(const implementation_type& impl,
      GettableSerialPortOption& option, boost::system::error_code& ec) const
  {
    return do_get_option(impl,
        &reactive_serial_port_service::load_option<GettableSerialPortOption>,
        &option, ec);
  }


  boost::system::error_code send_break(implementation_type& impl,
      boost::system::error_code& ec)
  {
    (*__errno_location ()) = 0;
    descriptor_ops::error_wrapper(::tcsendbreak(
          descriptor_service_.native_handle(impl), 0), ec);
    return ec;
  }


  template <typename ConstBufferSequence>
  size_t write_some(implementation_type& impl,
      const ConstBufferSequence& buffers, boost::system::error_code& ec)
  {
    return descriptor_service_.write_some(impl, buffers, ec);
  }



  template <typename ConstBufferSequence, typename Handler>
  void async_write_some(implementation_type& impl,
      const ConstBufferSequence& buffers, Handler& handler)
  {
    descriptor_service_.async_write_some(impl, buffers, handler);
  }


  template <typename MutableBufferSequence>
  size_t read_some(implementation_type& impl,
      const MutableBufferSequence& buffers, boost::system::error_code& ec)
  {
    return descriptor_service_.read_some(impl, buffers, ec);
  }



  template <typename MutableBufferSequence, typename Handler>
  void async_read_some(implementation_type& impl,
      const MutableBufferSequence& buffers, Handler& handler)
  {
    descriptor_service_.async_read_some(impl, buffers, handler);
  }

private:

  typedef boost::system::error_code (*store_function_type)(
      const void*, termios&, boost::system::error_code&);


  template <typename SettableSerialPortOption>
  static boost::system::error_code store_option(const void* option,
      termios& storage, boost::system::error_code& ec)
  {
    static_cast<const SettableSerialPortOption*>(option)->store(storage, ec);
    return ec;
  }


  inline boost::system::error_code do_set_option(
      implementation_type& impl, store_function_type store,
      const void* option, boost::system::error_code& ec);


  typedef boost::system::error_code (*load_function_type)(
      void*, const termios&, boost::system::error_code&);


  template <typename GettableSerialPortOption>
  static boost::system::error_code load_option(void* option,
      const termios& storage, boost::system::error_code& ec)
  {
    static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
    return ec;
  }


  inline boost::system::error_code do_get_option(
      const implementation_type& impl, load_function_type load,
      void* option, boost::system::error_code& ec) const;


  reactive_descriptor_service descriptor_service_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 230 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_serial_port_service.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

reactive_serial_port_service::reactive_serial_port_service(
    boost::asio::io_context& io_context)
  : service_base<reactive_serial_port_service>(io_context),
    descriptor_service_(io_context)
{
}

void reactive_serial_port_service::shutdown()
{
  descriptor_service_.shutdown();
}

boost::system::error_code reactive_serial_port_service::open(
    reactive_serial_port_service::implementation_type& impl,
    const std::string& device, boost::system::error_code& ec)
{
  if (is_open(impl))
  {
    ec = boost::asio::error::already_open;
    return ec;
  }

  descriptor_ops::state_type state = 0;
  int fd = descriptor_ops::open(device.c_str(),
      02 | 04000 | 0400, ec);
  if (fd < 0)
    return ec;

  int s = descriptor_ops::fcntl(fd, 3, ec);
  if (s >= 0)
    s = descriptor_ops::fcntl(fd, 4, s | 04000, ec);
  if (s < 0)
  {
    boost::system::error_code ignored_ec;
    descriptor_ops::close(fd, state, ignored_ec);
    return ec;
  }


  termios ios;
  (*__errno_location ()) = 0;
  s = descriptor_ops::error_wrapper(::tcgetattr(fd, &ios), ec);
  if (s >= 0)
  {

    ::cfmakeraw(&ios);
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 3 4
    ios.c_iflag |= 0000004;
    ios.c_cflag |= 0000200 | 0004000;
    (*__errno_location ()) = 0;
    s = descriptor_ops::error_wrapper(::tcsetattr(fd, 0, &ios), ec);
  }
  if (s < 0)
  {
    boost::system::error_code ignored_ec;
    descriptor_ops::close(fd, state, ignored_ec);
    return ec;
  }


  if (descriptor_service_.assign(impl, fd, ec))
  {
    boost::system::error_code ignored_ec;
    descriptor_ops::close(fd, state, ignored_ec);
  }

  return ec;
}

boost::system::error_code reactive_serial_port_service::do_set_option(
    reactive_serial_port_service::implementation_type& impl,
    reactive_serial_port_service::store_function_type store,
    const void* option, boost::system::error_code& ec)
{
  termios ios;
  (*__errno_location ()) = 0;
  descriptor_ops::error_wrapper(::tcgetattr(
        descriptor_service_.native_handle(impl), &ios), ec);
  if (ec)
    return ec;

  if (store(option, ios, ec))
    return ec;

  (*__errno_location ()) = 0;
  descriptor_ops::error_wrapper(::tcsetattr(
        descriptor_service_.native_handle(impl), 0, &ios), ec);
  return ec;
}

boost::system::error_code reactive_serial_port_service::do_get_option(
    const reactive_serial_port_service::implementation_type& impl,
    reactive_serial_port_service::load_function_type load,
    void* option, boost::system::error_code& ec) const
{
  termios ios;
  (*__errno_location ()) = 0;
  descriptor_ops::error_wrapper(::tcgetattr(
        descriptor_service_.native_handle(impl), &ios), ec);
  if (ec)
    return ec;

  return load(option, ios, ec);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
# 233 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
# 45 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 2 3 4

namespace boost {
namespace asio {
# 66 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
class serial_port
  : protected basic_io_object<detail::reactive_serial_port_service>,
    public serial_port_base
{
public:

  typedef io_context::executor_type executor_type;





  typedef detail::reactive_serial_port_service::native_handle_type native_handle_type;



  typedef serial_port lowest_layer_type;
# 91 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  explicit serial_port(boost::asio::io_context& io_context)
    : basic_io_object<detail::reactive_serial_port_service>(io_context)
  {
  }
# 107 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  explicit serial_port(boost::asio::io_context& io_context,
      const char* device)
    : basic_io_object<detail::reactive_serial_port_service>(io_context)
  {
    boost::system::error_code ec;
    this->get_service().open(this->get_implementation(), device, ec);
    boost::asio::detail::throw_error(ec, "open");
  }
# 127 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  explicit serial_port(boost::asio::io_context& io_context,
      const std::string& device)
    : basic_io_object<detail::reactive_serial_port_service>(io_context)
  {
    boost::system::error_code ec;
    this->get_service().open(this->get_implementation(), device, ec);
    boost::asio::detail::throw_error(ec, "open");
  }
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  serial_port(boost::asio::io_context& io_context,
      const native_handle_type& native_serial_port)
    : basic_io_object<detail::reactive_serial_port_service>(io_context)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        native_serial_port, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 169 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  serial_port(serial_port&& other)
    : basic_io_object<detail::reactive_serial_port_service>(std::move(other))
  {
  }
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  serial_port& operator=(serial_port&& other)
  {
    basic_io_object<detail::reactive_serial_port_service>::operator=(std::move(other));
    return *this;
  }
# 197 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  ~serial_port()
  {
  }
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<detail::reactive_serial_port_service>::get_io_context();
  }
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<detail::reactive_serial_port_service>::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<detail::reactive_serial_port_service>::get_executor();
  }
# 246 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  lowest_layer_type& lowest_layer()
  {
    return *this;
  }
# 260 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  const lowest_layer_type& lowest_layer() const
  {
    return *this;
  }
# 273 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  void open(const std::string& device)
  {
    boost::system::error_code ec;
    this->get_service().open(this->get_implementation(), device, ec);
    boost::asio::detail::throw_error(ec, "open");
  }
# 289 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  boost::system::error_code open(const std::string& device,
      boost::system::error_code& ec)
  {
    this->get_service().open(this->get_implementation(), device, ec);
    return ec;
  }
# 304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  void assign(const native_handle_type& native_serial_port)
  {
    boost::system::error_code ec;
    this->get_service().assign(this->get_implementation(),
        native_serial_port, ec);
    boost::asio::detail::throw_error(ec, "assign");
  }
# 320 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  boost::system::error_code assign(const native_handle_type& native_serial_port,
      boost::system::error_code& ec)
  {
    this->get_service().assign(this->get_implementation(),
        native_serial_port, ec);
    return ec;
  }


  bool is_open() const
  {
    return this->get_service().is_open(this->get_implementation());
  }
# 342 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  void close()
  {
    boost::system::error_code ec;
    this->get_service().close(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "close");
  }
# 357 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  boost::system::error_code close(boost::system::error_code& ec)
  {
    this->get_service().close(this->get_implementation(), ec);
    return ec;
  }







  native_handle_type native_handle()
  {
    return this->get_service().native_handle(this->get_implementation());
  }
# 382 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  void cancel()
  {
    boost::system::error_code ec;
    this->get_service().cancel(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel");
  }
# 397 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  boost::system::error_code cancel(boost::system::error_code& ec)
  {
    this->get_service().cancel(this->get_implementation(), ec);
    return ec;
  }
# 410 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  void send_break()
  {
    boost::system::error_code ec;
    this->get_service().send_break(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "send_break");
  }
# 424 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  boost::system::error_code send_break(boost::system::error_code& ec)
  {
    this->get_service().send_break(this->get_implementation(), ec);
    return ec;
  }
# 445 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename SettableSerialPortOption>
  void set_option(const SettableSerialPortOption& option)
  {
    boost::system::error_code ec;
    this->get_service().set_option(this->get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, "set_option");
  }
# 468 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename SettableSerialPortOption>
  boost::system::error_code set_option(const SettableSerialPortOption& option,
      boost::system::error_code& ec)
  {
    this->get_service().set_option(this->get_implementation(), option, ec);
    return ec;
  }
# 492 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename GettableSerialPortOption>
  void get_option(GettableSerialPortOption& option)
  {
    boost::system::error_code ec;
    this->get_service().get_option(this->get_implementation(), option, ec);
    boost::asio::detail::throw_error(ec, "get_option");
  }
# 516 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename GettableSerialPortOption>
  boost::system::error_code get_option(GettableSerialPortOption& option,
      boost::system::error_code& ec)
  {
    this->get_service().get_option(this->get_implementation(), option, ec);
    return ec;
  }
# 551 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().write_some(
        this->get_implementation(), buffers, ec);
    boost::asio::detail::throw_error(ec, "write_some");
    return s;
  }
# 577 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return this->get_service().write_some(
        this->get_implementation(), buffers, ec);
  }
# 620 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename ConstBufferSequence, typename WriteHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_write_some(const ConstBufferSequence& buffers,
      WriteHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

    async_completion<WriteHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_write_some(
        this->get_implementation(), buffers, init.completion_handler);

    return init.result.get();
  }
# 667 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    boost::system::error_code ec;
    std::size_t s = this->get_service().read_some(
        this->get_implementation(), buffers, ec);
    boost::asio::detail::throw_error(ec, "read_some");
    return s;
  }
# 694 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return this->get_service().read_some(
        this->get_implementation(), buffers, ec);
  }
# 738 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 3 4
  template <typename MutableBufferSequence, typename ReadHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

  async_read_some(const MutableBufferSequence& buffers,
      ReadHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

    async_completion<ReadHandler,
      void (boost::system::error_code, std::size_t)> init(handler);

    this->get_service().async_read_some(
        this->get_implementation(), buffers, init.completion_handler);

    return init.result.get();
  }
};


}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 763 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port.hpp" 2 3 4
# 116 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/serial_port_service.hpp" 1 3 4
# 118 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 1 3 4
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_set_service.hpp" 1 3 4
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_set_service.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_handler.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_handler.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_op.hpp" 1 3 4
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_op.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_op.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class signal_op
  : public operation
{
public:

  boost::system::error_code ec_;


  int signal_number_;

protected:
  signal_op(func_type func)
    : operation(func),
      signal_number_(0)
  {
  }
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_op.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_handler.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_handler.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Handler>
class signal_handler : public signal_op
{
public:
  struct ptr { Handler* h; signal_handler* v; signal_handler* p; ~ptr() { reset(); } static signal_handler* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<signal_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~signal_handler(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<signal_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<signal_handler*>(v), 1); v = 0; } } };

  signal_handler(Handler& h)
    : signal_op(&signal_handler::do_complete),
      handler_(static_cast<Handler&&>(h))
  {
    handler_work<Handler>::start(handler_);
  }

  static void do_complete(void* owner, operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {

    signal_handler* h(static_cast<signal_handler*>(base));
    ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
    handler_work<Handler> w(h->handler_);

    (void)0;







    detail::binder2<Handler, boost::system::error_code, int>
      handler(h->handler_, h->ec_, h->signal_number_);
    p.h = boost::asio::detail::addressof(handler.handler_);
    p.reset();


    if (owner)
    {
      fenced_block b(fenced_block::half);
      (void)0;
      w.complete(handler, handler.handler_);
      (void)0;
    }
  }

private:
  Handler handler_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 87 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_handler.hpp" 2 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_set_service.hpp" 2 3 4







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_set_service.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {


enum { max_signal_number = (64 + 1) };




extern inline struct signal_state* get_signal_state();

extern "C" inline void boost_asio_signal_handler(int signal_number);

class signal_set_service :
  public service_base<signal_set_service>
{
public:

  class registration
  {
  public:

    registration()
      : signal_number_(0),
        queue_(0),
        undelivered_(0),
        next_in_table_(0),
        prev_in_table_(0),
        next_in_set_(0)
    {
    }

  private:

    friend class signal_set_service;


    int signal_number_;


    op_queue<signal_op>* queue_;


    std::size_t undelivered_;


    registration* next_in_table_;
    registration* prev_in_table_;


    registration* next_in_set_;
  };


  class implementation_type
  {
  public:

    implementation_type()
      : signals_(0)
    {
    }

  private:

    friend class signal_set_service;


    op_queue<signal_op> queue_;


    registration* signals_;
  };


  inline signal_set_service(boost::asio::io_context& io_context);


  inline ~signal_set_service();


  inline void shutdown();


  inline void notify_fork(
      boost::asio::io_context::fork_event fork_ev);


  inline void construct(implementation_type& impl);


  inline void destroy(implementation_type& impl);


  inline boost::system::error_code add(implementation_type& impl,
      int signal_number, boost::system::error_code& ec);


  inline boost::system::error_code remove(implementation_type& impl,
      int signal_number, boost::system::error_code& ec);


  inline boost::system::error_code clear(implementation_type& impl,
      boost::system::error_code& ec);


  inline boost::system::error_code cancel(implementation_type& impl,
      boost::system::error_code& ec);


  template <typename Handler>
  void async_wait(implementation_type& impl, Handler& handler)
  {

    typedef signal_handler<Handler> op;
    typename op::ptr p = { boost::asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(handler);

    (void)0
                                                      ;

    start_wait_op(impl, p.p);
    p.v = p.p = 0;
  }


  inline static void deliver_signal(int signal_number);

private:

  inline static void add_service(signal_set_service* service);


  inline static void remove_service(signal_set_service* service);


  inline static void open_descriptors();


  inline static void close_descriptors();


  inline void start_wait_op(implementation_type& impl, signal_op* op);


  io_context_impl& io_context_;





  class pipe_read_op;


  reactor& reactor_;


  reactor::per_descriptor_data reactor_data_;





  registration* registrations_[max_signal_number];


  signal_set_service* next_;
  signal_set_service* prev_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 214 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_set_service.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 3 4
# 1 "/usr/include/c++/10/cstring" 1 3 4
# 39 "/usr/include/c++/10/cstring" 3 4
       
# 40 "/usr/include/c++/10/cstring" 3
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_blocker.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_blocker.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_signal_blocker.hpp" 1 3 4
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_signal_blocker.hpp" 3 4
# 1 "/usr/include/c++/10/csignal" 1 3 4
# 39 "/usr/include/c++/10/csignal" 3 4
       
# 40 "/usr/include/c++/10/csignal" 3
# 50 "/usr/include/c++/10/csignal" 3
namespace std
{
  using ::sig_atomic_t;
  using ::signal;
  using ::raise;
}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

class posix_signal_blocker
  : private noncopyable
{
public:

  posix_signal_blocker()
    : blocked_(false)
  {
    sigset_t new_mask;
    sigfillset(&new_mask);
    blocked_ = (pthread_sigmask(0, &new_mask, &old_mask_) == 0);
  }


  ~posix_signal_blocker()
  {
    if (blocked_)
      pthread_sigmask(2, &old_mask_, 0);
  }


  void block()
  {
    if (!blocked_)
    {
      sigset_t new_mask;
      sigfillset(&new_mask);
      blocked_ = (pthread_sigmask(0, &new_mask, &old_mask_) == 0);
    }
  }


  void unblock()
  {
    if (blocked_)
      blocked_ = (pthread_sigmask(2, &old_mask_, 0) != 0);
  }

private:

  bool blocked_;


  sigset_t old_mask_;
};

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_blocker.hpp" 2 3 4




namespace boost {
namespace asio {
namespace detail {






typedef posix_signal_blocker signal_blocker;


}
}
}
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_set_service.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/static_mutex.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/static_mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_static_mutex.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_static_mutex.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_static_mutex.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct posix_static_mutex
{
  typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;


  void init()
  {

  }


  void lock()
  {
    (void)::pthread_mutex_lock(&mutex_);
  }


  void unlock()
  {
    (void)::pthread_mutex_unlock(&mutex_);
  }

  ::pthread_mutex_t mutex_;
};



}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 63 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/posix_static_mutex.hpp" 2 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/static_mutex.hpp" 2 3 4






namespace boost {
namespace asio {
namespace detail {
# 43 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/static_mutex.hpp" 3 4
typedef posix_static_mutex static_mutex;






}
}
}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

struct signal_state
{

  static_mutex mutex_;


  int read_descriptor_;


  int write_descriptor_;


  bool fork_prepared_;


  class signal_set_service* service_list_;


  std::size_t registration_count_[max_signal_number];
};

signal_state* get_signal_state()
{
  static signal_state state = {
    { { { 0, 0, 0, 0, PTHREAD_MUTEX_DEFAULT, 0, 0, { 0, 0 } } } }, -1, -1, false, 0, { 0 } };
  return &state;
}

void boost_asio_signal_handler(int signal_number)
{







  int saved_errno = (*__errno_location ());
  signal_state* state = get_signal_state();
  signed_size_type result = ::write(state->write_descriptor_,
      &signal_number, sizeof(signal_number));
  (void)result;
  (*__errno_location ()) = saved_errno;







}




class signal_set_service::pipe_read_op : public reactor_op
{
public:
  pipe_read_op()
    : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete)
  {
  }

  static status do_perform(reactor_op*)
  {
    signal_state* state = get_signal_state();

    int fd = state->read_descriptor_;
    int signal_number = 0;
    while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
      if (signal_number >= 0 && signal_number < max_signal_number)
        signal_set_service::deliver_signal(signal_number);

    return not_done;
  }

  static void do_complete(void* , operation* base,
      const boost::system::error_code& ,
      std::size_t )
  {
    pipe_read_op* o(static_cast<pipe_read_op*>(base));
    delete o;
  }
};




signal_set_service::signal_set_service(
    boost::asio::io_context& io_context)
  : service_base<signal_set_service>(io_context),
    io_context_(boost::asio::use_service<io_context_impl>(io_context)),



    reactor_(boost::asio::use_service<reactor>(io_context)),



    next_(0),
    prev_(0)
{
  get_signal_state()->mutex_.init();




  reactor_.init_task();




  for (int i = 0; i < max_signal_number; ++i)
    registrations_[i] = 0;

  add_service(this);
}

signal_set_service::~signal_set_service()
{
  remove_service(this);
}

void signal_set_service::shutdown()
{
  remove_service(this);

  op_queue<operation> ops;

  for (int i = 0; i < max_signal_number; ++i)
  {
    registration* reg = registrations_[i];
    while (reg)
    {
      ops.push(*reg->queue_);
      reg = reg->next_in_table_;
    }
  }

  io_context_.abandon_operations(ops);
}

void signal_set_service::notify_fork(
    boost::asio::io_context::fork_event fork_ev)
{



  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);

  switch (fork_ev)
  {
  case boost::asio::io_context::fork_prepare:
    {
      int read_descriptor = state->read_descriptor_;
      state->fork_prepared_ = true;
      lock.unlock();
      reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
      reactor_.cleanup_descriptor_data(reactor_data_);
    }
    break;
  case boost::asio::io_context::fork_parent:
    if (state->fork_prepared_)
    {
      int read_descriptor = state->read_descriptor_;
      state->fork_prepared_ = false;
      lock.unlock();
      reactor_.register_internal_descriptor(reactor::read_op,
          read_descriptor, reactor_data_, new pipe_read_op);
    }
    break;
  case boost::asio::io_context::fork_child:
    if (state->fork_prepared_)
    {
      boost::asio::detail::signal_blocker blocker;
      close_descriptors();
      open_descriptors();
      int read_descriptor = state->read_descriptor_;
      state->fork_prepared_ = false;
      lock.unlock();
      reactor_.register_internal_descriptor(reactor::read_op,
          read_descriptor, reactor_data_, new pipe_read_op);
    }
    break;
  default:
    break;
  }







}

void signal_set_service::construct(
    signal_set_service::implementation_type& impl)
{
  impl.signals_ = 0;
}

void signal_set_service::destroy(
    signal_set_service::implementation_type& impl)
{
  boost::system::error_code ignored_ec;
  clear(impl, ignored_ec);
  cancel(impl, ignored_ec);
}

boost::system::error_code signal_set_service::add(
    signal_set_service::implementation_type& impl,
    int signal_number, boost::system::error_code& ec)
{

  if (signal_number < 0 || signal_number >= max_signal_number)
  {
    ec = boost::asio::error::invalid_argument;
    return ec;
  }

  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);


  registration** insertion_point = &impl.signals_;
  registration* next = impl.signals_;
  while (next && next->signal_number_ < signal_number)
  {
    insertion_point = &next->next_in_set_;
    next = next->next_in_set_;
  }


  if (next == 0 || next->signal_number_ != signal_number)
  {
    registration* new_registration = new registration;



    if (state->registration_count_[signal_number] == 0)
    {

      using namespace std;
      struct sigaction sa;
      memset(&sa, 0, sizeof(sa));
      sa.__sigaction_handler.sa_handler = boost_asio_signal_handler;
      sigfillset(&sa.sa_mask);
      if (::sigaction(signal_number, &sa, 0) == -1)



      {



        ec = boost::system::error_code((*__errno_location ()),
            boost::asio::error::get_system_category());

        delete new_registration;
        return ec;
      }
    }



    new_registration->signal_number_ = signal_number;
    new_registration->queue_ = &impl.queue_;
    new_registration->next_in_set_ = next;
    *insertion_point = new_registration;


    new_registration->next_in_table_ = registrations_[signal_number];
    if (registrations_[signal_number])
      registrations_[signal_number]->prev_in_table_ = new_registration;
    registrations_[signal_number] = new_registration;

    ++state->registration_count_[signal_number];
  }

  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code signal_set_service::remove(
    signal_set_service::implementation_type& impl,
    int signal_number, boost::system::error_code& ec)
{

  if (signal_number < 0 || signal_number >= max_signal_number)
  {
    ec = boost::asio::error::invalid_argument;
    return ec;
  }

  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);


  registration** deletion_point = &impl.signals_;
  registration* reg = impl.signals_;
  while (reg && reg->signal_number_ < signal_number)
  {
    deletion_point = &reg->next_in_set_;
    reg = reg->next_in_set_;
  }

  if (reg != 0 && reg->signal_number_ == signal_number)
  {


    if (state->registration_count_[signal_number] == 1)
    {

      using namespace std;
      struct sigaction sa;
      memset(&sa, 0, sizeof(sa));
      sa.__sigaction_handler.sa_handler = ((__sighandler_t) 0);
      if (::sigaction(signal_number, &sa, 0) == -1)



      {



        ec = boost::system::error_code((*__errno_location ()),
            boost::asio::error::get_system_category());

        return ec;
      }
    }



    *deletion_point = reg->next_in_set_;


    if (registrations_[signal_number] == reg)
      registrations_[signal_number] = reg->next_in_table_;
    if (reg->prev_in_table_)
      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
    if (reg->next_in_table_)
      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;

    --state->registration_count_[signal_number];

    delete reg;
  }

  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code signal_set_service::clear(
    signal_set_service::implementation_type& impl,
    boost::system::error_code& ec)
{
  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);

  while (registration* reg = impl.signals_)
  {


    if (state->registration_count_[reg->signal_number_] == 1)
    {

      using namespace std;
      struct sigaction sa;
      memset(&sa, 0, sizeof(sa));
      sa.__sigaction_handler.sa_handler = ((__sighandler_t) 0);
      if (::sigaction(reg->signal_number_, &sa, 0) == -1)



      {



        ec = boost::system::error_code((*__errno_location ()),
            boost::asio::error::get_system_category());

        return ec;
      }
    }



    if (registrations_[reg->signal_number_] == reg)
      registrations_[reg->signal_number_] = reg->next_in_table_;
    if (reg->prev_in_table_)
      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
    if (reg->next_in_table_)
      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;

    --state->registration_count_[reg->signal_number_];

    impl.signals_ = reg->next_in_set_;
    delete reg;
  }

  ec = boost::system::error_code();
  return ec;
}

boost::system::error_code signal_set_service::cancel(
    signal_set_service::implementation_type& impl,
    boost::system::error_code& ec)
{
  (void)0
                                          ;

  op_queue<operation> ops;
  {
    signal_state* state = get_signal_state();
    static_mutex::scoped_lock lock(state->mutex_);

    while (signal_op* op = impl.queue_.front())
    {
      op->ec_ = boost::asio::error::operation_aborted;
      impl.queue_.pop();
      ops.push(op);
    }
  }

  io_context_.post_deferred_completions(ops);

  ec = boost::system::error_code();
  return ec;
}

void signal_set_service::deliver_signal(int signal_number)
{
  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);

  signal_set_service* service = state->service_list_;
  while (service)
  {
    op_queue<operation> ops;

    registration* reg = service->registrations_[signal_number];
    while (reg)
    {
      if (reg->queue_->empty())
      {
        ++reg->undelivered_;
      }
      else
      {
        while (signal_op* op = reg->queue_->front())
        {
          op->signal_number_ = signal_number;
          reg->queue_->pop();
          ops.push(op);
        }
      }

      reg = reg->next_in_table_;
    }

    service->io_context_.post_deferred_completions(ops);

    service = service->next_;
  }
}

void signal_set_service::add_service(signal_set_service* service)
{
  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);



  if (state->service_list_ == 0)
    open_descriptors();




  if (state->service_list_ != 0)
  {
    if (!(((static_cast<unsigned>(service->io_context_.concurrency_hint()) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)

        || !(((static_cast<unsigned>(state->service_list_->io_context_.concurrency_hint()) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
                                                               )
    {
      std::logic_error ex(
          "Thread-unsafe io_context objects require "
          "exclusive access to signal handling.");
      boost::asio::detail::throw_exception(ex);
    }
  }


  service->next_ = state->service_list_;
  service->prev_ = 0;
  if (state->service_list_)
    state->service_list_->prev_ = service;
  state->service_list_ = service;





  int read_descriptor = state->read_descriptor_;
  lock.unlock();
  service->reactor_.register_internal_descriptor(reactor::read_op,
      read_descriptor, service->reactor_data_, new pipe_read_op);



}

void signal_set_service::remove_service(signal_set_service* service)
{
  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);

  if (service->next_ || service->prev_ || state->service_list_ == service)
  {




    int read_descriptor = state->read_descriptor_;
    lock.unlock();
    service->reactor_.deregister_internal_descriptor(
        read_descriptor, service->reactor_data_);
    service->reactor_.cleanup_descriptor_data(service->reactor_data_);
    lock.lock();





    if (state->service_list_ == service)
      state->service_list_ = service->next_;
    if (service->prev_)
      service->prev_->next_ = service->next_;
    if (service->next_)
      service->next_->prev_= service->prev_;
    service->next_ = 0;
    service->prev_ = 0;



    if (state->service_list_ == 0)
      close_descriptors();

  }
}

void signal_set_service::open_descriptors()
{



  signal_state* state = get_signal_state();

  int pipe_fds[2];
  if (::pipe(pipe_fds) == 0)
  {
    state->read_descriptor_ = pipe_fds[0];
    ::fcntl(state->read_descriptor_, 4, 04000);

    state->write_descriptor_ = pipe_fds[1];
    ::fcntl(state->write_descriptor_, 4, 04000);


    ::fcntl(state->read_descriptor_, 2, 1);
    ::fcntl(state->write_descriptor_, 2, 1);

  }
  else
  {
    boost::system::error_code ec((*__errno_location ()),
        boost::asio::error::get_system_category());
    boost::asio::detail::throw_error(ec, "signal_set_service pipe");
  }



}

void signal_set_service::close_descriptors()
{



  signal_state* state = get_signal_state();

  if (state->read_descriptor_ != -1)
    ::close(state->read_descriptor_);
  state->read_descriptor_ = -1;

  if (state->write_descriptor_ != -1)
    ::close(state->write_descriptor_);
  state->write_descriptor_ = -1;



}

void signal_set_service::start_wait_op(
    signal_set_service::implementation_type& impl, signal_op* op)
{
  io_context_.work_started();

  signal_state* state = get_signal_state();
  static_mutex::scoped_lock lock(state->mutex_);

  registration* reg = impl.signals_;
  while (reg)
  {
    if (reg->undelivered_ > 0)
    {
      --reg->undelivered_;
      op->signal_number_ = reg->signal_number_;
      io_context_.post_deferred_completion(op);
      return;
    }

    reg = reg->next_in_set_;
  }

  impl.queue_.push(op);
}

}
}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 670 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
# 217 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 2 3 4


namespace boost {
namespace asio {
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
class signal_set
  : protected basic_io_object<detail::signal_set_service>
{
public:

  typedef io_context::executor_type executor_type;
# 114 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  explicit signal_set(boost::asio::io_context& io_context)
    : basic_io_object<detail::signal_set_service>(io_context)
  {
  }
# 132 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  signal_set(boost::asio::io_context& io_context, int signal_number_1)
    : basic_io_object<detail::signal_set_service>(io_context)
  {
    boost::system::error_code ec;
    this->get_service().add(this->get_implementation(), signal_number_1, ec);
    boost::asio::detail::throw_error(ec, "add");
  }
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  signal_set(boost::asio::io_context& io_context, int signal_number_1,
      int signal_number_2)
    : basic_io_object<detail::signal_set_service>(io_context)
  {
    boost::system::error_code ec;
    this->get_service().add(this->get_implementation(), signal_number_1, ec);
    boost::asio::detail::throw_error(ec, "add");
    this->get_service().add(this->get_implementation(), signal_number_2, ec);
    boost::asio::detail::throw_error(ec, "add");
  }
# 186 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  signal_set(boost::asio::io_context& io_context, int signal_number_1,
      int signal_number_2, int signal_number_3)
    : basic_io_object<detail::signal_set_service>(io_context)
  {
    boost::system::error_code ec;
    this->get_service().add(this->get_implementation(), signal_number_1, ec);
    boost::asio::detail::throw_error(ec, "add");
    this->get_service().add(this->get_implementation(), signal_number_2, ec);
    boost::asio::detail::throw_error(ec, "add");
    this->get_service().add(this->get_implementation(), signal_number_3, ec);
    boost::asio::detail::throw_error(ec, "add");
  }







  ~signal_set()
  {
  }
# 219 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  boost::asio::io_context& get_io_context()
  {
    return basic_io_object<detail::signal_set_service>::get_io_context();
  }
# 233 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  boost::asio::io_context& get_io_service()
  {
    return basic_io_object<detail::signal_set_service>::get_io_service();
  }



  executor_type get_executor() noexcept
  {
    return basic_io_object<detail::signal_set_service>::get_executor();
  }
# 254 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  void add(int signal_number)
  {
    boost::system::error_code ec;
    this->get_service().add(this->get_implementation(), signal_number, ec);
    boost::asio::detail::throw_error(ec, "add");
  }
# 270 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  boost::system::error_code add(int signal_number,
      boost::system::error_code& ec)
  {
    this->get_service().add(this->get_implementation(), signal_number, ec);
    return ec;
  }
# 289 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  void remove(int signal_number)
  {
    boost::system::error_code ec;
    this->get_service().remove(this->get_implementation(), signal_number, ec);
    boost::asio::detail::throw_error(ec, "remove");
  }
# 308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  boost::system::error_code remove(int signal_number,
      boost::system::error_code& ec)
  {
    this->get_service().remove(this->get_implementation(), signal_number, ec);
    return ec;
  }
# 324 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  void clear()
  {
    boost::system::error_code ec;
    this->get_service().clear(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "clear");
  }
# 340 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  boost::system::error_code clear(boost::system::error_code& ec)
  {
    this->get_service().clear(this->get_implementation(), ec);
    return ec;
  }
# 367 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  void cancel()
  {
    boost::system::error_code ec;
    this->get_service().cancel(this->get_implementation(), ec);
    boost::asio::detail::throw_error(ec, "cancel");
  }
# 395 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  boost::system::error_code cancel(boost::system::error_code& ec)
  {
    this->get_service().cancel(this->get_implementation(), ec);
    return ec;
  }
# 426 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set.hpp" 3 4
  template <typename SignalHandler>
  typename ::boost::asio::async_result< typename ::boost::asio::decay<SignalHandler>::type, void (boost::system::error_code, int)>::return_type

  async_wait(SignalHandler&& handler)
  {


    typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<SignalHandler>::type, void(boost::system::error_code, int)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const int*>(0))) == 1, "SignalHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const int>()), char(0))> __attribute__((__unused__)) type_check;

    async_completion<SignalHandler,
      void (boost::system::error_code, int)> init(handler);

    this->get_service().async_wait(this->get_implementation(),
        init.completion_handler);

    return init.result.get();
  }
};


}
}
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/signal_set_service.hpp" 1 3 4
# 120 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/socket_acceptor_service.hpp" 1 3 4
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/stream_socket_service.hpp" 1 3 4
# 125 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/streambuf.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/streambuf.hpp" 3 4
namespace boost {
namespace asio {


typedef basic_streambuf<> streambuf;

}
}
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_timer.hpp" 1 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_timer.hpp" 3 4
namespace boost {
namespace asio {
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/system_timer.hpp" 3 4
typedef basic_waitable_timer<chrono::system_clock> system_timer;

}
}
# 129 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 2 3 4

namespace boost {
namespace asio {
# 64 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 3 4
class thread_pool
  : public execution_context
{
public:
  class executor_type;


  inline thread_pool();


  inline thread_pool(std::size_t num_threads);





  inline ~thread_pool();


  executor_type get_executor() noexcept;






  inline void stop();







  inline void join();

private:
  friend class executor_type;
  struct thread_function;


  detail::scheduler& scheduler_;


  detail::thread_group threads_;
};


class thread_pool::executor_type
{
public:

  thread_pool& context() const noexcept;







  void on_work_started() const noexcept;







  void on_work_finished() const noexcept;
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 3 4
  template <typename Function, typename Allocator>
  void dispatch(Function&& f, const Allocator& a) const;
# 164 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 3 4
  template <typename Function, typename Allocator>
  void post(Function&& f, const Allocator& a) const;
# 184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 3 4
  template <typename Function, typename Allocator>
  void defer(Function&& f, const Allocator& a) const;






  bool running_in_this_thread() const noexcept;





  friend bool operator==(const executor_type& a,
      const executor_type& b) noexcept
  {
    return &a.pool_ == &b.pool_;
  }





  friend bool operator!=(const executor_type& a,
      const executor_type& b) noexcept
  {
    return &a.pool_ != &b.pool_;
  }

private:
  friend class thread_pool;


  explicit executor_type(thread_pool& p) : pool_(p) {}


  thread_pool& pool_;
};

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 228 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.hpp" 2 3 4

namespace boost {
namespace asio {

inline thread_pool::executor_type
thread_pool::get_executor() noexcept
{
  return executor_type(*this);
}

inline thread_pool&
thread_pool::executor_type::context() const noexcept
{
  return pool_;
}

inline void
thread_pool::executor_type::on_work_started() const noexcept
{
  pool_.scheduler_.work_started();
}

inline void thread_pool::executor_type::on_work_finished()
const noexcept
{
  pool_.scheduler_.work_finished();
}

template <typename Function, typename Allocator>
void thread_pool::executor_type::dispatch(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;


  if (pool_.scheduler_.can_dispatch())
  {

    function_type tmp(static_cast<Function&&>(f));

    detail::fenced_block b(detail::fenced_block::full);
    boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
    return;
  }


  typedef detail::executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                        ;

  pool_.scheduler_.post_immediate_completion(p.p, false);
  p.v = p.p = 0;
}

template <typename Function, typename Allocator>
void thread_pool::executor_type::post(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;


  typedef detail::executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                    ;

  pool_.scheduler_.post_immediate_completion(p.p, false);
  p.v = p.p = 0;
}

template <typename Function, typename Allocator>
void thread_pool::executor_type::defer(
    Function&& f, const Allocator& a) const
{
  typedef typename decay<Function>::type function_type;


  typedef detail::executor_op<function_type, Allocator> op;
  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
  p.p = new (p.v) op(static_cast<Function&&>(f), a);

  (void)0
                                                     ;

  pool_.scheduler_.post_immediate_completion(p.p, true);
  p.v = p.p = 0;
}

inline bool
thread_pool::executor_type::running_in_this_thread() const noexcept
{
  return pool_.scheduler_.can_dispatch();
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.hpp" 2 3 4
# 230 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.ipp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.ipp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 1 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.ipp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.ipp" 2 3 4

namespace boost {
namespace asio {

struct thread_pool::thread_function
{
  detail::scheduler* scheduler_;

  void operator()()
  {
    boost::system::error_code ec;
    scheduler_->run(ec);
  }
};

thread_pool::thread_pool()
  : scheduler_(use_service<detail::scheduler>(*this))
{
  scheduler_.work_started();

  thread_function f = { &scheduler_ };
  std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
  threads_.create_threads(f, num_threads ? num_threads : 2);
}

thread_pool::thread_pool(std::size_t num_threads)
  : scheduler_(use_service<detail::scheduler>(*this))
{
  scheduler_.work_started();

  thread_function f = { &scheduler_ };
  threads_.create_threads(f, num_threads);
}

thread_pool::~thread_pool()
{
  stop();
  join();
}

void thread_pool::stop()
{
  scheduler_.stop();
}

void thread_pool::join()
{
  scheduler_.work_finished();
  threads_.join();
}

}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/thread_pool.ipp" 2 3 4
# 232 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/thread_pool.hpp" 2 3 4
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/use_future.hpp" 1 3 4
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/use_future.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/use_future.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {

template <typename Function, typename Allocator>
class packaged_token;

template <typename Function, typename Allocator, typename Result>
class packaged_handler;

}
# 55 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/use_future.hpp" 3 4
template <typename Allocator = std::allocator<void> >
class use_future_t
{
public:


  typedef Allocator allocator_type;


  constexpr use_future_t()
  {
  }


  explicit use_future_t(const Allocator& allocator)
    : allocator_(allocator)
  {
  }



  template <typename OtherAllocator>
  use_future_t<OtherAllocator> operator[](const OtherAllocator& allocator) const
  {
    return use_future_t<OtherAllocator>(allocator);
  }



  template <typename OtherAllocator>
  use_future_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
  {
    return use_future_t<OtherAllocator>(allocator);
  }


  allocator_type get_allocator() const
  {
    return allocator_;
  }
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/use_future.hpp" 3 4
  template <typename Function>



  detail::packaged_token<typename decay<Function>::type, Allocator>

  operator()(Function&& f) const;

private:


  struct std_allocator_void
  {
    constexpr std_allocator_void()
    {
    }

    operator std::allocator<void>() const
    {
      return std::allocator<void>();
    }
  };

  typename conditional<
    is_same<std::allocator<void>, Allocator>::value,
    std_allocator_void, Allocator>::type allocator_;
};






constexpr use_future_t<> use_future;




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 155 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/use_future.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 2 3 4

namespace boost {
namespace asio {
namespace detail {



template <typename T, typename F, typename... Args>
inline void promise_invoke_and_set(std::promise<T>& p,
    F& f, Args&&... args)
{

  try

  {
    p.set_value(f(static_cast<Args&&>(args)...));
  }

  catch (...)
  {
    p.set_exception(std::current_exception());
  }

}

template <typename F, typename... Args>
inline void promise_invoke_and_set(std::promise<void>& p,
    F& f, Args&&... args)
{

  try

  {
    f(static_cast<Args&&>(args)...);
    p.set_value();
  }

  catch (...)
  {
    p.set_exception(std::current_exception());
  }

}
# 172 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
template <typename T, typename F>
class promise_invoker
{
public:
  promise_invoker(const shared_ptr<std::promise<T> >& p,
      F&& f)
    : p_(p), f_(static_cast<F&&>(f))
  {
  }

  void operator()()
  {

    try

    {
      f_();
    }

    catch (...)
    {
      p_->set_exception(std::current_exception());
    }

  }

private:
  shared_ptr<std::promise<T> > p_;
  typename decay<F>::type f_;
};



template <typename T>
class promise_executor
{
public:
  explicit promise_executor(const shared_ptr<std::promise<T> >& p)
    : p_(p)
  {
  }

  execution_context& context() const noexcept
  {
    return system_executor().context();
  }

  void on_work_started() const noexcept {}
  void on_work_finished() const noexcept {}

  template <typename F, typename A>
  void dispatch(F&& f, const A&) const
  {
    promise_invoker<T, F>(p_, static_cast<F&&>(f))();
  }

  template <typename F, typename A>
  void post(F&& f, const A& a) const
  {
    system_executor().post(
        promise_invoker<T, F>(p_, static_cast<F&&>(f)), a);
  }

  template <typename F, typename A>
  void defer(F&& f, const A& a) const
  {
    system_executor().defer(
        promise_invoker<T, F>(p_, static_cast<F&&>(f)), a);
  }

  friend bool operator==(const promise_executor& a,
      const promise_executor& b) noexcept
  {
    return a.p_ == b.p_;
  }

  friend bool operator!=(const promise_executor& a,
      const promise_executor& b) noexcept
  {
    return a.p_ != b.p_;
  }

private:
  shared_ptr<std::promise<T> > p_;
};


template <typename T>
class promise_creator
{
public:
  typedef promise_executor<T> executor_type;

  executor_type get_executor() const noexcept
  {
    return executor_type(p_);
  }

  typedef std::future<T> future_type;

  future_type get_future()
  {
    return p_->get_future();
  }

protected:
  template <typename Allocator>
  void create_promise(const Allocator& a)
  {
    typename std::allocator_traits<Allocator>::template rebind_alloc<char> b(a);
    p_ = std::allocate_shared<std::promise<T>>(b, std::allocator_arg, b);
  }

  shared_ptr<std::promise<T> > p_;
};


class promise_handler_0
  : public promise_creator<void>
{
public:
  void operator()()
  {
    this->p_->set_value();
  }
};


class promise_handler_ec_0
  : public promise_creator<void>
{
public:
  void operator()(const boost::system::error_code& ec)
  {
    if (ec)
    {
      this->p_->set_exception(
          std::make_exception_ptr(
            boost::system::system_error(ec)));
    }
    else
    {
      this->p_->set_value();
    }
  }
};


class promise_handler_ex_0
  : public promise_creator<void>
{
public:
  void operator()(const std::exception_ptr& ex)
  {
    if (ex)
    {
      this->p_->set_exception(ex);
    }
    else
    {
      this->p_->set_value();
    }
  }
};


template <typename T>
class promise_handler_1
  : public promise_creator<T>
{
public:
  template <typename Arg>
  void operator()(Arg&& arg)
  {
    this->p_->set_value(static_cast<Arg&&>(arg));
  }
};


template <typename T>
class promise_handler_ec_1
  : public promise_creator<T>
{
public:
  template <typename Arg>
  void operator()(const boost::system::error_code& ec,
      Arg&& arg)
  {
    if (ec)
    {
      this->p_->set_exception(
          std::make_exception_ptr(
            boost::system::system_error(ec)));
    }
    else
      this->p_->set_value(static_cast<Arg&&>(arg));
  }
};


template <typename T>
class promise_handler_ex_1
  : public promise_creator<T>
{
public:
  template <typename Arg>
  void operator()(const std::exception_ptr& ex,
      Arg&& arg)
  {
    if (ex)
      this->p_->set_exception(ex);
    else
      this->p_->set_value(static_cast<Arg&&>(arg));
  }
};


template <typename T>
class promise_handler_n
  : public promise_creator<T>
{
public:


  template <typename... Args>
  void operator()(Args&&... args)
  {
    this->p_->set_value(
        std::forward_as_tuple(
          static_cast<Args&&>(args)...));
  }
# 419 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
};


template <typename T>
class promise_handler_ec_n
  : public promise_creator<T>
{
public:


  template <typename... Args>
  void operator()(const boost::system::error_code& ec,
      Args&&... args)
  {
    if (ec)
    {
      this->p_->set_exception(
          std::make_exception_ptr(
            boost::system::system_error(ec)));
    }
    else
    {
      this->p_->set_value(
          std::forward_as_tuple(
            static_cast<Args&&>(args)...));
    }
  }
# 472 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
};


template <typename T>
class promise_handler_ex_n
  : public promise_creator<T>
{
public:


  template <typename... Args>
  void operator()(const std::exception_ptr& ex,
      Args&&... args)
  {
    if (ex)
      this->p_->set_exception(ex);
    else
    {
      this->p_->set_value(
          std::forward_as_tuple(
            static_cast<Args&&>(args)...));
    }
  }
# 517 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
};



template <typename> class promise_handler_selector;

template <>
class promise_handler_selector<void()>
  : public promise_handler_0 {};

template <>
class promise_handler_selector<void(boost::system::error_code)>
  : public promise_handler_ec_0 {};

template <>
class promise_handler_selector<void(std::exception_ptr)>
  : public promise_handler_ex_0 {};

template <typename Arg>
class promise_handler_selector<void(Arg)>
  : public promise_handler_1<Arg> {};

template <typename Arg>
class promise_handler_selector<void(boost::system::error_code, Arg)>
  : public promise_handler_ec_1<Arg> {};

template <typename Arg>
class promise_handler_selector<void(std::exception_ptr, Arg)>
  : public promise_handler_ex_1<Arg> {};



template <typename... Arg>
class promise_handler_selector<void(Arg...)>
  : public promise_handler_n<std::tuple<Arg...> > {};

template <typename... Arg>
class promise_handler_selector<void(boost::system::error_code, Arg...)>
  : public promise_handler_ec_n<std::tuple<Arg...> > {};

template <typename... Arg>
class promise_handler_selector<void(std::exception_ptr, Arg...)>
  : public promise_handler_ex_n<std::tuple<Arg...> > {};
# 589 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
template <typename Signature, typename Allocator>
class promise_handler
  : public promise_handler_selector<Signature>
{
public:
  typedef Allocator allocator_type;
  typedef void result_type;

  promise_handler(use_future_t<Allocator> u)
    : allocator_(u.get_allocator())
  {
    this->create_promise(allocator_);
  }

  allocator_type get_allocator() const noexcept
  {
    return allocator_;
  }

private:
  Allocator allocator_;
};

template <typename Function, typename Signature, typename Allocator>
inline void asio_handler_invoke(Function& f,
    promise_handler<Signature, Allocator>* h)
{
  typename promise_handler<Signature, Allocator>::executor_type
    ex(h->get_executor());
  ex.dispatch(static_cast<Function&&>(f), std::allocator<void>());
}

template <typename Function, typename Signature, typename Allocator>
inline void asio_handler_invoke(const Function& f,
    promise_handler<Signature, Allocator>* h)
{
  typename promise_handler<Signature, Allocator>::executor_type
    ex(h->get_executor());
  ex.dispatch(f, std::allocator<void>());
}


template <typename Signature, typename Allocator>
class promise_async_result
{
public:
  typedef promise_handler<Signature, Allocator> completion_handler_type;
  typedef typename completion_handler_type::future_type return_type;

  explicit promise_async_result(completion_handler_type& h)
    : future_(h.get_future())
  {
  }

  return_type get()
  {
    return static_cast<return_type&&>(future_);
  }

private:
  return_type future_;
};


template <typename Function, typename Allocator>
class packaged_token
{
public:
  packaged_token(Function f, const Allocator& a)
    : function_(static_cast<Function&&>(f)),
      allocator_(a)
  {
  }


  Function function_;
  Allocator allocator_;
};



template <typename Function, typename Allocator, typename Result>
class packaged_handler
  : public promise_creator<Result>
{
public:
  typedef Allocator allocator_type;
  typedef void result_type;

  packaged_handler(packaged_token<Function, Allocator> t)
    : function_(static_cast<Function&&>(t.function_)),
      allocator_(t.allocator_)
  {
    this->create_promise(allocator_);
  }

  allocator_type get_allocator() const noexcept
  {
    return allocator_;
  }



  template <typename... Args>
  void operator()(Args&&... args)
  {
    (promise_invoke_and_set)(*this->p_,
        function_, static_cast<Args&&>(args)...);
  }
# 719 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
private:
  Function function_;
  Allocator allocator_;
};

template <typename Function,
    typename Function1, typename Allocator, typename Result>
inline void asio_handler_invoke(Function& f,
    packaged_handler<Function1, Allocator, Result>* h)
{
  typename packaged_handler<Function1, Allocator, Result>::executor_type
    ex(h->get_executor());
  ex.dispatch(static_cast<Function&&>(f), std::allocator<void>());
}

template <typename Function,
    typename Function1, typename Allocator, typename Result>
inline void asio_handler_invoke(const Function& f,
    packaged_handler<Function1, Allocator, Result>* h)
{
  typename packaged_handler<Function1, Allocator, Result>::executor_type
    ex(h->get_executor());
  ex.dispatch(f, std::allocator<void>());
}


template <typename Function, typename Allocator, typename Result>
class packaged_async_result
{
public:
  typedef packaged_handler<Function, Allocator, Result> completion_handler_type;
  typedef typename completion_handler_type::future_type return_type;

  explicit packaged_async_result(completion_handler_type& h)
    : future_(h.get_future())
  {
  }

  return_type get()
  {
    return static_cast<return_type&&>(future_);
  }

private:
  return_type future_;
};

}

template <typename Allocator> template <typename Function>
inline detail::packaged_token<typename decay<Function>::type, Allocator>
use_future_t<Allocator>::operator()(Function&& f) const
{
  return detail::packaged_token<typename decay<Function>::type, Allocator>(
      static_cast<Function&&>(f), allocator_);
}





template <typename Allocator, typename Result, typename... Args>
class async_result<use_future_t<Allocator>, Result(Args...)>
  : public detail::promise_async_result<
      void(typename decay<Args>::type...), Allocator>
{
public:
  explicit async_result(
    typename detail::promise_async_result<void(typename decay<Args>::type...),
      Allocator>::completion_handler_type& h)
    : detail::promise_async_result<
        void(typename decay<Args>::type...), Allocator>(h)
  {
  }
};

template <typename Function, typename Allocator,
    typename Result, typename... Args>
class async_result<detail::packaged_token<Function, Allocator>, Result(Args...)>
  : public detail::packaged_async_result<Function, Allocator,
      typename result_of<Function(Args...)>::type>
{
public:
  explicit async_result(
    typename detail::packaged_async_result<Function, Allocator,
      typename result_of<Function(Args...)>::type>::completion_handler_type& h)
    : detail::packaged_async_result<Function, Allocator,
        typename result_of<Function(Args...)>::type>(h)
  {
  }
};
# 885 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 3 4
template <typename Allocator, typename Signature>
struct handler_type<use_future_t<Allocator>, Signature>
{
  typedef typename async_result<use_future_t<Allocator>,
    Signature>::completion_handler_type type;
};

template <typename Signature, typename Allocator>
class async_result<detail::promise_handler<Signature, Allocator> >
  : public detail::promise_async_result<Signature, Allocator>
{
public:
  typedef typename detail::promise_async_result<
    Signature, Allocator>::return_type type;

  explicit async_result(
    typename detail::promise_async_result<
      Signature, Allocator>::completion_handler_type& h)
    : detail::promise_async_result<Signature, Allocator>(h)
  {
  }
};

template <typename Function, typename Allocator, typename Signature>
struct handler_type<detail::packaged_token<Function, Allocator>, Signature>
{
  typedef typename async_result<detail::packaged_token<Function, Allocator>,
    Signature>::completion_handler_type type;
};

template <typename Function, typename Allocator, typename Result>
class async_result<detail::packaged_handler<Function, Allocator, Result> >
  : public detail::packaged_async_result<Function, Allocator, Result>
{
public:
  typedef typename detail::packaged_async_result<
    Function, Allocator, Result>::return_type type;

  explicit async_result(
    typename detail::packaged_async_result<
      Function, Allocator, Result>::completion_handler_type& h)
    : detail::packaged_async_result<Function, Allocator, Result>(h)
  {
  }
};





}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 939 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/use_future.hpp" 2 3 4
# 157 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/use_future.hpp" 2 3 4
# 132 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/version.hpp" 1 3 4
# 134 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/waitable_timer_service.hpp" 1 3 4
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/basic_handle.hpp" 1 3 4
# 137 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/basic_object_handle.hpp" 1 3 4
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/basic_random_access_handle.hpp" 1 3 4
# 139 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/basic_stream_handle.hpp" 1 3 4
# 140 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/object_handle.hpp" 1 3 4
# 141 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/object_handle_service.hpp" 1 3 4
# 142 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/overlapped_handle.hpp" 1 3 4
# 143 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/overlapped_ptr.hpp" 1 3 4
# 144 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/random_access_handle.hpp" 1 3 4
# 145 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/random_access_handle_service.hpp" 1 3 4
# 146 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/stream_handle.hpp" 1 3 4
# 147 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/windows/stream_handle_service.hpp" 1 3 4
# 148 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 1 3 4
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 2 3 4

namespace boost {
namespace asio {
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers);
# 123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    boost::system::error_code& ec);
# 177 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition);
# 225 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec);
# 263 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, basic_streambuf<Allocator>& b);
# 296 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename Allocator>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, basic_streambuf<Allocator>& b,
    boost::system::error_code& ec);
# 339 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename Allocator,
    typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
    basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
# 383 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename SyncRandomAccessWriteDevice, typename Allocator,
    typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
    basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
    boost::system::error_code& ec);
# 457 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
    const ConstBufferSequence& buffers,
    WriteHandler&& handler);
# 536 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition,
    WriteHandler&& handler);
# 593 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
    typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
    basic_streambuf<Allocator>& b, WriteHandler&& handler);
# 659 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 3 4
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
    typename CompletionCondition, typename WriteHandler>
typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
    basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
    WriteHandler&& handler);






}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 676 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write_at.hpp" 1 3 4
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write_at.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 1 3 4
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/push_options.hpp" 3 4
#pragma GCC visibility push (default)



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write_at.hpp" 2 3 4

namespace boost {
namespace asio {

namespace detail
{
  template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
      typename ConstBufferIterator, typename CompletionCondition>
  std::size_t write_at_buffer_sequence(SyncRandomAccessWriteDevice& d,
      uint64_t offset, const ConstBufferSequence& buffers,
      const ConstBufferIterator&, CompletionCondition completion_condition,
      boost::system::error_code& ec)
  {
    ec = boost::system::error_code();
    boost::asio::detail::consuming_buffers<const_buffer,
        ConstBufferSequence, ConstBufferIterator> tmp(buffers);
    while (!tmp.empty())
    {
      if (std::size_t max_size = detail::adapt_completion_condition_result(
            completion_condition(ec, tmp.total_consumed())))
      {
        tmp.consume(d.write_some_at(offset + tmp.total_consumed(),
              tmp.prepare(max_size), ec));
      }
      else
        break;
    }
    return tmp.total_consumed();;
  }
}

template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition, boost::system::error_code& ec)
{
  return detail::write_at_buffer_sequence(d, offset, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
}

template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write_at(
      d, offset, buffers, transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "write_at");
  return bytes_transferred;
}

template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    boost::system::error_code& ec)
{
  return write_at(d, offset, buffers, transfer_all(), ec);
}

template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename CompletionCondition>
inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write_at(
      d, offset, buffers, completion_condition, ec);
  boost::asio::detail::throw_error(ec, "write_at");
  return bytes_transferred;
}




template <typename SyncRandomAccessWriteDevice, typename Allocator,
    typename CompletionCondition>
std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition, boost::system::error_code& ec)
{
  std::size_t bytes_transferred = write_at(
      d, offset, b.data(), completion_condition, ec);
  b.consume(bytes_transferred);
  return bytes_transferred;
}

template <typename SyncRandomAccessWriteDevice, typename Allocator>
inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write_at(d, offset, b, transfer_all(), ec);
  boost::asio::detail::throw_error(ec, "write_at");
  return bytes_transferred;
}

template <typename SyncRandomAccessWriteDevice, typename Allocator>
inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    boost::system::error_code& ec)
{
  return write_at(d, offset, b, transfer_all(), ec);
}

template <typename SyncRandomAccessWriteDevice, typename Allocator,
    typename CompletionCondition>
inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition)
{
  boost::system::error_code ec;
  std::size_t bytes_transferred = write_at(
      d, offset, b, completion_condition, ec);
  boost::asio::detail::throw_error(ec, "write_at");
  return bytes_transferred;
}




namespace detail
{
  template <typename AsyncRandomAccessWriteDevice,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  class write_at_op
    : detail::base_from_completion_cond<CompletionCondition>
  {
  public:
    write_at_op(AsyncRandomAccessWriteDevice& device,
        uint64_t offset, const ConstBufferSequence& buffers,
        CompletionCondition completion_condition, WriteHandler& handler)
      : detail::base_from_completion_cond<
          CompletionCondition>(completion_condition),
        device_(device),
        offset_(offset),
        buffers_(buffers),
        start_(0),
        handler_(static_cast<WriteHandler&&>(handler))
    {
    }


    write_at_op(const write_at_op& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        device_(other.device_),
        offset_(other.offset_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(other.handler_)
    {
    }

    write_at_op(write_at_op&& other)
      : detail::base_from_completion_cond<CompletionCondition>(other),
        device_(other.device_),
        offset_(other.offset_),
        buffers_(other.buffers_),
        start_(other.start_),
        handler_(static_cast<WriteHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        std::size_t bytes_transferred, int start = 0)
    {
      std::size_t max_size;
      switch (start_ = start)
      {
        case 1:
        max_size = this->check_for_completion(ec, buffers_.total_consumed());
        do
        {
          device_.async_write_some_at(
              offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
              static_cast<write_at_op&&>(*this));
          return; default:
          buffers_.consume(bytes_transferred);
          if ((!ec && bytes_transferred == 0) || buffers_.empty())
            break;
          max_size = this->check_for_completion(ec, buffers_.total_consumed());
        } while (max_size > 0);

        handler_(ec, buffers_.total_consumed());
      }
    }


    AsyncRandomAccessWriteDevice& device_;
    uint64_t offset_;
    boost::asio::detail::consuming_buffers<const_buffer,
        ConstBufferSequence, ConstBufferIterator> buffers_;
    int start_;
    WriteHandler handler_;
  };

  template <typename AsyncRandomAccessWriteDevice,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline void* asio_handler_allocate(std::size_t size,
      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename AsyncRandomAccessWriteDevice,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename AsyncRandomAccessWriteDevice,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline bool asio_handler_is_continuation(
      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
  {
    return this_handler->start_ == 0 ? true
      : boost_asio_handler_cont_helpers::is_continuation(
          this_handler->handler_);
  }

  template <typename Function, typename AsyncRandomAccessWriteDevice,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline void asio_handler_invoke(Function& function,
      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename AsyncRandomAccessWriteDevice,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline void asio_handler_invoke(const Function& function,
      write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
        ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename AsyncRandomAccessWriteDevice,
      typename ConstBufferSequence, typename ConstBufferIterator,
      typename CompletionCondition, typename WriteHandler>
  inline void start_write_at_buffer_sequence_op(AsyncRandomAccessWriteDevice& d,
      uint64_t offset, const ConstBufferSequence& buffers,
      const ConstBufferIterator&, CompletionCondition completion_condition,
      WriteHandler& handler)
  {
    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>(
        d, offset, buffers, completion_condition, handler)(
          boost::system::error_code(), 0, 1);
  }
}



template <typename AsyncRandomAccessWriteDevice,
    typename ConstBufferSequence, typename ConstBufferIterator,
    typename CompletionCondition, typename WriteHandler, typename Allocator>
struct associated_allocator<
    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>,
    Allocator>
{
  typedef typename associated_allocator<WriteHandler, Allocator>::type type;

  static type get(
      const detail::write_at_op<AsyncRandomAccessWriteDevice,
        ConstBufferSequence, ConstBufferIterator,
        CompletionCondition, WriteHandler>& h,
      const Allocator& a = Allocator()) noexcept
  {
    return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
  }
};

template <typename AsyncRandomAccessWriteDevice,
    typename ConstBufferSequence, typename ConstBufferIterator,
    typename CompletionCondition, typename WriteHandler, typename Executor>
struct associated_executor<
    detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
      ConstBufferIterator, CompletionCondition, WriteHandler>,
    Executor>
{
  typedef typename associated_executor<WriteHandler, Executor>::type type;

  static type get(
      const detail::write_at_op<AsyncRandomAccessWriteDevice,
        ConstBufferSequence, ConstBufferIterator,
        CompletionCondition, WriteHandler>& h,
      const Executor& ex = Executor()) noexcept
  {
    return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
  }
};



template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    CompletionCondition completion_condition,
    WriteHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_write_at_buffer_sequence_op(d, offset, buffers,
      boost::asio::buffer_sequence_begin(buffers), completion_condition,
      init.completion_handler);

  return init.result.get();
}

template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
    typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d,
    uint64_t offset, const ConstBufferSequence& buffers,
    WriteHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  detail::start_write_at_buffer_sequence_op(d, offset, buffers,
      boost::asio::buffer_sequence_begin(buffers), transfer_all(),
      init.completion_handler);

  return init.result.get();
}




namespace detail
{
  template <typename Allocator, typename WriteHandler>
  class write_at_streambuf_op
  {
  public:
    write_at_streambuf_op(
        boost::asio::basic_streambuf<Allocator>& streambuf,
        WriteHandler& handler)
      : streambuf_(streambuf),
        handler_(static_cast<WriteHandler&&>(handler))
    {
    }


    write_at_streambuf_op(const write_at_streambuf_op& other)
      : streambuf_(other.streambuf_),
        handler_(other.handler_)
    {
    }

    write_at_streambuf_op(write_at_streambuf_op&& other)
      : streambuf_(other.streambuf_),
        handler_(static_cast<WriteHandler&&>(other.handler_))
    {
    }


    void operator()(const boost::system::error_code& ec,
        const std::size_t bytes_transferred)
    {
      streambuf_.consume(bytes_transferred);
      handler_(ec, bytes_transferred);
    }


    boost::asio::basic_streambuf<Allocator>& streambuf_;
    WriteHandler handler_;
  };

  template <typename Allocator, typename WriteHandler>
  inline void* asio_handler_allocate(std::size_t size,
      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
  {
    return boost_asio_handler_alloc_helpers::allocate(
        size, this_handler->handler_);
  }

  template <typename Allocator, typename WriteHandler>
  inline void asio_handler_deallocate(void* pointer, std::size_t size,
      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
  {
    boost_asio_handler_alloc_helpers::deallocate(
        pointer, size, this_handler->handler_);
  }

  template <typename Allocator, typename WriteHandler>
  inline bool asio_handler_is_continuation(
      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
  {
    return boost_asio_handler_cont_helpers::is_continuation(
        this_handler->handler_);
  }

  template <typename Function, typename Allocator, typename WriteHandler>
  inline void asio_handler_invoke(Function& function,
      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Function, typename Allocator, typename WriteHandler>
  inline void asio_handler_invoke(const Function& function,
      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
  {
    boost_asio_handler_invoke_helpers::invoke(
        function, this_handler->handler_);
  }

  template <typename Allocator, typename WriteHandler>
  inline write_at_streambuf_op<Allocator, WriteHandler>
  make_write_at_streambuf_op(
      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
  {
    return write_at_streambuf_op<Allocator, WriteHandler>(b, handler);
  }
}



template <typename Allocator, typename WriteHandler, typename Allocator1>
struct associated_allocator<
    detail::write_at_streambuf_op<Allocator, WriteHandler>,
    Allocator1>
{
  typedef typename associated_allocator<WriteHandler, Allocator1>::type type;

  static type get(
      const detail::write_at_streambuf_op<Allocator, WriteHandler>& h,
      const Allocator1& a = Allocator1()) noexcept
  {
    return associated_allocator<WriteHandler, Allocator1>::get(h.handler_, a);
  }
};

template <typename Executor, typename WriteHandler, typename Executor1>
struct associated_executor<
    detail::write_at_streambuf_op<Executor, WriteHandler>,
    Executor1>
{
  typedef typename associated_executor<WriteHandler, Executor1>::type type;

  static type get(
      const detail::write_at_streambuf_op<Executor, WriteHandler>& h,
      const Executor1& ex = Executor1()) noexcept
  {
    return associated_executor<WriteHandler, Executor1>::get(h.handler_, ex);
  }
};



template <typename AsyncRandomAccessWriteDevice, typename Allocator,
    typename CompletionCondition, typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    CompletionCondition completion_condition,
    WriteHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  async_write_at(d, offset, b.data(), completion_condition,
    detail::write_at_streambuf_op<Allocator, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                  >(
        b, init.completion_handler));

  return init.result.get();
}

template <typename AsyncRandomAccessWriteDevice, typename Allocator,
    typename WriteHandler>
inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type

async_write_at(AsyncRandomAccessWriteDevice& d,
    uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
    WriteHandler&& handler)
{


  typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;

  async_completion<WriteHandler,
    void (boost::system::error_code, std::size_t)> init(handler);

  async_write_at(d, offset, b.data(), transfer_all(),
    detail::write_at_streambuf_op<Allocator, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
                                                                  >(
        b, init.completion_handler));

  return init.result.get();
}




}
}

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 1 3 4
# 67 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/detail/pop_options.hpp" 3 4
#pragma GCC visibility pop



#pragma GCC diagnostic pop
# 573 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/impl/write_at.hpp" 2 3 4
# 678 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio/write_at.hpp" 2 3 4
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/asio.hpp" 2 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 2



       





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Timer.h" 1
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Timer.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Cond.h" 1
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Timer.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Mutex.h" 1
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Timer.h" 2


# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Timer.h"
class CephContext;
class Context;
class SafeTimerThread;

class SafeTimer
{
  CephContext *cct;
  Mutex& lock;
  Cond cond;
  bool safe_callbacks;

  friend class SafeTimerThread;
  SafeTimerThread *thread;

  void timer_thread();
  void _shutdown();

  std::multimap<utime_t, Context*> schedule;
  std::map<Context*, std::multimap<utime_t, Context*>::iterator> events;
  bool stopping;

  void dump(const char *caller = 0) const;

public:

  SafeTimer(const SafeTimer&) = delete;
  SafeTimer& operator=(const SafeTimer&) = delete;
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/Timer.h"
  SafeTimer(CephContext *cct, Mutex &l, bool safe_callbacks=true);
  virtual ~SafeTimer();







  void init();
  void shutdown();



  Context* add_event_after(double seconds, Context *callback);
  Context* add_event_at(utime_t when, Context *callback);







  bool cancel_event(Context *callback);







  void cancel_all_events();

};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 2
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
class RGWCoroutinesStack;
class RGWCoroutinesManager;
class RGWAioCompletionNotifier;

class RGWCompletionManager : public RefCountedObject {
  friend class RGWCoroutinesManager;

  CephContext *cct;

  struct io_completion {
    rgw_io_id io_id;
    void *user_info;
  };
  list<io_completion> complete_reqs;
  set<rgw_io_id> complete_reqs_set;
  using NotifierRef = boost::intrusive_ptr<RGWAioCompletionNotifier>;
  set<NotifierRef> cns;

  Mutex lock;
  Cond cond;

  SafeTimer timer;

  std::atomic<bool> going_down = { false };

  map<void *, void *> waiters;

  class WaitContext;

protected:
  void _wakeup(void *opaque);
  void _complete(RGWAioCompletionNotifier *cn, const rgw_io_id& io_id, void *user_info);
public:
  explicit RGWCompletionManager(CephContext *_cct);
  ~RGWCompletionManager() override;

  void complete(RGWAioCompletionNotifier *cn, const rgw_io_id& io_id, void *user_info);
  int get_next(io_completion *io);
  bool try_get_next(io_completion *io);

  void go_down();




  void wait_interval(void *opaque, const utime_t& interval, void *user_info);
  void wakeup(void *opaque);

  void register_completion_notifier(RGWAioCompletionNotifier *cn);
  void unregister_completion_notifier(RGWAioCompletionNotifier *cn);
};


class RGWAioCompletionNotifier : public RefCountedObject {
  librados::AioCompletion *c;
  RGWCompletionManager *completion_mgr;
  rgw_io_id io_id;
  void *user_data;
  Mutex lock;
  bool registered;

public:
  RGWAioCompletionNotifier(RGWCompletionManager *_mgr, const rgw_io_id& _io_id, void *_user_data);
  ~RGWAioCompletionNotifier() override {
    c->release();
    lock.Lock();
    bool need_unregister = registered;
    if (registered) {
      completion_mgr->get();
    }
    registered = false;
    lock.Unlock();
    if (need_unregister) {
      completion_mgr->unregister_completion_notifier(this);
      completion_mgr->put();
    }
  }

  librados::AioCompletion *completion() {
    return c;
  }

  void unregister() {
    Mutex::Locker l(lock);
    if (!registered) {
      return;
    }
    registered = false;
  }

  void cb() {
    lock.Lock();
    if (!registered) {
      lock.Unlock();
      put();
      return;
    }
    completion_mgr->get();
    registered = false;
    lock.Unlock();
    completion_mgr->complete(this, io_id, user_data);
    completion_mgr->put();
    put();
  }
};


template <typename T>
class RGWAioCompletionNotifierWith : public RGWAioCompletionNotifier {
  T value;
public:
  RGWAioCompletionNotifierWith(RGWCompletionManager *mgr,
                               const rgw_io_id& io_id, void *user_data,
                               T value)
    : RGWAioCompletionNotifier(mgr, io_id, user_data), value(std::move(value))
  {}
};

struct RGWCoroutinesEnv {
  uint64_t run_context;
  RGWCoroutinesManager *manager;
  list<RGWCoroutinesStack *> *scheduled_stacks;
  RGWCoroutinesStack *stack;

  RGWCoroutinesEnv() : run_context(0), manager(
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 3 4
                                              __null
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
                                                  ), scheduled_stacks(
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 3 4
                                                                      __null
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
                                                                          ), stack(
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 3 4
                                                                                   __null
# 156 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
                                                                                       ) {}
};

enum RGWCoroutineState {
  RGWCoroutine_Error = -2,
  RGWCoroutine_Done = -1,
  RGWCoroutine_Run = 0,
};

struct rgw_spawned_stacks {
  vector<RGWCoroutinesStack *> entries;

  rgw_spawned_stacks() {}

  void add_pending(RGWCoroutinesStack *s) {
    entries.push_back(s);
  }

  void inherit(rgw_spawned_stacks *source) {
    for (vector<RGWCoroutinesStack *>::iterator iter = source->entries.begin();
         iter != source->entries.end(); ++iter) {
      add_pending(*iter);
    }
    source->entries.clear();
  }
};



class RGWCoroutine : public RefCountedObject, public boost::asio::coroutine {
  friend class RGWCoroutinesStack;

  struct StatusItem {
    utime_t timestamp;
    string status;

    StatusItem(utime_t& t, const string& s) : timestamp(t), status(s) {}

    void dump(Formatter *f) const;
  };



  struct Status {
    CephContext *cct;
    RWLock lock;
    int max_history;

    utime_t timestamp;
    stringstream status;

    explicit Status(CephContext *_cct) : cct(_cct), lock("RGWCoroutine::Status::lock"), max_history(10) {}

    deque<StatusItem> history;

    stringstream& set_status();
  } status;

  stringstream description;

protected:
  bool _yield_ret;
  boost::asio::coroutine drain_cr;

  CephContext *cct;

  RGWCoroutinesStack *stack;
  int retcode;
  int state;

  rgw_spawned_stacks spawned;

  stringstream error_stream;

  int set_state(int s, int ret = 0) {
    retcode = ret;
    state = s;
    return ret;
  }
  int set_cr_error(int ret) {
    return set_state(RGWCoroutine_Error, ret);
  }
  int set_cr_done() {
    return set_state(RGWCoroutine_Done, 0);
  }
  void set_io_blocked(bool flag);

  void reset_description() {
    description.str(string());
  }

  stringstream& set_description() {
    return description;
  }
  stringstream& set_status() {
    return status.set_status();
  }

  stringstream& set_status(const string& s) {
    stringstream& status = set_status();
    status << s;
    return status;
  }

  virtual int operate_wrapper() {
    return operate();
  }
public:
  RGWCoroutine(CephContext *_cct) : status(_cct), _yield_ret(false), cct(_cct), stack(
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 3 4
                                                                                     __null
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
                                                                                         ), retcode(0), state(RGWCoroutine_Run) {}
  ~RGWCoroutine() override;

  virtual int operate() = 0;

  bool is_done() { return (state == RGWCoroutine_Done || state == RGWCoroutine_Error); }
  bool is_error() { return (state == RGWCoroutine_Error); }

  stringstream& log_error() { return error_stream; }
  string error_str() {
    return error_stream.str();
  }

  void set_retcode(int r) {
    retcode = r;
  }

  int get_ret_status() {
    return retcode;
  }

  void call(RGWCoroutine *op);
  RGWCoroutinesStack *spawn(RGWCoroutine *op, bool wait);
  bool collect(int *ret, RGWCoroutinesStack *skip_stack);
  bool collect_next(int *ret, RGWCoroutinesStack **collected_stack = 
# 288 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 3 4
                                                                    __null
# 288 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
                                                                        );

  int wait(const utime_t& interval);
  bool drain_children(int num_cr_left, RGWCoroutinesStack *skip_stack = 
# 291 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 3 4
                                                                       __null
# 291 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
                                                                           );
  void wakeup();
  void set_sleeping(bool flag);

  size_t num_spawned() {
    return spawned.entries.size();
  }

  void wait_for_child();

  virtual string to_str() const;

  RGWCoroutinesStack *get_stack() const {
    return stack;
  }

  RGWCoroutinesEnv *get_env() const;

  void dump(Formatter *f) const;

  void init_new_io(RGWIOProvider *io_provider);

  int io_block(int ret = 0) {
    return io_block(ret, -1);
  }
  int io_block(int ret, int64_t io_id);
  int io_block(int ret, const rgw_io_id& io_id);
  void io_complete() {
    io_complete(rgw_io_id{});
  }
  void io_complete(const rgw_io_id& io_id);
};

ostream& operator<<(ostream& out, const RGWCoroutine& cr);
# 346 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
template <class T>
class RGWConsumerCR : public RGWCoroutine {
  list<T> product;

public:
  explicit RGWConsumerCR(CephContext *_cct) : RGWCoroutine(_cct) {}

  bool has_product() {
    return !product.empty();
  }

  void wait_for_product() {
    if (!has_product()) {
      set_sleeping(true);
    }
  }

  bool consume(T *p) {
    if (product.empty()) {
      return false;
    }
    *p = product.front();
    product.pop_front();
    return true;
  }

  void receive(const T& p, bool wakeup = true);
  void receive(list<T>& l, bool wakeup = true);
};

class RGWCoroutinesStack : public RefCountedObject {
  friend class RGWCoroutine;
  friend class RGWCoroutinesManager;

  CephContext *cct;

  RGWCoroutinesManager *ops_mgr;

  list<RGWCoroutine *> ops;
  list<RGWCoroutine *>::iterator pos;

  rgw_spawned_stacks spawned;

  set<RGWCoroutinesStack *> blocked_by_stack;
  set<RGWCoroutinesStack *> blocking_stacks;

  map<int64_t, rgw_io_id> io_finish_ids;
  rgw_io_id io_blocked_id;

  bool done_flag;
  bool error_flag;
  bool blocked_flag;
  bool sleep_flag;
  bool interval_wait_flag;

  bool is_scheduled;

  bool is_waiting_for_child;

  int retcode;

  uint64_t run_count;

protected:
  RGWCoroutinesEnv *env;
  RGWCoroutinesStack *parent;

  RGWCoroutinesStack *spawn(RGWCoroutine *source_op, RGWCoroutine *next_op, bool wait);
  bool collect(RGWCoroutine *op, int *ret, RGWCoroutinesStack *skip_stack);
  bool collect_next(RGWCoroutine *op, int *ret, RGWCoroutinesStack **collected_stack);
public:
  RGWCoroutinesStack(CephContext *_cct, RGWCoroutinesManager *_ops_mgr, RGWCoroutine *start = 
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h" 3 4
                                                                                             __null
# 417 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_coroutine.h"
                                                                                                 );
  ~RGWCoroutinesStack() override;

  int operate(RGWCoroutinesEnv *env);

  bool is_done() {
    return done_flag;
  }
  bool is_error() {
    return error_flag;
  }
  bool is_blocked_by_stack() {
    return !blocked_by_stack.empty();
  }
  void set_io_blocked(bool flag) {
    blocked_flag = flag;
  }
  void set_io_blocked_id(const rgw_io_id& io_id) {
    io_blocked_id = io_id;
  }
  bool is_io_blocked() {
    return blocked_flag && !done_flag;
  }
  bool can_io_unblock(const rgw_io_id& io_id) {
    return ((io_blocked_id.id < 0) ||
            io_blocked_id.intersects(io_id));
  }
  bool try_io_unblock(const rgw_io_id& io_id);
  bool consume_io_finish(const rgw_io_id& io_id);
  void set_interval_wait(bool flag) {
    interval_wait_flag = flag;
  }
  bool is_interval_waiting() {
    return interval_wait_flag;
  }
  void set_sleeping(bool flag) {
    bool wakeup = sleep_flag & !flag;
    sleep_flag = flag;
    if (wakeup) {
      schedule();
    }
  }
  bool is_sleeping() {
    return sleep_flag;
  }
  void set_is_scheduled(bool flag) {
    is_scheduled = flag;
  }

  bool is_blocked() {
    return is_blocked_by_stack() || is_sleeping() ||
          is_io_blocked() || waiting_for_child() ;
  }

  void schedule();
  void _schedule();

  int get_ret_status() {
    return retcode;
  }

  string error_str();

  void call(RGWCoroutine *next_op);
  RGWCoroutinesStack *spawn(RGWCoroutine *next_op, bool wait);
  int unwind(int retcode);

  int wait(const utime_t& interval);
  void wakeup();
  void io_complete() {
    io_complete(rgw_io_id{});
  }
  void io_complete(const rgw_io_id& io_id);

  bool collect(int *ret, RGWCoroutinesStack *skip_stack);

  void cancel();

  RGWAioCompletionNotifier *create_completion_notifier();
  template <typename T>
  RGWAioCompletionNotifier *create_completion_notifier(T value);
  RGWCompletionManager *get_completion_mgr();

  void set_blocked_by(RGWCoroutinesStack *s) {
    blocked_by_stack.insert(s);
    s->blocking_stacks.insert(this);
  }

  void set_wait_for_child(bool flag) {
    is_waiting_for_child = flag;
  }

  bool waiting_for_child() {
    return is_waiting_for_child;
  }

  bool unblock_stack(RGWCoroutinesStack **s);

  RGWCoroutinesEnv *get_env() const { return env; }

  void dump(Formatter *f) const;

  void init_new_io(RGWIOProvider *io_provider);
};

template <class T>
void RGWConsumerCR<T>::receive(list<T>& l, bool wakeup)
{
  product.splice(product.end(), l);
  if (wakeup) {
    set_sleeping(false);
  }
}


template <class T>
void RGWConsumerCR<T>::receive(const T& p, bool wakeup)
{
  product.push_back(p);
  if (wakeup) {
    set_sleeping(false);
  }
}

class RGWCoroutinesManagerRegistry : public RefCountedObject, public AdminSocketHook {
  CephContext *cct;

  set<RGWCoroutinesManager *> managers;
  RWLock lock;

  string admin_command;

public:
  explicit RGWCoroutinesManagerRegistry(CephContext *_cct) : cct(_cct), lock("RGWCoroutinesRegistry::lock") {}
  ~RGWCoroutinesManagerRegistry() override;

  void add(RGWCoroutinesManager *mgr);
  void remove(RGWCoroutinesManager *mgr);

  int hook_to_admin_command(const string& command);
  bool call(std::string_view command, const cmdmap_t& cmdmap,
            std::string_view format, bufferlist& out) override;

  void dump(Formatter *f) const;
};

class RGWCoroutinesManager {
  CephContext *cct;
  std::atomic<bool> going_down = { false };

  std::atomic<int64_t> run_context_count = { 0 };
  map<uint64_t, set<RGWCoroutinesStack *> > run_contexts;

  std::atomic<int64_t> max_io_id = { 0 };

  RWLock lock;

  RGWIOIDProvider io_id_provider;

  void handle_unblocked_stack(set<RGWCoroutinesStack *>& context_stacks, list<RGWCoroutinesStack *>& scheduled_stacks,
                              RGWCompletionManager::io_completion& io, int *waiting_count);
protected:
  RGWCompletionManager *completion_mgr;
  RGWCoroutinesManagerRegistry *cr_registry;

  int ops_window;

  string id;

  void put_completion_notifier(RGWAioCompletionNotifier *cn);
public:
  RGWCoroutinesManager(CephContext *_cct, RGWCoroutinesManagerRegistry *_cr_registry) : cct(_cct), lock("RGWCoroutinesManager::lock"),
                                                                                        cr_registry(_cr_registry), ops_window(100) {
    completion_mgr = new RGWCompletionManager(cct);
    if (cr_registry) {
      cr_registry->add(this);
    }
  }
  virtual ~RGWCoroutinesManager() {
    stop();
    completion_mgr->put();
    if (cr_registry) {
      cr_registry->remove(this);
    }
  }

  int run(list<RGWCoroutinesStack *>& ops);
  int run(RGWCoroutine *op);
  void stop() {
    bool expected = false;
    if (going_down.compare_exchange_strong(expected, true)) {
      completion_mgr->go_down();
    }
  }

  virtual void report_error(RGWCoroutinesStack *op);

  RGWAioCompletionNotifier *create_completion_notifier(RGWCoroutinesStack *stack);
  template <typename T>
  RGWAioCompletionNotifier *create_completion_notifier(RGWCoroutinesStack *stack, T value);
  RGWCompletionManager *get_completion_mgr() { return completion_mgr; }

  void schedule(RGWCoroutinesEnv *env, RGWCoroutinesStack *stack);
  void _schedule(RGWCoroutinesEnv *env, RGWCoroutinesStack *stack);
  RGWCoroutinesStack *allocate_stack();

  int64_t get_next_io_id();

  void set_sleeping(RGWCoroutine *cr, bool flag);
  void io_complete(RGWCoroutine *cr, const rgw_io_id& io_id);

  virtual string get_id();
  void dump(Formatter *f) const;

  RGWIOIDProvider& get_io_id_provider() {
    return io_id_provider;
  }
};

template <typename T>
RGWAioCompletionNotifier *RGWCoroutinesManager::create_completion_notifier(RGWCoroutinesStack *stack, T value)
{
  rgw_io_id io_id{get_next_io_id(), -1};
  RGWAioCompletionNotifier *cn = new RGWAioCompletionNotifierWith<T>(completion_mgr, io_id, (void *)stack, std::move(value));
  completion_mgr->register_completion_notifier(cn);
  return cn;
}

template <typename T>
RGWAioCompletionNotifier *RGWCoroutinesStack::create_completion_notifier(T value)
{
  return ops_mgr->create_completion_notifier(this, std::move(value));
}

class RGWSimpleCoroutine : public RGWCoroutine {
  bool called_cleanup;

  int operate() override;

  int state_init();
  int state_send_request();
  int state_request_complete();
  int state_all_complete();

  void call_cleanup();

public:
  RGWSimpleCoroutine(CephContext *_cct) : RGWCoroutine(_cct), called_cleanup(false) {}
  ~RGWSimpleCoroutine() override;

  virtual int init() { return 0; }
  virtual int send_request() = 0;
  virtual int request_complete() = 0;
  virtual int finish() { return 0; }
  virtual void request_cleanup() {}
};
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_module.h" 2

class RGWBucketInfo;
class RGWRemoteDataLog;
struct RGWDataSyncEnv;
struct rgw_bucket_entry_owner;
struct rgw_obj_key;


class RGWDataSyncModule {
public:
  RGWDataSyncModule() {}
  virtual ~RGWDataSyncModule() {}

  virtual void init(RGWDataSyncEnv *sync_env, uint64_t instance_id) {}

  virtual RGWCoroutine *init_sync(RGWDataSyncEnv *sync_env) {
    return nullptr;
  }

  virtual RGWCoroutine *start_sync(RGWDataSyncEnv *sync_env) {
    return nullptr;
  }
  virtual RGWCoroutine *sync_object(RGWDataSyncEnv *sync_env, RGWBucketInfo& bucket_info, rgw_obj_key& key, std::optional<uint64_t> versioned_epoch, rgw_zone_set *zones_trace) = 0;
  virtual RGWCoroutine *remove_object(RGWDataSyncEnv *sync_env, RGWBucketInfo& bucket_info, rgw_obj_key& key, real_time& mtime,
                                      bool versioned, uint64_t versioned_epoch, rgw_zone_set *zones_trace) = 0;
  virtual RGWCoroutine *create_delete_marker(RGWDataSyncEnv *sync_env, RGWBucketInfo& bucket_info, rgw_obj_key& key, real_time& mtime,
                                             rgw_bucket_entry_owner& owner, bool versioned, uint64_t versioned_epoch, rgw_zone_set *zones_trace) = 0;
};

class RGWRESTMgr;
class RGWMetadataHandler;

class RGWSyncModuleInstance {
public:
  RGWSyncModuleInstance() {}
  virtual ~RGWSyncModuleInstance() {}
  virtual RGWDataSyncModule *get_data_handler() = 0;
  virtual RGWRESTMgr *get_rest_filter(int dialect, RGWRESTMgr *orig) {
    return orig;
  }
  virtual bool supports_user_writes() {
    return false;
  }
  virtual RGWMetadataHandler *alloc_bucket_meta_handler();
  virtual RGWMetadataHandler *alloc_bucket_instance_meta_handler();



  virtual bool should_full_sync() const {
      return true;
  }
};

typedef std::shared_ptr<RGWSyncModuleInstance> RGWSyncModuleInstanceRef;

class JSONFormattable;

class RGWSyncModule {

public:
  RGWSyncModule() {}
  virtual ~RGWSyncModule() {}

  virtual bool supports_writes() {
    return false;
  }
  virtual bool supports_data_export() = 0;
  virtual int create_instance(CephContext *cct, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) = 0;
};

typedef std::shared_ptr<RGWSyncModule> RGWSyncModuleRef;


class RGWSyncModulesManager {
  Mutex lock;

  map<string, RGWSyncModuleRef> modules;
public:
  RGWSyncModulesManager() : lock("RGWSyncModulesManager") {}

  void register_module(const string& name, RGWSyncModuleRef& module, bool is_default = false) {
    Mutex::Locker l(lock);
    modules[name] = module;
    if (is_default) {
      modules[string()] = module;
    }
  }

  bool get_module(const string& name, RGWSyncModuleRef *module) {
    Mutex::Locker l(lock);
    auto iter = modules.find(name);
    if (iter == modules.end()) {
      return false;
    }
    if (module != nullptr) {
      *module = iter->second;
    }
    return true;
  }


  int supports_data_export(const string& name) {
    RGWSyncModuleRef module;
    if (!get_module(name, &module)) {
      return -
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_module.h" 3 4
             2
# 113 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_module.h"
                   ;
    }

    return module.get()->supports_data_export();
  }

  int create_instance(CephContext *cct, const string& name, const JSONFormattable& config, RGWSyncModuleInstanceRef *instance) {
    RGWSyncModuleRef module;
    if (!get_module(name, &module)) {
      return -
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_module.h" 3 4
             2
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_module.h"
                   ;
    }

    return module.get()->create_instance(cct, config, instance);
  }

  vector<string> get_registered_module_names() const {
    vector<string> names;
    for (auto& i: modules) {
      if (!i.first.empty()) {
        names.push_back(i.first);
      }
    }
    return names;
  }
};

class RGWStatRemoteObjCBCR : public RGWCoroutine {
protected:
  RGWDataSyncEnv *sync_env;

  RGWBucketInfo bucket_info;
  rgw_obj_key key;

  ceph::real_time mtime;
  uint64_t size = 0;
  string etag;
  map<string, bufferlist> attrs;
  map<string, string> headers;
public:
  RGWStatRemoteObjCBCR(RGWDataSyncEnv *_sync_env,
                       RGWBucketInfo& _bucket_info, rgw_obj_key& _key);
  ~RGWStatRemoteObjCBCR() override {}

  void set_result(ceph::real_time& _mtime,
                  uint64_t _size,
                  const string& _etag,
                  map<string, bufferlist>&& _attrs,
                  map<string, string>&& _headers) {
    mtime = _mtime;
    size = _size;
    etag = _etag;
    attrs = std::move(_attrs);
    headers = std::move(_headers);
  }
};

class RGWCallStatRemoteObjCR : public RGWCoroutine {
  ceph::real_time mtime;
  uint64_t size{0};
  string etag;
  map<string, bufferlist> attrs;
  map<string, string> headers;

protected:
  RGWDataSyncEnv *sync_env;

  RGWBucketInfo bucket_info;
  rgw_obj_key key;

public:
  RGWCallStatRemoteObjCR(RGWDataSyncEnv *_sync_env,
                     RGWBucketInfo& _bucket_info, rgw_obj_key& _key);

  ~RGWCallStatRemoteObjCR() override {}

  int operate() override;

  virtual RGWStatRemoteObjCBCR *allocate_callback() {
    return nullptr;
  }
};

void rgw_register_sync_modules(RGWSyncModulesManager *modules_manager);
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_log_trim.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sync_log_trim.h"
class CephContext;
class RGWCoroutine;
class RGWHTTPManager;
class RGWRados;

namespace rgw {


struct BucketChangeObserver {
  virtual ~BucketChangeObserver() = default;

  virtual void on_bucket_changed(const boost::string_view& bucket_instance) = 0;
};


struct BucketTrimConfig {

  uint32_t trim_interval_sec{0};

  size_t counter_size{0};

  uint32_t buckets_per_interval{0};

  uint32_t min_cold_buckets_per_interval{0};

  uint32_t concurrent_buckets{0};

  uint64_t notify_timeout_ms{0};


  size_t recent_size{0};


  ceph::timespan recent_duration{0};
};


void configure_bucket_trim(CephContext *cct, BucketTrimConfig& config);





class BucketTrimManager : public BucketChangeObserver {
  class Impl;
  std::unique_ptr<Impl> impl;
 public:
  BucketTrimManager(RGWRados *store, const BucketTrimConfig& config);
  ~BucketTrimManager();

  int init();


  void on_bucket_changed(const boost::string_view& bucket_instance) override;


  RGWCoroutine* create_bucket_trim_cr(RGWHTTPManager *http);


  RGWCoroutine* create_admin_bucket_trim_cr(RGWHTTPManager *http);
};



struct BucketTrimStatus {
  std::string marker;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& p) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, p); decode(struct_compat, p); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, p); if (struct_len > p.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = p.get_off() + struct_len; do {;
    decode(marker, p);
    } while (false); if (struct_end) { if (p.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (p.get_off() < struct_end) p.advance(struct_end - p.get_off()); };
  }

  static const std::string oid;
};

}

inline void encode(const rgw::BucketTrimStatus &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw::BucketTrimStatus &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); };
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_service.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_service.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_common.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_service.h" 2

struct RGWServices_Def;

class RGWServiceInstance
{
  friend struct RGWServices_Def;

protected:
  CephContext *cct;

  enum StartState {
    StateInit = 0,
    StateStarting = 1,
    StateStarted = 2,
  } start_state{StateInit};

  virtual void shutdown() {}
  virtual int do_start() {
    return 0;
  }
public:
  RGWServiceInstance(CephContext *_cct) : cct(_cct) {}
  virtual ~RGWServiceInstance() {}

  int start();
  bool is_started() {
    return (start_state == StateStarted);
  }

  CephContext *ctx() {
    return cct;
  }
};

class RGWSI_Finisher;
class RGWSI_Notify;
class RGWSI_RADOS;
class RGWSI_Zone;
class RGWSI_ZoneUtils;
class RGWSI_Quota;
class RGWSI_SyncModules;
class RGWSI_SysObj;
class RGWSI_SysObj_Core;
class RGWSI_SysObj_Cache;

struct RGWServices_Def
{
  bool can_shutdown{false};
  bool has_shutdown{false};

  std::unique_ptr<RGWSI_Finisher> finisher;
  std::unique_ptr<RGWSI_Notify> notify;
  std::unique_ptr<RGWSI_RADOS> rados;
  std::unique_ptr<RGWSI_Zone> zone;
  std::unique_ptr<RGWSI_ZoneUtils> zone_utils;
  std::unique_ptr<RGWSI_Quota> quota;
  std::unique_ptr<RGWSI_SyncModules> sync_modules;
  std::unique_ptr<RGWSI_SysObj> sysobj;
  std::unique_ptr<RGWSI_SysObj_Core> sysobj_core;
  std::unique_ptr<RGWSI_SysObj_Cache> sysobj_cache;

  RGWServices_Def();
  ~RGWServices_Def();

  int init(CephContext *cct, bool have_cache, bool raw_storage);
  void shutdown();
};


struct RGWServices
{
  RGWServices_Def _svc;

  RGWSI_Finisher *finisher{nullptr};
  RGWSI_Notify *notify{nullptr};
  RGWSI_RADOS *rados{nullptr};
  RGWSI_Zone *zone{nullptr};
  RGWSI_ZoneUtils *zone_utils{nullptr};
  RGWSI_Quota *quota{nullptr};
  RGWSI_SyncModules *sync_modules{nullptr};
  RGWSI_SysObj *sysobj{nullptr};
  RGWSI_SysObj_Cache *cache{nullptr};
  RGWSI_SysObj_Core *core{nullptr};

  int do_init(CephContext *cct, bool have_cache, bool raw_storage);

  int init(CephContext *cct, bool have_cache) {
    return do_init(cct, have_cache, false);
  }

  int init_raw(CephContext *cct, bool have_cache) {
    return do_init(cct, have_cache, true);
  }
  void shutdown() {
    _svc.shutdown();
  }
};
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_rados.h" 1




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_service.h" 1
# 6 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_rados.h" 2




class RGWAccessListFilter {
public:
  virtual ~RGWAccessListFilter() {}
  virtual bool filter(const string& name, string& key) = 0;
};

struct RGWAccessListFilterPrefix : public RGWAccessListFilter {
  string prefix;

  explicit RGWAccessListFilterPrefix(const string& _prefix) : prefix(_prefix) {}
  bool filter(const string& name, string& key) override {
    return (prefix.compare(key.substr(0, prefix.size())) == 0);
  }
};

struct rgw_rados_ref {
  rgw_raw_obj obj;
  librados::IoCtx ioctx;
};

class RGWSI_RADOS : public RGWServiceInstance
{
  librados::Rados rados;

  int do_start() override;

  librados::Rados* get_rados_handle();
  int open_pool_ctx(const rgw_pool& pool, librados::IoCtx& io_ctx);
  int pool_iterate(librados::IoCtx& ioctx,
                   librados::NObjectIterator& iter,
                   uint32_t num, vector<rgw_bucket_dir_entry>& objs,
                   RGWAccessListFilter *filter,
                   bool *is_truncated);

public:
  RGWSI_RADOS(CephContext *cct) : RGWServiceInstance(cct) {}

  void init() {}

  uint64_t instance_id();

  class Handle;

  class Obj {
    friend class RGWSI_RADOS;
    friend Handle;

    RGWSI_RADOS *rados_svc{nullptr};
    rgw_rados_ref ref;

    void init(const rgw_raw_obj& obj);

    Obj(RGWSI_RADOS *_rados_svc, const rgw_raw_obj& _obj)
      : rados_svc(_rados_svc) {
      init(_obj);
    }

  public:
    Obj() {}

    int open();

    int operate(librados::ObjectWriteOperation *op, optional_yield y);
    int operate(librados::ObjectReadOperation *op, bufferlist *pbl,
                optional_yield y);
    int aio_operate(librados::AioCompletion *c, librados::ObjectWriteOperation *op);
    int aio_operate(librados::AioCompletion *c, librados::ObjectReadOperation *op,
                    bufferlist *pbl);

    int watch(uint64_t *handle, librados::WatchCtx2 *ctx);
    int aio_watch(librados::AioCompletion *c, uint64_t *handle, librados::WatchCtx2 *ctx);
    int unwatch(uint64_t handle);
    int notify(bufferlist& bl,
               uint64_t timeout_ms,
               bufferlist *pbl);
    void notify_ack(uint64_t notify_id,
                    uint64_t cookie,
                    bufferlist& bl);

    uint64_t get_last_version();

    rgw_rados_ref& get_ref() { return ref; }
    const rgw_rados_ref& get_ref() const { return ref; }
  };

  class Pool {
    friend class RGWSI_RADOS;
    friend Handle;

    RGWSI_RADOS *rados_svc{nullptr};
    rgw_pool pool;

    Pool(RGWSI_RADOS *_rados_svc,
         const rgw_pool& _pool) : rados_svc(_rados_svc),
                                  pool(_pool) {}

    Pool(RGWSI_RADOS *_rados_svc) : rados_svc(_rados_svc) {}
  public:
    Pool() {}

    int create();
    int create(const std::vector<rgw_pool>& pools, std::vector<int> *retcodes);
    int lookup();

    struct List {
      Pool& pool;

      struct Ctx {
        bool initialized{false};
        librados::IoCtx ioctx;
        librados::NObjectIterator iter;
        RGWAccessListFilter *filter{nullptr};
      } ctx;

      List(Pool& _pool) : pool(_pool) {}

      int init(const string& marker, RGWAccessListFilter *filter = nullptr);
      int get_next(int max,
                   std::list<string> *oids,
                   bool *is_truncated);
    };

    List op() {
      return List(*this);
    }

    friend List;
  };

  class Handle {
    friend class RGWSI_RADOS;

    RGWSI_RADOS *rados_svc{nullptr};

    Handle(RGWSI_RADOS *_rados_svc) : rados_svc(_rados_svc) {}
  public:
    Obj obj(const rgw_raw_obj& o) {
      return Obj(rados_svc, o);
    }

    Pool pool(const rgw_pool& p) {
      return Pool(rados_svc, p);
    }

    int watch_flush();
  };

  Handle handle() {
    return Handle(this);
  }

  Obj obj(const rgw_raw_obj& o) {
    return Obj(this, o);
  }

  Pool pool() {
    return Pool(this);
  }

  Pool pool(const rgw_pool& p) {
    return Pool(this, p);
  }

  friend Obj;
  friend Pool;
  friend Pool::List;
};
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_zone.h" 1







class RGWSI_RADOS;
class RGWSI_SysObj;
class RGWSI_SyncModules;

class RGWRealm;
class RGWZoneGroup;
class RGWZone;
class RGWZoneParams;
class RGWPeriod;
class RGWZonePlacementInfo;

class RGWRESTConn;

class RGWSI_Zone : public RGWServiceInstance
{
  friend struct RGWServices_Def;

  RGWSI_SysObj *sysobj_svc{nullptr};
  RGWSI_RADOS *rados_svc{nullptr};
  RGWSI_SyncModules *sync_modules_svc{nullptr};

  RGWRealm *realm{nullptr};
  RGWZoneGroup *zonegroup{nullptr};
  RGWZone *zone_public_config{nullptr};
  RGWZoneParams *zone_params{nullptr};
  RGWPeriod *current_period{nullptr};
  uint32_t zone_short_id{0};
  bool writeable_zone{false};

  RGWRESTConn *rest_master_conn{nullptr};
  map<string, RGWRESTConn *> zone_conn_map;
  std::vector<const RGWZone*> data_sync_source_zones;
  map<string, RGWRESTConn *> zone_data_notify_to_map;
  map<string, RGWRESTConn *> zonegroup_conn_map;

  map<string, string> zone_id_by_name;
  map<string, RGWZone> zone_by_id;

  void init(RGWSI_SysObj *_sysobj_svc,
           RGWSI_RADOS *_rados_svc,
           RGWSI_SyncModules *_sync_modules_svc);
  int do_start() override;
  void shutdown() override;

  int replace_region_with_zonegroup();
  int init_zg_from_period(bool *initialized);
  int init_zg_from_local(bool *creating_defaults);
  int convert_regionmap();

  int update_placement_map();
public:
  RGWSI_Zone(CephContext *cct);
  ~RGWSI_Zone();

  const RGWZoneParams& get_zone_params() const;
  const RGWPeriod& get_current_period() const;
  const RGWRealm& get_realm() const;
  const RGWZoneGroup& get_zonegroup() const;
  int get_zonegroup(const string& id, RGWZoneGroup& zonegroup) const;
  const RGWZone& get_zone() const;

  const string& zone_name();
  const string& zone_id();
  uint32_t get_zone_short_id() const;

  const string& get_current_period_id();
  bool has_zonegroup_api(const std::string& api) const;

  bool zone_is_writeable();
  bool zone_syncs_from(const RGWZone& target_zone, const RGWZone& source_zone) const;
  bool get_redirect_zone_endpoint(string *endpoint);

  RGWRESTConn *get_master_conn() {
    return rest_master_conn;
  }

  map<string, RGWRESTConn *>& get_zonegroup_conn_map() {
    return zonegroup_conn_map;
  }

  map<string, RGWRESTConn *>& get_zone_conn_map() {
    return zone_conn_map;
  }

  std::vector<const RGWZone*>& get_data_sync_source_zones() {
    return data_sync_source_zones;
  }

  map<string, RGWRESTConn *>& get_zone_data_notify_to_map() {
    return zone_data_notify_to_map;
  }

  bool find_zone_by_id(const string& id, RGWZone **zone);

  RGWRESTConn *get_zone_conn_by_id(const string& id);
  RGWRESTConn *get_zone_conn_by_name(const string& name);
  bool find_zone_id_by_name(const string& name, string *id);

  int select_bucket_placement(const RGWUserInfo& user_info, const string& zonegroup_id,
                              const rgw_placement_rule& rule,
                              rgw_placement_rule *pselected_rule, RGWZonePlacementInfo *rule_info);
  int select_legacy_bucket_placement(RGWZonePlacementInfo *rule_info);
  int select_new_bucket_location(const RGWUserInfo& user_info, const string& zonegroup_id,
                                 const rgw_placement_rule& rule,
                                 rgw_placement_rule *pselected_rule_name, RGWZonePlacementInfo *rule_info);
  int select_bucket_location_by_rule(const rgw_placement_rule& location_rule, RGWZonePlacementInfo *rule_info);

  int add_bucket_placement(const rgw_pool& new_pool);
  int remove_bucket_placement(const rgw_pool& old_pool);
  int list_placement_set(set<rgw_pool>& names);

  bool is_meta_master() const;

  bool need_to_log_data() const;
  bool need_to_log_metadata() const;
  bool can_reshard() const;
  bool is_syncing_bucket_meta(const rgw_bucket& bucket);

  int list_zonegroups(list<string>& zonegroups);
  int list_regions(list<string>& regions);
  int list_zones(list<string>& zones);
  int list_realms(list<string>& realms);
  int list_periods(list<string>& periods);
  int list_periods(const string& current_period, list<string>& periods);
};
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 2

class RGWWatcher;
class SafeTimer;
class ACLOwner;
class RGWGC;
class RGWMetaNotifier;
class RGWDataNotifier;
class RGWLC;
class RGWObjectExpirer;
class RGWMetaSyncProcessorThread;
class RGWDataSyncProcessorThread;
class RGWSyncLogTrimThread;
class RGWSyncTraceManager;
struct RGWZoneGroup;
struct RGWZoneParams;
class RGWReshard;
class RGWReshardWait;

class RGWSysObjectCtx;
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
extern const std::string MP_META_SUFFIX;


static inline int rgw_shards_mod(unsigned hval, int max_shards)
{
  if (max_shards <= 7877) {
    return hval % 7877 % max_shards;
  }
  return hval % 65521 % max_shards;
}


static inline int rgw_shard_id(const string& key, int max_shards)
{
  return rgw_shards_mod(ceph_str_hash_linux(key.c_str(), key.size()),
   max_shards);
}


static inline uint32_t rgw_bucket_shard_index(const std::string& key,
           int num_shards) {
  uint32_t sid = ceph_str_hash_linux(key.c_str(), key.size());
  uint32_t sid2 = sid ^ ((sid & 0xFF) << 24);
  return rgw_shards_mod(sid2, num_shards);
}

static inline int rgw_shards_max()
{
  return 65521;
}

static inline void prepend_bucket_marker(const rgw_bucket& bucket, const string& orig_oid, string& oid)
{
  if (bucket.marker.empty() || orig_oid.empty()) {
    oid = orig_oid;
  } else {
    oid = bucket.marker;
    oid.append("_");
    oid.append(orig_oid);
  }
}

static inline void get_obj_bucket_and_oid_loc(const rgw_obj& obj, string& oid, string& locator)
{
  const rgw_bucket& bucket = obj.bucket;
  prepend_bucket_marker(bucket, obj.get_oid(), oid);
  const string& loc = obj.key.get_loc();
  if (!loc.empty()) {
    prepend_bucket_marker(bucket, loc, locator);
  } else {
    locator.clear();
  }
}

int rgw_policy_from_attrset(CephContext *cct, map<string, bufferlist>& attrset, RGWAccessControlPolicy *policy);

static inline bool rgw_raw_obj_to_obj(const rgw_bucket& bucket, const rgw_raw_obj& raw_obj, rgw_obj *obj)
{
  ssize_t pos = raw_obj.oid.find('_');
  if (pos < 0) {
    return false;
  }

  if (!rgw_obj_key::parse_raw_oid(raw_obj.oid.substr(pos + 1), &obj->key)) {
    return false;
  }
  obj->bucket = bucket;

  return true;
}


struct rgw_bucket_placement {
  rgw_placement_rule placement_rule;
  rgw_bucket bucket;

  void dump(Formatter *f) const;
};

class rgw_obj_select {
  rgw_placement_rule placement_rule;
  rgw_obj obj;
  rgw_raw_obj raw_obj;
  bool is_raw;

public:
  rgw_obj_select() : is_raw(false) {}
  explicit rgw_obj_select(const rgw_obj& _obj) : obj(_obj), is_raw(false) {}
  explicit rgw_obj_select(const rgw_raw_obj& _raw_obj) : raw_obj(_raw_obj), is_raw(true) {}
  rgw_obj_select(const rgw_obj_select& rhs) {
    placement_rule = rhs.placement_rule;
    is_raw = rhs.is_raw;
    if (is_raw) {
      raw_obj = rhs.raw_obj;
    } else {
      obj = rhs.obj;
    }
  }

  rgw_raw_obj get_raw_obj(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params) const;
  rgw_raw_obj get_raw_obj(RGWRados *store) const;

  rgw_obj_select& operator=(const rgw_obj& rhs) {
    obj = rhs;
    is_raw = false;
    return *this;
  }

  rgw_obj_select& operator=(const rgw_raw_obj& rhs) {
    raw_obj = rhs;
    is_raw = true;
    return *this;
  }

  void set_placement_rule(const rgw_placement_rule& rule) {
    placement_rule = rule;
  }
  void dump(Formatter *f) const;
};

struct compression_block {
  uint64_t old_ofs;
  uint64_t new_ofs;
  uint64_t len;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(old_ofs, bl);
    encode(new_ofs, bl);
    encode(len, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(old_ofs, bl);
     decode(new_ofs, bl);
     decode(len, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
};
inline void encode(const compression_block &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(compression_block &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWCompressionInfo {
  string compression_type;
  uint64_t orig_size;
  vector<compression_block> blocks;

  RGWCompressionInfo() : compression_type("none"), orig_size(0) {}
  RGWCompressionInfo(const RGWCompressionInfo& cs_info) : compression_type(cs_info.compression_type),
                                                          orig_size(cs_info.orig_size),
                                                          blocks(cs_info.blocks) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(compression_type, bl);
    encode(orig_size, bl);
    encode(blocks, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(compression_type, bl);
     decode(orig_size, bl);
     decode(blocks, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
};
inline void encode(const RGWCompressionInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWCompressionInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

int rgw_compression_info_from_attrset(map<string, bufferlist>& attrs, bool& need_decompress, RGWCompressionInfo& cs_info);

struct RGWOLHInfo {
  rgw_obj target;
  bool removed;

  RGWOLHInfo() : removed(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(target, bl);
    encode(removed, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(target, bl);
     decode(removed, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<RGWOLHInfo*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const RGWOLHInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWOLHInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWOLHPendingInfo {
  ceph::real_time time;

  RGWOLHPendingInfo() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(time, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(time, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
};
inline void encode(const RGWOLHPendingInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWOLHPendingInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWUsageBatch {
  map<ceph::real_time, rgw_usage_log_entry> m;

  void insert(ceph::real_time& t, rgw_usage_log_entry& entry, bool *account) {
    bool exists = m.find(t) != m.end();
    *account = !exists;
    m[t].aggregate(entry);
  }
};

struct RGWUsageIter {
  string read_iter;
  uint32_t index;

  RGWUsageIter() : index(0) {}
};

class RGWGetDataCB {
public:
  virtual int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) = 0;
  RGWGetDataCB() {}
  virtual ~RGWGetDataCB() {}
};

struct RGWCloneRangeInfo {
  rgw_obj src;
  off_t src_ofs;
  off_t dst_ofs;
  uint64_t len;
};

struct RGWObjManifestPart {
  rgw_obj loc;
  uint64_t loc_ofs;
  uint64_t size;

  RGWObjManifestPart() : loc_ofs(0), size(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(loc, bl);
    encode(loc_ofs, bl);
    encode(size, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } else if (3u) { if (bl.get_remaining() < 3u) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); bl.advance(3u); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
     decode(loc, bl);
     decode(loc_ofs, bl);
     decode(size, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWObjManifestPart*>& o);
};
inline void encode(const RGWObjManifestPart &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWObjManifestPart &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 363 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
struct RGWObjManifestRule {
  uint32_t start_part_num;
  uint64_t start_ofs;
  uint64_t part_size;
  uint64_t stripe_max_size;
  string override_prefix;

  RGWObjManifestRule() : start_part_num(0), start_ofs(0), part_size(0), stripe_max_size(0) {}
  RGWObjManifestRule(uint32_t _start_part_num, uint64_t _start_ofs, uint64_t _part_size, uint64_t _stripe_max_size) :
                       start_part_num(_start_part_num), start_ofs(_start_ofs), part_size(_part_size), stripe_max_size(_stripe_max_size) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(start_part_num, bl);
    encode(start_ofs, bl);
    encode(part_size, bl);
    encode(stripe_max_size, bl);
    encode(override_prefix, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(start_part_num, bl);
    decode(start_ofs, bl);
    decode(part_size, bl);
    decode(stripe_max_size, bl);
    if (struct_v >= 2)
      decode(override_prefix, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
};
inline void encode(const RGWObjManifestRule &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWObjManifestRule &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWObjManifest {
protected:
  bool explicit_objs;
  map<uint64_t, RGWObjManifestPart> objs;

  uint64_t obj_size;

  rgw_obj obj;
  uint64_t head_size;
  rgw_placement_rule head_placement_rule;

  uint64_t max_head_size;
  string prefix;
  rgw_bucket_placement tail_placement;

  map<uint64_t, RGWObjManifestRule> rules;

  string tail_instance;

  void convert_to_explicit(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params);
  int append_explicit(RGWObjManifest& m, const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params);
  void append_rules(RGWObjManifest& m, map<uint64_t, RGWObjManifestRule>::iterator& iter, string *override_prefix);

  void update_iterators() {
    begin_iter.seek(0);
    end_iter.seek(obj_size);
  }
public:

  RGWObjManifest() : explicit_objs(false), obj_size(0), head_size(0), max_head_size(0),
                     begin_iter(this), end_iter(this) {}
  RGWObjManifest(const RGWObjManifest& rhs) {
    *this = rhs;
  }
  RGWObjManifest& operator=(const RGWObjManifest& rhs) {
    explicit_objs = rhs.explicit_objs;
    objs = rhs.objs;
    obj_size = rhs.obj_size;
    obj = rhs.obj;
    head_size = rhs.head_size;
    max_head_size = rhs.max_head_size;
    prefix = rhs.prefix;
    tail_placement = rhs.tail_placement;
    rules = rhs.rules;
    tail_instance = rhs.tail_instance;

    begin_iter.set_manifest(this);
    end_iter.set_manifest(this);

    begin_iter.seek(rhs.begin_iter.get_ofs());
    end_iter.seek(rhs.end_iter.get_ofs());

    return *this;
  }

  map<uint64_t, RGWObjManifestPart>& get_explicit_objs() {
    return objs;
  }


  void set_explicit(uint64_t _size, map<uint64_t, RGWObjManifestPart>& _objs) {
    explicit_objs = true;
    obj_size = _size;
    objs.swap(_objs);
  }

  void get_implicit_location(uint64_t cur_part_id, uint64_t cur_stripe, uint64_t ofs, string *override_prefix, rgw_obj_select *location);

  void set_trivial_rule(uint64_t tail_ofs, uint64_t stripe_max_size) {
    RGWObjManifestRule rule(0, tail_ofs, 0, stripe_max_size);
    rules[0] = rule;
    max_head_size = tail_ofs;
  }

  void set_multipart_part_rule(uint64_t stripe_max_size, uint64_t part_num) {
    RGWObjManifestRule rule(0, 0, 0, stripe_max_size);
    rule.start_part_num = part_num;
    rules[0] = rule;
    max_head_size = 0;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 7; __u8 struct_compat = 6; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(obj_size, bl);
    encode(objs, bl);
    encode(explicit_objs, bl);
    encode(obj, bl);
    encode(head_size, bl);
    encode(max_head_size, bl);
    encode(prefix, bl);
    encode(rules, bl);
    bool encode_tail_bucket = !(tail_placement.bucket == obj.bucket);
    encode(encode_tail_bucket, bl);
    if (encode_tail_bucket) {
      encode(tail_placement.bucket, bl);
    }
    bool encode_tail_instance = (tail_instance != obj.key.instance);
    encode(encode_tail_instance, bl);
    if (encode_tail_instance) {
      encode(tail_instance, bl);
    }
    encode(head_placement_rule, bl);
    encode(tail_placement.placement_rule, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (7 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "7" " < " + std::to_string(struct_compat))); } else if (3u) { if (bl.get_remaining() < 3u) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); bl.advance(3u); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(obj_size, bl);
    decode(objs, bl);
    if (struct_v >= 3) {
      decode(explicit_objs, bl);
      decode(obj, bl);
      decode(head_size, bl);
      decode(max_head_size, bl);
      decode(prefix, bl);
      decode(rules, bl);
    } else {
      explicit_objs = true;
      if (!objs.empty()) {
        map<uint64_t, RGWObjManifestPart>::iterator iter = objs.begin();
        obj = iter->second.loc;
        head_size = iter->second.size;
        max_head_size = head_size;
      }
    }

    if (explicit_objs && head_size > 0 && !objs.empty()) {





      rgw_obj& obj_0 = objs[0].loc;
      if (!obj_0.get_oid().empty() && obj_0.key.ns.empty()) {
        objs[0].loc = obj;
        objs[0].size = head_size;
      }
    }

    if (struct_v >= 4) {
      if (struct_v < 6) {
        decode(tail_placement.bucket, bl);
      } else {
        bool need_to_decode;
        decode(need_to_decode, bl);
        if (need_to_decode) {
          decode(tail_placement.bucket, bl);
        } else {
          tail_placement.bucket = obj.bucket;
        }
      }
    }

    if (struct_v >= 5) {
      if (struct_v < 6) {
        decode(tail_instance, bl);
      } else {
        bool need_to_decode;
        decode(need_to_decode, bl);
        if (need_to_decode) {
          decode(tail_instance, bl);
        } else {
          tail_instance = obj.key.instance;
        }
      }
    } else {
      tail_instance = obj.key.instance;
    }

    if (struct_v >= 7) {
      decode(head_placement_rule, bl);
      decode(tail_placement.placement_rule, bl);
    }

    update_iterators();
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWObjManifest*>& o);

  int append(RGWObjManifest& m, const RGWZoneGroup& zonegroup,
             const RGWZoneParams& zone_params);
  int append(RGWObjManifest& m, RGWSI_Zone *zone_svc);

  bool get_rule(uint64_t ofs, RGWObjManifestRule *rule);

  bool empty() {
    if (explicit_objs)
      return objs.empty();
    return rules.empty();
  }

  bool has_explicit_objs() {
    return explicit_objs;
  }

  bool has_tail() {
    if (explicit_objs) {
      if (objs.size() == 1) {
        map<uint64_t, RGWObjManifestPart>::iterator iter = objs.begin();
        rgw_obj& o = iter->second.loc;
        return !(obj == o);
      }
      return (objs.size() >= 2);
    }
    return (obj_size > head_size);
  }

  void set_head(const rgw_placement_rule& placement_rule, const rgw_obj& _o, uint64_t _s) {
    head_placement_rule = placement_rule;
    obj = _o;
    head_size = _s;

    if (explicit_objs && head_size > 0) {
      objs[0].loc = obj;
      objs[0].size = head_size;
    }
  }

  const rgw_obj& get_obj() {
    return obj;
  }

  void set_tail_placement(const rgw_placement_rule& placement_rule, const rgw_bucket& _b) {
    tail_placement.placement_rule = placement_rule;
    tail_placement.bucket = _b;
  }

  const rgw_bucket_placement& get_tail_placement() {
    return tail_placement;
  }

  const rgw_placement_rule& get_head_placement_rule() {
    return head_placement_rule;
  }

  void set_prefix(const string& _p) {
    prefix = _p;
  }

  const string& get_prefix() {
    return prefix;
  }

  void set_tail_instance(const string& _ti) {
    tail_instance = _ti;
  }

  const string& get_tail_instance() {
    return tail_instance;
  }

  void set_head_size(uint64_t _s) {
    head_size = _s;
  }

  void set_obj_size(uint64_t s) {
    obj_size = s;

    update_iterators();
  }

  uint64_t get_obj_size() {
    return obj_size;
  }

  uint64_t get_head_size() {
    return head_size;
  }

  uint64_t get_max_head_size() {
    return max_head_size;
  }

  class obj_iterator {
    RGWObjManifest *manifest;
    uint64_t part_ofs;
    uint64_t stripe_ofs;
    uint64_t ofs;
    uint64_t stripe_size;

    int cur_part_id;
    int cur_stripe;
    string cur_override_prefix;

    rgw_obj_select location;

    map<uint64_t, RGWObjManifestRule>::iterator rule_iter;
    map<uint64_t, RGWObjManifestRule>::iterator next_rule_iter;

    map<uint64_t, RGWObjManifestPart>::iterator explicit_iter;

    void init() {
      part_ofs = 0;
      stripe_ofs = 0;
      ofs = 0;
      stripe_size = 0;
      cur_part_id = 0;
      cur_stripe = 0;
    }

    void update_explicit_pos();


  protected:

    void set_manifest(RGWObjManifest *m) {
      manifest = m;
    }

  public:
    obj_iterator() : manifest(
# 711 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                             __null
# 711 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                 ) {
      init();
    }
    explicit obj_iterator(RGWObjManifest *_m) : manifest(_m) {
      init();
      if (!manifest->empty()) {
        seek(0);
      }
    }
    obj_iterator(RGWObjManifest *_m, uint64_t _ofs) : manifest(_m) {
      init();
      if (!manifest->empty()) {
        seek(_ofs);
      }
    }
    void seek(uint64_t ofs);

    void operator++();
    bool operator==(const obj_iterator& rhs) {
      return (ofs == rhs.ofs);
    }
    bool operator!=(const obj_iterator& rhs) {
      return (ofs != rhs.ofs);
    }
    const rgw_obj_select& get_location() {
      return location;
    }


    uint64_t get_stripe_ofs() {
      if (manifest->explicit_objs) {
        return explicit_iter->first;
      }
      return stripe_ofs;
    }


    uint64_t get_ofs() const {
      return ofs;
    }


    int get_cur_stripe() const {
      return cur_stripe;
    }


    uint64_t get_stripe_size() {
      if (manifest->explicit_objs) {
        return explicit_iter->second.size;
      }
      return stripe_size;
    }


    uint64_t location_ofs() {
      if (manifest->explicit_objs) {
        return explicit_iter->second.loc_ofs;
      }
      return 0;
    }

    void update_location();

    friend class RGWObjManifest;
    void dump(Formatter *f) const;
  };

  const obj_iterator& obj_begin();
  const obj_iterator& obj_end();
  obj_iterator obj_find(uint64_t ofs);

  obj_iterator begin_iter;
  obj_iterator end_iter;




  class generator {
    RGWObjManifest *manifest;
    uint64_t last_ofs;
    uint64_t cur_part_ofs;
    int cur_part_id;
    int cur_stripe;
    uint64_t cur_stripe_size;
    string cur_oid;

    string oid_prefix;

    rgw_obj_select cur_obj;

    RGWObjManifestRule rule;

  public:
    generator() : manifest(
# 805 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                          __null
# 805 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                              ), last_ofs(0), cur_part_ofs(0), cur_part_id(0),
    cur_stripe(0), cur_stripe_size(0) {}
    int create_begin(CephContext *cct, RGWObjManifest *manifest,
                     const rgw_placement_rule& head_placement_rule,
                     const rgw_placement_rule *tail_placement_rule,
                     const rgw_bucket& bucket,
                     const rgw_obj& obj);

    int create_next(uint64_t ofs);

    rgw_raw_obj get_cur_obj(RGWZoneGroup& zonegroup, RGWZoneParams& zone_params) { return cur_obj.get_raw_obj(zonegroup, zone_params); }
    rgw_raw_obj get_cur_obj(RGWRados *store) const { return cur_obj.get_raw_obj(store); }


    uint64_t cur_stripe_max_size() const {
      return cur_stripe_size;
    }
  };
};
inline void encode(const RGWObjManifest &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWObjManifest &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWUploadPartInfo {
  uint32_t num;
  uint64_t size;
  uint64_t accounted_size{0};
  string etag;
  ceph::real_time modified;
  RGWObjManifest manifest;
  RGWCompressionInfo cs_info;

  RGWUploadPartInfo() : num(0), size(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 4; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(num, bl);
    encode(size, bl);
    encode(etag, bl);
    encode(modified, bl);
    encode(manifest, bl);
    encode(cs_info, bl);
    encode(accounted_size, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (4 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "4" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(num, bl);
    decode(size, bl);
    decode(etag, bl);
    decode(modified, bl);
    if (struct_v >= 3)
      decode(manifest, bl);
    if (struct_v >= 4) {
      decode(cs_info, bl);
      decode(accounted_size, bl);
    } else {
      accounted_size = size;
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWUploadPartInfo*>& o);
};
inline void encode(const RGWUploadPartInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWUploadPartInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWObjState {
  rgw_obj obj;
  bool is_atomic;
  bool has_attrs;
  bool exists;
  uint64_t size;
  uint64_t accounted_size{0};
  ceph::real_time mtime;
  uint64_t epoch;
  bufferlist obj_tag;
  bufferlist tail_tag;
  string write_tag;
  bool fake_tag;
  RGWObjManifest manifest;
  bool has_manifest;
  string shadow_obj;
  bool has_data;
  bufferlist data;
  bool prefetch_data;
  bool keep_tail;
  bool is_olh;
  bufferlist olh_tag;
  uint64_t pg_ver;
  uint32_t zone_short_id;



  RGWObjVersionTracker objv_tracker;

  map<string, bufferlist> attrset;
  RGWObjState() : is_atomic(false), has_attrs(0), exists(false),
                  size(0), epoch(0), fake_tag(false), has_manifest(false),
                  has_data(false), prefetch_data(false), keep_tail(false), is_olh(false),
                  pg_ver(0), zone_short_id(0) {}
  RGWObjState(const RGWObjState& rhs) : obj (rhs.obj) {
    is_atomic = rhs.is_atomic;
    has_attrs = rhs.has_attrs;
    exists = rhs.exists;
    size = rhs.size;
    accounted_size = rhs.accounted_size;
    mtime = rhs.mtime;
    epoch = rhs.epoch;
    if (rhs.obj_tag.length()) {
      obj_tag = rhs.obj_tag;
    }
    if (rhs.tail_tag.length()) {
      tail_tag = rhs.tail_tag;
    }
    write_tag = rhs.write_tag;
    fake_tag = rhs.fake_tag;
    if (rhs.has_manifest) {
      manifest = rhs.manifest;
    }
    has_manifest = rhs.has_manifest;
    shadow_obj = rhs.shadow_obj;
    has_data = rhs.has_data;
    if (rhs.data.length()) {
      data = rhs.data;
    }
    prefetch_data = rhs.prefetch_data;
    keep_tail = rhs.keep_tail;
    is_olh = rhs.is_olh;
    objv_tracker = rhs.objv_tracker;
    pg_ver = rhs.pg_ver;
  }

  bool get_attr(string name, bufferlist& dest) {
    map<string, bufferlist>::iterator iter = attrset.find(name);
    if (iter != attrset.end()) {
      dest = iter->second;
      return true;
    }
    return false;
  }
};

struct RGWRawObjState {
  rgw_raw_obj obj;
  bool has_attrs{false};
  bool exists{false};
  uint64_t size{0};
  ceph::real_time mtime;
  uint64_t epoch{0};
  bufferlist obj_tag;
  bool has_data{false};
  bufferlist data;
  bool prefetch_data{false};
  uint64_t pg_ver{0};



  RGWObjVersionTracker objv_tracker;

  map<string, bufferlist> attrset;
  RGWRawObjState() {}
  RGWRawObjState(const RGWRawObjState& rhs) : obj (rhs.obj) {
    has_attrs = rhs.has_attrs;
    exists = rhs.exists;
    size = rhs.size;
    mtime = rhs.mtime;
    epoch = rhs.epoch;
    if (rhs.obj_tag.length()) {
      obj_tag = rhs.obj_tag;
    }
    has_data = rhs.has_data;
    if (rhs.data.length()) {
      data = rhs.data;
    }
    prefetch_data = rhs.prefetch_data;
    pg_ver = rhs.pg_ver;
    objv_tracker = rhs.objv_tracker;
  }
};

struct RGWPoolIterCtx {
  librados::IoCtx io_ctx;
  librados::NObjectIterator iter;
};

struct RGWListRawObjsCtx {
  bool initialized;
  RGWPoolIterCtx iter_ctx;

  RGWListRawObjsCtx() : initialized(false) {}
};

struct objexp_hint_entry {
  string tenant;
  string bucket_name;
  string bucket_id;
  rgw_obj_key obj_key;
  ceph::real_time exp_time;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(bucket_name, bl);
    encode(bucket_id, bl);
    encode(obj_key, bl);
    encode(exp_time, bl);
    encode(tenant, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {

    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(bucket_name, bl);
    decode(bucket_id, bl);
    decode(obj_key, bl);
    decode(exp_time, bl);
    if (struct_v >= 2) {
      decode(tenant, bl);
    } else {
      tenant.clear();
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const objexp_hint_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(objexp_hint_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWDataChangesLog;
class RGWMetaSyncStatusManager;
class RGWDataSyncStatusManager;
class RGWCoroutinesManagerRegistry;

class RGWGetBucketStats_CB : public RefCountedObject {
protected:
  rgw_bucket bucket;
  map<RGWObjCategory, RGWStorageStats> *stats;
public:
  explicit RGWGetBucketStats_CB(const rgw_bucket& _bucket) : bucket(_bucket), stats(
# 1039 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                   __null
# 1039 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                       ) {}
  ~RGWGetBucketStats_CB() override {}
  virtual void handle_response(int r) = 0;
  virtual void set_response(map<RGWObjCategory, RGWStorageStats> *_stats) {
    stats = _stats;
  }
};

class RGWGetUserStats_CB : public RefCountedObject {
protected:
  rgw_user user;
  RGWStorageStats stats;
public:
  explicit RGWGetUserStats_CB(const rgw_user& _user) : user(_user) {}
  ~RGWGetUserStats_CB() override {}
  virtual void handle_response(int r) = 0;
  virtual void set_response(RGWStorageStats& _stats) {
    stats = _stats;
  }
};

class RGWGetDirHeader_CB;
class RGWGetUserHeader_CB;

class RGWObjectCtx {
  RGWRados *store;
  RWLock lock{"RGWObjectCtx"};
  void *s{nullptr};

  std::map<rgw_obj, RGWObjState> objs_state;
public:
  explicit RGWObjectCtx(RGWRados *_store) : store(_store) {}
  explicit RGWObjectCtx(RGWRados *_store, void *_s) : store(_store), s(_s) {}

  void *get_private() {
    return s;
  }

  RGWRados *get_store() {
    return store;
  }

  RGWObjState *get_state(const rgw_obj& obj) {
    RGWObjState *result;
    typename std::map<rgw_obj, RGWObjState>::iterator iter;
    lock.get_read();
    
# 1085 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
   (static_cast<void> (0))
# 1085 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                        ;
    iter = objs_state.find(obj);
    if (iter != objs_state.end()) {
      result = &iter->second;
      lock.unlock();
    } else {
      lock.unlock();
      lock.get_write();
      result = &objs_state[obj];
      lock.unlock();
    }
    return result;
  }

  void set_atomic(rgw_obj& obj) {
    RWLock::WLocker wl(lock);
    
# 1101 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
   (static_cast<void> (0))
# 1101 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                        ;
    objs_state[obj].is_atomic = true;
  }
  void set_prefetch_data(const rgw_obj& obj) {
    RWLock::WLocker wl(lock);
    
# 1106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
   (static_cast<void> (0))
# 1106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                        ;
    objs_state[obj].prefetch_data = true;
  }

  void invalidate(const rgw_obj& obj) {
    RWLock::WLocker wl(lock);
    auto iter = objs_state.find(obj);
    if (iter == objs_state.end()) {
      return;
    }
    bool is_atomic = iter->second.is_atomic;
    bool prefetch_data = iter->second.prefetch_data;

    objs_state.erase(iter);

    if (is_atomic || prefetch_data) {
      auto& state = objs_state[obj];
      state.is_atomic = is_atomic;
      state.prefetch_data = prefetch_data;
    }
  }
};

class RGWAsyncRadosProcessor;

template <class T>
class RGWChainedCacheImpl;

struct bucket_info_entry {
  RGWBucketInfo info;
  real_time mtime;
  map<string, bufferlist> attrs;
};

struct tombstone_entry {
  ceph::real_time mtime;
  uint32_t zone_short_id;
  uint64_t pg_ver;

  tombstone_entry() = default;
  explicit tombstone_entry(const RGWObjState& state)
    : mtime(state.mtime), zone_short_id(state.zone_short_id),
      pg_ver(state.pg_ver) {}
};

class RGWIndexCompletionManager;

class RGWRados : public AdminSocketHook
{
  friend class RGWGC;
  friend class RGWMetaNotifier;
  friend class RGWDataNotifier;
  friend class RGWLC;
  friend class RGWObjectExpirer;
  friend class RGWMetaSyncProcessorThread;
  friend class RGWDataSyncProcessorThread;
  friend class RGWReshard;
  friend class RGWBucketReshard;
  friend class RGWBucketReshardLock;
  friend class BucketIndexLockGuard;
  friend class RGWCompleteMultipart;

  static constexpr const char* admin_commands[4][3] = {
    { "cache list",
      "cache list name=filter,type=CephString,req=false",
      "cache list [filter_str]: list object cache, possibly matching substrings" },
    { "cache inspect",
      "cache inspect name=target,type=CephString,req=true",
      "cache inspect target: print cache element" },
    { "cache erase",
      "cache erase name=target,type=CephString,req=true",
      "cache erase target: erase element from cache" },
    { "cache zap",
      "cache zap",
      "cache zap: erase all elements from cache" }
  };


  int open_root_pool_ctx();
  int open_gc_pool_ctx();
  int open_lc_pool_ctx();
  int open_objexp_pool_ctx();
  int open_reshard_pool_ctx();

  int open_pool_ctx(const rgw_pool& pool, librados::IoCtx& io_ctx,
      bool mostly_omap);
  int open_bucket_index_ctx(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx);
  int open_bucket_index(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx, string& bucket_oid);
  int open_bucket_index_base(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
      string& bucket_oid_base);
  int open_bucket_index_shard(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
      const string& obj_key, string *bucket_obj, int *shard_id);
  int open_bucket_index_shard(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
                              int shard_id, string *bucket_obj);
  int open_bucket_index(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
      map<int, string>& bucket_objs, int shard_id = -1, map<int, string> *bucket_instance_ids = 
# 1201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                               __null
# 1201 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                                   );
  template<typename T>
  int open_bucket_index(const RGWBucketInfo& bucket_info, librados::IoCtx& index_ctx,
                        map<int, string>& oids, map<int, T>& bucket_objs,
                        int shard_id = -1, map<int, string> *bucket_instance_ids = 
# 1205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                  __null
# 1205 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                      );
  void build_bucket_index_marker(const string& shard_id_str, const string& shard_marker,
      string *marker);

  void get_bucket_instance_ids(const RGWBucketInfo& bucket_info, int shard_id, map<int, string> *result);

  std::atomic<int64_t> max_req_id = { 0 };
  Mutex lock;
  SafeTimer *timer;

  RGWGC *gc;
  RGWLC *lc;
  RGWObjectExpirer *obj_expirer;
  bool use_gc_thread;
  bool use_lc_thread;
  bool quota_threads;
  bool run_sync_thread;
  bool run_reshard_thread;

  RGWAsyncRadosProcessor* async_rados;

  RGWMetaNotifier *meta_notifier;
  RGWDataNotifier *data_notifier;
  RGWMetaSyncProcessorThread *meta_sync_processor_thread;
  RGWSyncTraceManager *sync_tracer = nullptr;
  map<string, RGWDataSyncProcessorThread *> data_sync_processor_threads;

  boost::optional<rgw::BucketTrimManager> bucket_trim;
  RGWSyncLogTrimThread *sync_log_trimmer{nullptr};

  Mutex meta_sync_thread_lock;
  Mutex data_sync_thread_lock;

  librados::IoCtx root_pool_ctx;

  double inject_notify_timeout_probability = 0;
  unsigned max_notify_retries = 0;

  friend class RGWWatcher;

  Mutex bucket_id_lock;


  uint32_t bucket_index_max_shards;

  int get_obj_head_ioctx(const RGWBucketInfo& bucket_info, const rgw_obj& obj, librados::IoCtx *ioctx);
  int get_obj_head_ref(const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_rados_ref *ref);
  int get_system_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref);
  uint64_t max_bucket_id;

  int get_olh_target_state(RGWObjectCtx& rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
                           RGWObjState *olh_state, RGWObjState **target_state);
  int get_obj_state_impl(RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state,
                         bool follow_olh, bool assume_noent = false);
  int append_atomic_test(RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
                         librados::ObjectOperation& op, RGWObjState **state);
  int append_atomic_test(const RGWObjState* astate, librados::ObjectOperation& op);

  int update_placement_map();
  int store_bucket_info(RGWBucketInfo& info, map<string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker, bool exclusive);

  void remove_rgw_head_obj(librados::ObjectWriteOperation& op);
  void cls_obj_check_prefix_exist(librados::ObjectOperation& op, const string& prefix, bool fail_if_exist);
  void cls_obj_check_mtime(librados::ObjectOperation& op, const real_time& mtime, bool high_precision_time, RGWCheckMTimeType type);
protected:
  CephContext *cct;

  librados::Rados rados;

  using RGWChainedCacheImpl_bucket_info_entry = RGWChainedCacheImpl<bucket_info_entry>;
  RGWChainedCacheImpl_bucket_info_entry *binfo_cache;

  using tombstone_cache_t = lru_map<rgw_obj, tombstone_entry>;
  tombstone_cache_t *obj_tombstone_cache;

  librados::IoCtx gc_pool_ctx;
  librados::IoCtx lc_pool_ctx;
  librados::IoCtx objexp_pool_ctx;
  librados::IoCtx reshard_pool_ctx;

  bool pools_initialized;

  RGWQuotaHandler *quota_handler;

  RGWCoroutinesManagerRegistry *cr_registry;

  RGWSyncModuleInstanceRef sync_module;
  bool writeable_zone{false};

  RGWIndexCompletionManager *index_completion_manager{nullptr};

  bool use_cache{false};
public:
  RGWRados(): lock("rados_timer_lock"), timer(
# 1298 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                             __null
# 1298 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                 ),
               gc(
# 1299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                 __null
# 1299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                     ), lc(
# 1299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                           __null
# 1299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                               ), obj_expirer(
# 1299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                              __null
# 1299 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                  ), use_gc_thread(false), use_lc_thread(false), quota_threads(false),
               run_sync_thread(false), run_reshard_thread(false), async_rados(nullptr), meta_notifier(
# 1300 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                                     __null
# 1300 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                                         ),
               data_notifier(
# 1301 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                            __null
# 1301 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                ), meta_sync_processor_thread(
# 1301 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                              __null
# 1301 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                  ),
               meta_sync_thread_lock("meta_sync_thread_lock"), data_sync_thread_lock("data_sync_thread_lock"),
               bucket_id_lock("rados_bucket_id"),
               bucket_index_max_shards(0),
               max_bucket_id(0), cct(
# 1305 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                    __null
# 1305 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                        ),
               binfo_cache(
# 1306 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                          __null
# 1306 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                              ), obj_tombstone_cache(nullptr),
               pools_initialized(false),
               quota_handler(
# 1308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                            __null
# 1308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                ),
               cr_registry(
# 1309 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                          __null
# 1309 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                              ),
               meta_mgr(
# 1310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                       __null
# 1310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                           ), data_log(
# 1310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                       __null
# 1310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                           ), reshard(
# 1310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                      __null
# 1310 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                          ) {}

  RGWRados& set_use_cache(bool status) {
    use_cache = status;
    return *this;
  }

  RGWLC *get_lc() {
    return lc;
  }

  RGWRados& set_run_gc_thread(bool _use_gc_thread) {
    use_gc_thread = _use_gc_thread;
    return *this;
  }

  RGWRados& set_run_lc_thread(bool _use_lc_thread) {
    use_lc_thread = _use_lc_thread;
    return *this;
  }

  RGWRados& set_run_quota_threads(bool _run_quota_threads) {
    quota_threads = _run_quota_threads;
    return *this;
  }

  RGWRados& set_run_sync_thread(bool _run_sync_thread) {
    run_sync_thread = _run_sync_thread;
    return *this;
  }

  RGWRados& set_run_reshard_thread(bool _run_reshard_thread) {
    run_reshard_thread = _run_reshard_thread;
    return *this;
  }

  uint64_t get_new_req_id() {
    return ++max_req_id;
  }

  librados::IoCtx* get_lc_pool_ctx() {
    return &lc_pool_ctx;
  }
  void set_context(CephContext *_cct) {
    cct = _cct;
  }

  RGWServices svc;





  string host_id;


  std::unique_ptr<RGWPeriodPuller> period_puller;

  std::unique_ptr<RGWPeriodHistory> period_history;

  RGWAsyncRadosProcessor* get_async_rados() const { return async_rados; };

  RGWMetadataManager *meta_mgr;

  RGWDataChangesLog *data_log;

  RGWReshard *reshard;
  std::shared_ptr<RGWReshardWait> reshard_wait;

  virtual ~RGWRados() = default;

  tombstone_cache_t *get_tombstone_cache() {
    return obj_tombstone_cache;
  }
  const RGWSyncModuleInstanceRef& get_sync_module() {
    return sync_module;
  }
  RGWSyncTraceManager *get_sync_tracer() {
    return sync_tracer;
  }

  int get_required_alignment(const rgw_pool& pool, uint64_t *alignment);
  void get_max_aligned_size(uint64_t size, uint64_t alignment, uint64_t *max_size);
  int get_max_chunk_size(const rgw_pool& pool, uint64_t *max_chunk_size, uint64_t *palignment = nullptr);
  int get_max_chunk_size(const rgw_placement_rule& placement_rule, const rgw_obj& obj, uint64_t *max_chunk_size, uint64_t *palignment = nullptr);

  uint32_t get_max_bucket_shards() {
    return rgw_shards_max();
  }


  int get_raw_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref);

  int list_raw_objects_init(const rgw_pool& pool, const string& marker, RGWListRawObjsCtx *ctx);
  int list_raw_objects_next(const string& prefix_filter, int max,
                            RGWListRawObjsCtx& ctx, list<string>& oids,
                            bool *is_truncated);
  int list_raw_objects(const rgw_pool& pool, const string& prefix_filter, int max,
                       RGWListRawObjsCtx& ctx, list<string>& oids,
                       bool *is_truncated);
  string list_raw_objs_get_cursor(RGWListRawObjsCtx& ctx);

  CephContext *ctx() { return cct; }

  int initialize(CephContext *_cct) {
    set_context(_cct);
    return initialize();
  }

  int init_svc(bool raw);
  int init_rados();
  int init_complete();
  int initialize();
  void finalize();

  int register_to_service_map(const string& daemon_type, const map<string, string>& meta);
  int update_service_map(std::map<std::string, std::string>&& status);


  int log_list_init(const string& prefix, RGWAccessHandle *handle);
  int log_list_next(RGWAccessHandle handle, string *name);


  int log_remove(const string& name);


  int log_show_init(const string& name, RGWAccessHandle *handle);
  int log_show_next(RGWAccessHandle handle, rgw_log_entry *entry);


  int log_usage(map<rgw_user_bucket, RGWUsageBatch>& usage_info);
  int read_usage(const rgw_user& user, const string& bucket_name, uint64_t start_epoch, uint64_t end_epoch,
                 uint32_t max_entries, bool *is_truncated, RGWUsageIter& read_iter, map<rgw_user_bucket,
   rgw_usage_log_entry>& usage);
  int trim_usage(const rgw_user& user, const string& bucket_name, uint64_t start_epoch, uint64_t end_epoch);
  int clear_usage();

  int create_pool(const rgw_pool& pool);

  int init_bucket_index(RGWBucketInfo& bucket_info, int num_shards);
  int clean_bucket_index(RGWBucketInfo& bucket_info, int num_shards);
  void create_bucket_id(string *bucket_id);

  bool get_obj_data_pool(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_pool *pool);
  bool obj_to_raw(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj *raw_obj);

  int create_bucket(const RGWUserInfo& owner, rgw_bucket& bucket,
                            const string& zonegroup_id,
                            const rgw_placement_rule& placement_rule,
                            const string& swift_ver_location,
                            const RGWQuotaInfo * pquota_info,
                            map<std::string,bufferlist>& attrs,
                            RGWBucketInfo& bucket_info,
                            obj_version *pobjv,
                            obj_version *pep_objv,
                            ceph::real_time creation_time,
                            rgw_bucket *master_bucket,
                            uint32_t *master_num_shards,
                            bool exclusive = true);

  RGWCoroutinesManagerRegistry *get_cr_registry() { return cr_registry; }

  struct BucketShard {
    RGWRados *store;
    rgw_bucket bucket;
    int shard_id;
    librados::IoCtx index_ctx;
    string bucket_obj;

    explicit BucketShard(RGWRados *_store) : store(_store), shard_id(-1) {}
    int init(const rgw_bucket& _bucket, const rgw_obj& obj, RGWBucketInfo* out);
    int init(const rgw_bucket& _bucket, int sid, RGWBucketInfo* out);
    int init(const RGWBucketInfo& bucket_info, const rgw_obj& obj);
    int init(const RGWBucketInfo& bucket_info, int sid);
  };

  class Object {
    RGWRados *store;
    RGWBucketInfo bucket_info;
    RGWObjectCtx& ctx;
    rgw_obj obj;

    BucketShard bs;

    RGWObjState *state;

    bool versioning_disabled;

    bool bs_initialized;

  protected:
    int get_state(RGWObjState **pstate, bool follow_olh, bool assume_noent = false);
    void invalidate_state();

    int prepare_atomic_modification(librados::ObjectWriteOperation& op, bool reset_obj, const string *ptag,
                                    const char *ifmatch, const char *ifnomatch, bool removal_op, bool modify_tail);
    int complete_atomic_modification();

  public:
    Object(RGWRados *_store, const RGWBucketInfo& _bucket_info, RGWObjectCtx& _ctx, const rgw_obj& _obj) : store(_store), bucket_info(_bucket_info),
                                                                                               ctx(_ctx), obj(_obj), bs(store),
                                                                                               state(
# 1511 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                                    __null
# 1511 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                                        ), versioning_disabled(false),
                                                                                               bs_initialized(false) {}

    RGWRados *get_store() { return store; }
    rgw_obj& get_obj() { return obj; }
    RGWObjectCtx& get_ctx() { return ctx; }
    RGWBucketInfo& get_bucket_info() { return bucket_info; }
    int get_manifest(RGWObjManifest **pmanifest);

    int get_bucket_shard(BucketShard **pbs) {
      if (!bs_initialized) {
        int r =
   bs.init(bucket_info.bucket, obj, nullptr );
        if (r < 0) {
          return r;
        }
        bs_initialized = true;
      }
      *pbs = &bs;
      return 0;
    }

    void set_versioning_disabled(bool status) {
      versioning_disabled = status;
    }

    bool versioning_enabled() {
      return (!versioning_disabled && bucket_info.versioning_enabled());
    }

    struct Read {
      RGWRados::Object *source;

      struct GetObjState {
        map<rgw_pool, librados::IoCtx> io_ctxs;
        rgw_pool cur_pool;
        librados::IoCtx *cur_ioctx{nullptr};
        rgw_obj obj;
        rgw_raw_obj head_obj;
      } state;

      struct ConditionParams {
        const ceph::real_time *mod_ptr;
        const ceph::real_time *unmod_ptr;
        bool high_precision_time;
        uint32_t mod_zone_id;
        uint64_t mod_pg_ver;
        const char *if_match;
        const char *if_nomatch;

        ConditionParams() :
                 mod_ptr(
# 1562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                        __null
# 1562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                            ), unmod_ptr(
# 1562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                         __null
# 1562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                             ), high_precision_time(false), mod_zone_id(0), mod_pg_ver(0),
                 if_match(
# 1563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                         __null
# 1563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                             ), if_nomatch(
# 1563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                           __null
# 1563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                               ) {}
      } conds;

      struct Params {
        ceph::real_time *lastmod;
        uint64_t *obj_size;
        map<string, bufferlist> *attrs;
        rgw_obj *target_obj;

        Params() : lastmod(nullptr), obj_size(nullptr), attrs(nullptr),
   target_obj(nullptr) {}
      } params;

      explicit Read(RGWRados::Object *_source) : source(_source) {}

      int prepare();
      static int range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end);
      int read(int64_t ofs, int64_t end, bufferlist& bl);
      int iterate(int64_t ofs, int64_t end, RGWGetDataCB *cb);
      int get_attr(const char *name, bufferlist& dest);
    };

    struct Write {
      RGWRados::Object *target;

      struct MetaParams {
        ceph::real_time *mtime;
        map<std::string, bufferlist>* rmattrs;
        const bufferlist *data;
        RGWObjManifest *manifest;
        const string *ptag;
        list<rgw_obj_index_key> *remove_objs;
        ceph::real_time set_mtime;
        rgw_user owner;
        RGWObjCategory category;
        int flags;
        const char *if_match;
        const char *if_nomatch;
        std::optional<uint64_t> olh_epoch;
        ceph::real_time delete_at;
        bool canceled;
        const string *user_data;
        rgw_zone_set *zones_trace;
        bool modify_tail;
        bool completeMultipart;
        bool appendable;

        MetaParams() : mtime(
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                            __null
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                ), rmattrs(
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                           __null
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                               ), data(
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                       __null
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                           ), manifest(
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                       __null
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                           ), ptag(
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                   __null
# 1610 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                       ),
                 remove_objs(
# 1611 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                            __null
# 1611 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                ), category(RGWObjCategory::Main), flags(0),
                 if_match(
# 1612 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                         __null
# 1612 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                             ), if_nomatch(
# 1612 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                           __null
# 1612 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                               ), canceled(false), user_data(nullptr), zones_trace(nullptr),
                 modify_tail(false), completeMultipart(false), appendable(false) {}
      } meta;

      explicit Write(RGWRados::Object *_target) : target(_target) {}

      int _do_write_meta(uint64_t size, uint64_t accounted_size,
                     map<std::string, bufferlist>& attrs,
                     bool modify_tail, bool assume_noent,
                     void *index_op);
      int write_meta(uint64_t size, uint64_t accounted_size,
                     map<std::string, bufferlist>& attrs);
      int write_data(const char *data, uint64_t ofs, uint64_t len, bool exclusive);
      const req_state* get_req_state() {
        return (req_state *)target->get_ctx().get_private();
      }
    };

    struct Delete {
      RGWRados::Object *target;

      struct DeleteParams {
        rgw_user bucket_owner;
        int versioning_status;
        ACLOwner obj_owner;
        uint64_t olh_epoch;
        string marker_version_id;
        uint32_t bilog_flags;
        list<rgw_obj_index_key> *remove_objs;
        ceph::real_time expiration_time;
        ceph::real_time unmod_since;
        ceph::real_time mtime;
        bool high_precision_time;
        rgw_zone_set *zones_trace;

        DeleteParams() : versioning_status(0), olh_epoch(0), bilog_flags(0), remove_objs(
# 1647 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                        __null
# 1647 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                            ), high_precision_time(false), zones_trace(nullptr) {}
      } params;

      struct DeleteResult {
        bool delete_marker;
        string version_id;

        DeleteResult() : delete_marker(false) {}
      } result;

      explicit Delete(RGWRados::Object *_target) : target(_target) {}

      int delete_obj();
    };

    struct Stat {
      RGWRados::Object *source;

      struct Result {
        rgw_obj obj;
        RGWObjManifest manifest;
        bool has_manifest;
        uint64_t size;
 struct timespec mtime;
        map<string, bufferlist> attrs;

        Result() : has_manifest(false), size(0) {}
      } result;

      struct State {
        librados::IoCtx io_ctx;
        librados::AioCompletion *completion;
        int ret;

        State() : completion(
# 1681 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                            __null
# 1681 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                ), ret(0) {}
      } state;


      explicit Stat(RGWRados::Object *_source) : source(_source) {}

      int stat_async();
      int wait();
      int stat();
    private:
      int finish();
    };
  };

  class Bucket {
    RGWRados *store;
    RGWBucketInfo bucket_info;
    rgw_bucket& bucket;
    int shard_id;

  public:
    Bucket(RGWRados *_store, const RGWBucketInfo& _bucket_info) : store(_store), bucket_info(_bucket_info), bucket(bucket_info.bucket),
                                                            shard_id(-1) {}
    RGWRados *get_store() { return store; }
    rgw_bucket& get_bucket() { return bucket; }
    RGWBucketInfo& get_bucket_info() { return bucket_info; }

    int update_bucket_id(const string& new_bucket_id);

    int get_shard_id() { return shard_id; }
    void set_shard_id(int id) {
      shard_id = id;
    }

    class UpdateIndex {
      RGWRados::Bucket *target;
      string optag;
      rgw_obj obj;
      uint16_t bilog_flags{0};
      BucketShard bs;
      bool bs_initialized{false};
      bool blind;
      bool prepared{false};
      rgw_zone_set *zones_trace{nullptr};

      int init_bs() {
        int r =
   bs.init(target->get_bucket(), obj, nullptr );
        if (r < 0) {
          return r;
        }
        bs_initialized = true;
        return 0;
      }

      void invalidate_bs() {
        bs_initialized = false;
      }

      int guard_reshard(BucketShard **pbs, std::function<int(BucketShard *)> call);
    public:

      UpdateIndex(RGWRados::Bucket *_target, const rgw_obj& _obj) : target(_target), obj(_obj),
                                                              bs(target->get_store()) {
                                                                blind = (target->get_bucket_info().index_type == RGWBIType_Indexless);
                                                              }

      int get_bucket_shard(BucketShard **pbs) {
        if (!bs_initialized) {
          int r = init_bs();
          if (r < 0) {
            return r;
          }
        }
        *pbs = &bs;
        return 0;
      }

      void set_bilog_flags(uint16_t flags) {
        bilog_flags = flags;
      }

      void set_zones_trace(rgw_zone_set *_zones_trace) {
        zones_trace = _zones_trace;
      }

      int prepare(RGWModifyOp, const string *write_tag);
      int complete(int64_t poolid, uint64_t epoch, uint64_t size,
                   uint64_t accounted_size, ceph::real_time& ut,
                   const string& etag, const string& content_type,
                   const string& storage_class,
                   bufferlist *acl_bl, RGWObjCategory category,
     list<rgw_obj_index_key> *remove_objs, const string *user_data = nullptr, bool appendable = false);
      int complete_del(int64_t poolid, uint64_t epoch,
                       ceph::real_time& removed_mtime,
                       list<rgw_obj_index_key> *remove_objs);
      int cancel();

      const string *get_optag() { return &optag; }

      bool is_prepared() { return prepared; }
    };

    class List {
    protected:


      static constexpr int64_t bucket_list_objects_absolute_max = 25000;

      RGWRados::Bucket *target;
      rgw_obj_key next_marker;

      int list_objects_ordered(int64_t max,
          vector<rgw_bucket_dir_entry> *result,
          map<string, bool> *common_prefixes,
          bool *is_truncated);
      int list_objects_unordered(int64_t max,
     vector<rgw_bucket_dir_entry> *result,
     map<string, bool> *common_prefixes,
     bool *is_truncated);

    public:

      struct Params {
        string prefix;
        string delim;
        rgw_obj_key marker;
        rgw_obj_key end_marker;
        string ns;
        bool enforce_ns;
        RGWAccessListFilter *filter;
        bool list_versions;
 bool allow_unordered;

        Params() :
   enforce_ns(true),
   filter(
# 1817 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
         __null
# 1817 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
             ),
   list_versions(false),
   allow_unordered(false)
 {}
      } params;

      explicit List(RGWRados::Bucket *_target) : target(_target) {}

      int list_objects(int64_t max,
         vector<rgw_bucket_dir_entry> *result,
         map<string, bool> *common_prefixes,
         bool *is_truncated) {
 if (params.allow_unordered) {
   return list_objects_unordered(max, result, common_prefixes,
     is_truncated);
 } else {
   return list_objects_ordered(max, result, common_prefixes,
          is_truncated);
 }
      }
      rgw_obj_key& get_next_marker() {
        return next_marker;
      }
    };
  };

  int on_last_entry_in_listing(RGWBucketInfo& bucket_info,
                               const std::string& obj_prefix,
                               const std::string& obj_delim,
                               std::function<int(const rgw_bucket_dir_entry&)> handler);

  bool swift_versioning_enabled(const RGWBucketInfo& bucket_info) const {
    return bucket_info.has_swift_versioning() &&
        bucket_info.swift_ver_location.size();
  }

  int swift_versioning_copy(RGWObjectCtx& obj_ctx,
                            const rgw_user& user,
                            RGWBucketInfo& bucket_info,
                            rgw_obj& obj);
  int swift_versioning_restore(RGWSysObjectCtx& sysobj_ctx,
                               RGWObjectCtx& obj_ctx,
                               const rgw_user& user,
                               RGWBucketInfo& bucket_info,
                               rgw_obj& obj,
                               bool& restored);
  int copy_obj_to_remote_dest(RGWObjState *astate,
                              map<string, bufferlist>& src_attrs,
                              RGWRados::Object::Read& read_op,
                              const rgw_user& user_id,
                              rgw_obj& dest_obj,
                              ceph::real_time *mtime);

  enum AttrsMod {
    ATTRSMOD_NONE = 0,
    ATTRSMOD_REPLACE = 1,
    ATTRSMOD_MERGE = 2
  };

  int rewrite_obj(RGWBucketInfo& dest_bucket_info, const rgw_obj& obj);

  int stat_remote_obj(RGWObjectCtx& obj_ctx,
               const rgw_user& user_id,
               req_info *info,
               const string& source_zone,
               rgw_obj& src_obj,
               RGWBucketInfo& src_bucket_info,
               real_time *src_mtime,
               uint64_t *psize,
               const real_time *mod_ptr,
               const real_time *unmod_ptr,
               bool high_precision_time,
               const char *if_match,
               const char *if_nomatch,
               map<string, bufferlist> *pattrs,
               map<string, string> *pheaders,
               string *version_id,
               string *ptag,
               string *petag);

  int fetch_remote_obj(RGWObjectCtx& obj_ctx,
                       const rgw_user& user_id,
                       req_info *info,
                       const string& source_zone,
                       const rgw_obj& dest_obj,
                       const rgw_obj& src_obj,
                       RGWBucketInfo& dest_bucket_info,
                       RGWBucketInfo& src_bucket_info,
         std::optional<rgw_placement_rule> dest_placement,
                       ceph::real_time *src_mtime,
                       ceph::real_time *mtime,
                       const ceph::real_time *mod_ptr,
                       const ceph::real_time *unmod_ptr,
                       bool high_precision_time,
                       const char *if_match,
                       const char *if_nomatch,
                       AttrsMod attrs_mod,
                       bool copy_if_newer,
                       map<string, bufferlist>& attrs,
                       RGWObjCategory category,
                       std::optional<uint64_t> olh_epoch,
         ceph::real_time delete_at,
                       string *ptag,
                       string *petag,
                       void (*progress_cb)(off_t, void *),
                       void *progress_data,
                       rgw_zone_set *zones_trace= nullptr,
                       std::optional<uint64_t>* bytes_transferred = 0);
# 1939 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
  int copy_obj(RGWObjectCtx& obj_ctx,
               const rgw_user& user_id,
               req_info *info,
               const string& source_zone,
               rgw_obj& dest_obj,
               rgw_obj& src_obj,
               RGWBucketInfo& dest_bucket_info,
               RGWBucketInfo& src_bucket_info,
               const rgw_placement_rule& dest_placement,
               ceph::real_time *src_mtime,
               ceph::real_time *mtime,
               const ceph::real_time *mod_ptr,
               const ceph::real_time *unmod_ptr,
               bool high_precision_time,
               const char *if_match,
               const char *if_nomatch,
               AttrsMod attrs_mod,
               bool copy_if_newer,
               map<std::string, bufferlist>& attrs,
               RGWObjCategory category,
               uint64_t olh_epoch,
        ceph::real_time delete_at,
               string *version_id,
               string *ptag,
               string *petag,
               void (*progress_cb)(off_t, void *),
               void *progress_data);

  int copy_obj_data(RGWObjectCtx& obj_ctx,
               RGWBucketInfo& dest_bucket_info,
               const rgw_placement_rule& dest_placement,
        RGWRados::Object::Read& read_op, off_t end,
               const rgw_obj& dest_obj,
        ceph::real_time *mtime,
        ceph::real_time set_mtime,
               map<string, bufferlist>& attrs,
               uint64_t olh_epoch,
        ceph::real_time delete_at,
               string *petag);

  int transition_obj(RGWObjectCtx& obj_ctx,
                     RGWBucketInfo& bucket_info,
                     rgw_obj& obj,
                     const rgw_placement_rule& placement_rule,
                     const real_time& mtime,
                     uint64_t olh_epoch);

  int check_bucket_empty(RGWBucketInfo& bucket_info);






  int delete_bucket(RGWBucketInfo& bucket_info, RGWObjVersionTracker& objv_tracker, bool check_empty = true);

  void wakeup_meta_sync_shards(set<int>& shard_ids);
  void wakeup_data_sync_shards(const string& source_zone, map<int, set<string> >& shard_ids);

  RGWMetaSyncStatusManager* get_meta_sync_manager();
  RGWDataSyncStatusManager* get_data_sync_manager(const std::string& source_zone);

  int set_bucket_owner(rgw_bucket& bucket, ACLOwner& owner);
  int set_buckets_enabled(std::vector<rgw_bucket>& buckets, bool enabled);
  int bucket_suspended(rgw_bucket& bucket, bool *suspended);


  int delete_obj(RGWObjectCtx& obj_ctx,
                         const RGWBucketInfo& bucket_owner,
                         const rgw_obj& src_obj,
                         int versioning_status,
                         uint16_t bilog_flags = 0,
                         const ceph::real_time& expiration_time = ceph::real_time(),
                         rgw_zone_set *zones_trace = nullptr);

  int delete_raw_obj(const rgw_raw_obj& obj);


  int delete_obj_index(const rgw_obj& obj, ceph::real_time mtime);
# 2027 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
  int set_attr(void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& obj, const char *name, bufferlist& bl);

  int set_attrs(void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& obj,
                        map<string, bufferlist>& attrs,
                        map<string, bufferlist>* rmattrs);

  int get_obj_state(RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state,
                    bool follow_olh, bool assume_noent = false);
  int get_obj_state(RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state) {
    return get_obj_state(rctx, bucket_info, obj, state, true);
  }

  using iterate_obj_cb = int (*)(const rgw_raw_obj&, off_t, off_t,
                                 off_t, bool, RGWObjState*, void*);

  int iterate_obj(RGWObjectCtx& ctx, const RGWBucketInfo& bucket_info,
                  const rgw_obj& obj, off_t ofs, off_t end,
                  uint64_t max_chunk_size, iterate_obj_cb cb, void *arg);

  int flush_read_list(struct get_obj_data *d);

  int get_obj_iterate_cb(const rgw_raw_obj& read_obj, off_t obj_ofs,
                         off_t read_ofs, off_t len, bool is_head_obj,
                         RGWObjState *astate, void *arg);

  void get_obj_aio_completion_cb(librados::completion_t cb, void *arg);





  int raw_obj_stat(rgw_raw_obj& obj, uint64_t *psize, ceph::real_time *pmtime, uint64_t *epoch,
                   map<string, bufferlist> *attrs, bufferlist *first_chunk,
                   RGWObjVersionTracker *objv_tracker);

  int obj_operate(const RGWBucketInfo& bucket_info, const rgw_obj& obj, librados::ObjectWriteOperation *op);
  int obj_operate(const RGWBucketInfo& bucket_info, const rgw_obj& obj, librados::ObjectReadOperation *op);

  int guard_reshard(BucketShard *bs,
      const rgw_obj& obj_instance,
      const RGWBucketInfo& bucket_info,
      std::function<int(BucketShard *)> call);
  int block_while_resharding(RGWRados::BucketShard *bs,
        string *new_bucket_id,
        const RGWBucketInfo& bucket_info,
                             optional_yield y);

  void bucket_index_guard_olh_op(RGWObjState& olh_state, librados::ObjectOperation& op);
  int olh_init_modification(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, string *op_tag);
  int olh_init_modification_impl(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, string *op_tag);
  int bucket_index_link_olh(const RGWBucketInfo& bucket_info, RGWObjState& olh_state,
                            const rgw_obj& obj_instance, bool delete_marker,
                            const string& op_tag, struct rgw_bucket_dir_entry_meta *meta,
                            uint64_t olh_epoch,
                            ceph::real_time unmod_since, bool high_precision_time,
                            rgw_zone_set *zones_trace = nullptr,
                            bool log_data_change = false);
  int bucket_index_unlink_instance(const RGWBucketInfo& bucket_info, const rgw_obj& obj_instance, const string& op_tag, const string& olh_tag, uint64_t olh_epoch, rgw_zone_set *zones_trace = nullptr);
  int bucket_index_read_olh_log(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& obj_instance, uint64_t ver_marker,
                                map<uint64_t, vector<rgw_bucket_olh_log_entry> > *log, bool *is_truncated);
  int bucket_index_trim_olh_log(const RGWBucketInfo& bucket_info, RGWObjState& obj_state, const rgw_obj& obj_instance, uint64_t ver);
  int bucket_index_clear_olh(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& obj_instance);
  int apply_olh_log(RGWObjectCtx& ctx, RGWObjState& obj_state, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
                    bufferlist& obj_tag, map<uint64_t, vector<rgw_bucket_olh_log_entry> >& log,
                    uint64_t *plast_ver, rgw_zone_set *zones_trace = nullptr);
  int update_olh(RGWObjectCtx& obj_ctx, RGWObjState *state, const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_zone_set *zones_trace = nullptr);
  int set_olh(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta,
              uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time,
              rgw_zone_set *zones_trace = nullptr, bool log_data_change = false);
  int repair_olh(RGWObjState* state, const RGWBucketInfo& bucket_info,
                 const rgw_obj& obj);
  int unlink_obj_instance(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj,
                          uint64_t olh_epoch, rgw_zone_set *zones_trace = nullptr);

  void check_pending_olh_entries(map<string, bufferlist>& pending_entries, map<string, bufferlist> *rm_pending_entries);
  int remove_olh_pending_entries(const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, map<string, bufferlist>& pending_attrs);
  int follow_olh(const RGWBucketInfo& bucket_info, RGWObjectCtx& ctx, RGWObjState *state, const rgw_obj& olh_obj, rgw_obj *target);
  int get_olh(const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWOLHInfo *olh);

  void gen_rand_obj_instance_name(rgw_obj_key *target_key);
  void gen_rand_obj_instance_name(rgw_obj *target);

  int update_containers_stats(map<string, RGWBucketEnt>& m);
  int append_async(rgw_raw_obj& obj, size_t size, bufferlist& bl);

public:
  void set_atomic(void *ctx, rgw_obj& obj) {
    RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
    rctx->set_atomic(obj);
  }
  void set_prefetch_data(void *ctx, const rgw_obj& obj) {
    RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
    rctx->set_prefetch_data(obj);
  }
  int decode_policy(bufferlist& bl, ACLOwner *owner);
  int get_bucket_stats(RGWBucketInfo& bucket_info, int shard_id, string *bucket_ver, string *master_ver,
      map<RGWObjCategory, RGWStorageStats>& stats, string *max_marker, bool* syncstopped = 
# 2123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                          __null
# 2123 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                              );
  int get_bucket_stats_async(RGWBucketInfo& bucket_info, int shard_id, RGWGetBucketStats_CB *cb);
  int get_user_stats(const rgw_user& user, RGWStorageStats& stats);
  int get_user_stats_async(const rgw_user& user, RGWGetUserStats_CB *cb);
  void get_bucket_instance_obj(const rgw_bucket& bucket, rgw_raw_obj& obj);
  void get_bucket_meta_oid(const rgw_bucket& bucket, string& oid);

  int put_bucket_entrypoint_info(const string& tenant_name, const string& bucket_name, RGWBucketEntryPoint& entry_point,
                                 bool exclusive, RGWObjVersionTracker& objv_tracker, ceph::real_time mtime,
                                 map<string, bufferlist> *pattrs);
  int put_bucket_instance_info(RGWBucketInfo& info, bool exclusive, ceph::real_time mtime, map<string, bufferlist> *pattrs);
  int get_bucket_entrypoint_info(RGWSysObjectCtx& obj_ctx, const string& tenant_name, const string& bucket_name,
                                 RGWBucketEntryPoint& entry_point, RGWObjVersionTracker *objv_tracker,
                                 ceph::real_time *pmtime, map<string, bufferlist> *pattrs, rgw_cache_entry_info *cache_info = 
# 2136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                                                             __null
# 2136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                                                                 ,
     boost::optional<obj_version> refresh_version = boost::none);
  int get_bucket_instance_info(RGWSysObjectCtx& obj_ctx, const string& meta_key, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs);
  int get_bucket_instance_info(RGWSysObjectCtx& obj_ctx, const rgw_bucket& bucket, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs);
  int get_bucket_instance_from_oid(RGWSysObjectCtx& obj_ctx, const string& oid, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs,
                                   rgw_cache_entry_info *cache_info = 
# 2141 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                     __null
# 2141 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                         ,
       boost::optional<obj_version> refresh_version = boost::none);

  int convert_old_bucket_info(RGWSysObjectCtx& obj_ctx, const string& tenant_name, const string& bucket_name);
  static void make_bucket_entry_name(const string& tenant_name, const string& bucket_name, string& bucket_entry);


private:
  int _get_bucket_info(RGWSysObjectCtx& obj_ctx, const string& tenant,
         const string& bucket_name, RGWBucketInfo& info,
         real_time *pmtime,
         map<string, bufferlist> *pattrs,
         boost::optional<obj_version> refresh_version);
public:

  bool call(std::string_view command, const cmdmap_t& cmdmap,
     std::string_view format,
     bufferlist& out) override final;

protected:




  void call_list(const std::optional<std::string>& filter,
    Formatter* format);




  bool call_inspect(const std::string& target, Formatter* format);



  bool call_erase(const std::string& target);


  void call_zap();
public:

  int get_bucket_info(RGWSysObjectCtx& obj_ctx,
        const string& tenant_name, const string& bucket_name,
        RGWBucketInfo& info,
        ceph::real_time *pmtime, map<string, bufferlist> *pattrs = 
# 2184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                  __null
# 2184 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                      );





  int try_refresh_bucket_info(RGWBucketInfo& info,
         ceph::real_time *pmtime,
         map<string, bufferlist> *pattrs = nullptr);

  int put_linked_bucket_info(RGWBucketInfo& info, bool exclusive, ceph::real_time mtime, obj_version *pep_objv,
        map<string, bufferlist> *pattrs, bool create_entry_point);

  int cls_obj_prepare_op(BucketShard& bs, RGWModifyOp op, string& tag, rgw_obj& obj, uint16_t bilog_flags, rgw_zone_set *zones_trace = nullptr);
  int cls_obj_complete_op(BucketShard& bs, const rgw_obj& obj, RGWModifyOp op, string& tag, int64_t pool, uint64_t epoch,
                          rgw_bucket_dir_entry& ent, RGWObjCategory category, list<rgw_obj_index_key> *remove_objs, uint16_t bilog_flags, rgw_zone_set *zones_trace = nullptr);
  int cls_obj_complete_add(BucketShard& bs, const rgw_obj& obj, string& tag, int64_t pool, uint64_t epoch, rgw_bucket_dir_entry& ent,
                           RGWObjCategory category, list<rgw_obj_index_key> *remove_objs, uint16_t bilog_flags, rgw_zone_set *zones_trace = nullptr);
  int cls_obj_complete_del(BucketShard& bs, string& tag, int64_t pool, uint64_t epoch, rgw_obj& obj,
                           ceph::real_time& removed_mtime, list<rgw_obj_index_key> *remove_objs, uint16_t bilog_flags, rgw_zone_set *zones_trace = nullptr);
  int cls_obj_complete_cancel(BucketShard& bs, string& tag, rgw_obj& obj, uint16_t bilog_flags, rgw_zone_set *zones_trace = nullptr);
  int cls_obj_set_bucket_tag_timeout(RGWBucketInfo& bucket_info, uint64_t timeout);
  int cls_bucket_list_ordered(RGWBucketInfo& bucket_info, int shard_id,
         const rgw_obj_index_key& start,
         const string& prefix,
         uint32_t num_entries, bool list_versions,
         map<string, rgw_bucket_dir_entry>& m,
         bool *is_truncated,
         rgw_obj_index_key *last_entry,
         bool (*force_check_filter)(const string& name) = nullptr);
  int cls_bucket_list_unordered(RGWBucketInfo& bucket_info, int shard_id,
    const rgw_obj_index_key& start,
    const string& prefix,
    uint32_t num_entries, bool list_versions,
    vector<rgw_bucket_dir_entry>& ent_list,
    bool *is_truncated, rgw_obj_index_key *last_entry,
    bool (*force_check_filter)(const string& name) = nullptr);
  int cls_bucket_head(const RGWBucketInfo& bucket_info, int shard_id, vector<rgw_bucket_dir_header>& headers, map<int, string> *bucket_instance_ids = 
# 2221 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
                                                                                                                                                     __null
# 2221 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                                                                                                                                                         );
  int cls_bucket_head_async(const RGWBucketInfo& bucket_info, int shard_id, RGWGetDirHeader_CB *ctx, int *num_aio);
  int list_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id, string& marker, uint32_t max, std::list<rgw_bi_log_entry>& result, bool *truncated);
  int trim_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id, string& marker, string& end_marker);
  int resync_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id);
  int stop_bi_log_entries(RGWBucketInfo& bucket_info, int shard_id);
  int get_bi_log_status(RGWBucketInfo& bucket_info, int shard_id, map<int, string>& max_marker);

  int bi_get_instance(const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_bucket_dir_entry *dirent);
  int bi_get_olh(const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_bucket_olh_entry *olh);
  int bi_get(const RGWBucketInfo& bucket_info, const rgw_obj& obj, BIIndexType index_type, rgw_cls_bi_entry *entry);
  void bi_put(librados::ObjectWriteOperation& op, BucketShard& bs, rgw_cls_bi_entry& entry);
  int bi_put(BucketShard& bs, rgw_cls_bi_entry& entry);
  int bi_put(rgw_bucket& bucket, rgw_obj& obj, rgw_cls_bi_entry& entry);
  int bi_list(rgw_bucket& bucket, int shard_id, const string& filter_obj, const string& marker, uint32_t max, list<rgw_cls_bi_entry> *entries, bool *is_truncated);
  int bi_list(BucketShard& bs, const string& filter_obj, const string& marker, uint32_t max, list<rgw_cls_bi_entry> *entries, bool *is_truncated);
  int bi_list(rgw_bucket& bucket, const string& obj_name, const string& marker, uint32_t max,
              list<rgw_cls_bi_entry> *entries, bool *is_truncated);
  int bi_remove(BucketShard& bs);

  int cls_obj_usage_log_add(const string& oid, rgw_usage_log_info& info);
  int cls_obj_usage_log_read(const string& oid, const string& user, const string& bucket, uint64_t start_epoch,
                             uint64_t end_epoch, uint32_t max_entries, string& read_iter, map<rgw_user_bucket,
        rgw_usage_log_entry>& usage, bool *is_truncated);
  int cls_obj_usage_log_trim(const string& oid, const string& user, const string& bucket, uint64_t start_epoch,
                             uint64_t end_epoch);
  int cls_obj_usage_log_clear(string& oid);

  int key_to_shard_id(const string& key, int max_shards);
  void shard_name(const string& prefix, unsigned max_shards, const string& key, string& name, int *shard_id);
  void shard_name(const string& prefix, unsigned max_shards, const string& section, const string& key, string& name);
  void shard_name(const string& prefix, unsigned shard_id, string& name);
  int get_target_shard_id(const RGWBucketInfo& bucket_info, const string& obj_key, int *shard_id);
  void time_log_prepare_entry(cls_log_entry& entry, const ceph::real_time& ut, const string& section, const string& key, bufferlist& bl);
  int time_log_add_init(librados::IoCtx& io_ctx);
  int time_log_add(const string& oid, list<cls_log_entry>& entries,
     librados::AioCompletion *completion, bool monotonic_inc = true);
  int time_log_add(const string& oid, const ceph::real_time& ut, const string& section, const string& key, bufferlist& bl);
  int time_log_list(const string& oid, const ceph::real_time& start_time, const ceph::real_time& end_time,
                    int max_entries, list<cls_log_entry>& entries,
      const string& marker, string *out_marker, bool *truncated);
  int time_log_info(const string& oid, cls_log_header *header);
  int time_log_info_async(librados::IoCtx& io_ctx, const string& oid, cls_log_header *header, librados::AioCompletion *completion);
  int time_log_trim(const string& oid, const ceph::real_time& start_time, const ceph::real_time& end_time,
                    const string& from_marker, const string& to_marker,
                    librados::AioCompletion *completion = nullptr);

  string objexp_hint_get_shardname(int shard_num);
  int objexp_key_shard(const rgw_obj_index_key& key);
  void objexp_get_shard(int shard_num,
                        string& shard);
  int objexp_hint_add(const ceph::real_time& delete_at,
                      const string& tenant_name,
                      const string& bucket_name,
                      const string& bucket_id,
                      const rgw_obj_index_key& obj_key);
  int objexp_hint_list(const string& oid,
                       const ceph::real_time& start_time,
                       const ceph::real_time& end_time,
                       const int max_entries,
                       const string& marker,
                       list<cls_timeindex_entry>& entries,
                       string *out_marker,
                       bool *truncated);
  int objexp_hint_parse(cls_timeindex_entry &ti_entry,
                        objexp_hint_entry& hint_entry);
  int objexp_hint_trim(const string& oid,
                       const ceph::real_time& start_time,
                       const ceph::real_time& end_time,
                       const string& from_marker = std::string(),
                       const string& to_marker = std::string());

  int lock_exclusive(const rgw_pool& pool, const string& oid, ceph::timespan& duration, string& zone_id, string& owner_id);
  int unlock(const rgw_pool& pool, const string& oid, string& zone_id, string& owner_id);

  void update_gc_chain(rgw_obj& head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain);
  int send_chain_to_gc(cls_rgw_obj_chain& chain, const string& tag, bool sync);
  int gc_operate(string& oid, librados::ObjectWriteOperation *op);
  int gc_aio_operate(string& oid, librados::ObjectWriteOperation *op, librados::AioCompletion **pc = nullptr);
  int gc_operate(string& oid, librados::ObjectReadOperation *op, bufferlist *pbl);

  int list_gc_objs(int *index, string& marker, uint32_t max, bool expired_only, std::list<cls_rgw_gc_obj_info>& result, bool *truncated);
  int process_gc(bool expired_only);
  bool process_expire_objects();
  int defer_gc(void *ctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj);

  int process_lc();
  int list_lc_progress(const string& marker, uint32_t max_entries, map<string, int> *progress_map);

  int bucket_check_index(RGWBucketInfo& bucket_info,
                         map<RGWObjCategory, RGWStorageStats> *existing_stats,
                         map<RGWObjCategory, RGWStorageStats> *calculated_stats);
  int bucket_rebuild_index(RGWBucketInfo& bucket_info);
  int bucket_set_reshard(const RGWBucketInfo& bucket_info, const cls_rgw_bucket_instance_entry& entry);
  int remove_objs_from_index(RGWBucketInfo& bucket_info, list<rgw_obj_index_key>& oid_list);
  int move_rados_obj(librados::IoCtx& src_ioctx,
       const string& src_oid, const string& src_locator,
              librados::IoCtx& dst_ioctx,
       const string& dst_oid, const string& dst_locator);
  int fix_head_obj_locator(const RGWBucketInfo& bucket_info, bool copy_obj, bool remove_bad, rgw_obj_key& key);
  int fix_tail_obj_locator(const RGWBucketInfo& bucket_info, rgw_obj_key& key, bool fix, bool *need_fix);

  int cls_user_get_header(const string& user_id, cls_user_header *header);
  int cls_user_reset_stats(const string& user_id);
  int cls_user_get_header_async(const string& user_id, RGWGetUserHeader_CB *ctx);
  int cls_user_sync_bucket_stats(rgw_raw_obj& user_obj, const RGWBucketInfo& bucket_info);
  int cls_user_list_buckets(rgw_raw_obj& obj,
                            const string& in_marker,
                            const string& end_marker,
                            int max_entries,
                            list<cls_user_bucket_entry>& entries,
                            string *out_marker,
                            bool *truncated);
  int cls_user_add_bucket(rgw_raw_obj& obj, const cls_user_bucket_entry& entry);
  int cls_user_update_buckets(rgw_raw_obj& obj, list<cls_user_bucket_entry>& entries, bool add);
  int cls_user_complete_stats_sync(rgw_raw_obj& obj);
  int complete_sync_user_stats(const rgw_user& user_id);
  int cls_user_remove_bucket(rgw_raw_obj& obj, const cls_user_bucket& bucket);
  int cls_user_get_bucket_stats(const rgw_bucket& bucket, cls_user_bucket_entry& entry);

  int check_quota(const rgw_user& bucket_owner, rgw_bucket& bucket,
                  RGWQuotaInfo& user_quota, RGWQuotaInfo& bucket_quota, uint64_t obj_size, bool check_size_only = false);

  int check_bucket_shards(const RGWBucketInfo& bucket_info, const rgw_bucket& bucket,
     RGWQuotaInfo& bucket_quota);

  int add_bucket_to_reshard(const RGWBucketInfo& bucket_info, uint32_t new_num_shards);

  uint64_t instance_id();

  librados::Rados* get_rados_handle();

  int delete_raw_obj_aio(const rgw_raw_obj& obj, list<librados::AioCompletion *>& handles);
  int delete_obj_aio(const rgw_obj& obj, RGWBucketInfo& info, RGWObjState *astate,
                     list<librados::AioCompletion *>& handles, bool keep_index_consistent);


 private:
  void prepare_mfa_write(librados::ObjectWriteOperation *op,
                         RGWObjVersionTracker *objv_tracker,
                         const ceph::real_time& mtime);
 public:
  string get_mfa_oid(const rgw_user& user);
  int get_mfa_ref(const rgw_user& user, rgw_rados_ref *ref);
  int check_mfa(const rgw_user& user, const string& otp_id, const string& pin);
  int create_mfa(const rgw_user& user, const rados::cls::otp::otp_info_t& config,
                 RGWObjVersionTracker *objv_tracker, const ceph::real_time& mtime);
  int remove_mfa(const rgw_user& user, const string& id,
                 RGWObjVersionTracker *objv_tracker, const ceph::real_time& mtime);
  int get_mfa(const rgw_user& user, const string& id, rados::cls::otp::otp_info_t *result);
  int list_mfa(const rgw_user& user, list<rados::cls::otp::otp_info_t> *result);
  int otp_get_current_time(const rgw_user& user, ceph::real_time *result);


  int set_mfa(const string& oid, const list<rados::cls::otp::otp_info_t>& entries, bool reset_obj,
              RGWObjVersionTracker *objv_tracker, const ceph::real_time& mtime);
  int list_mfa(const string& oid, list<rados::cls::otp::otp_info_t> *result,
               RGWObjVersionTracker *objv_tracker, ceph::real_time *pmtime);
 private:
# 2388 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
  void get_bucket_index_objects(const string& bucket_oid_base, uint32_t num_shards,
      map<int, string>& bucket_objs, int shard_id = -1);
# 2403 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
  int get_bucket_index_object(const string& bucket_oid_base, const string& obj_key,
      uint32_t num_shards, RGWBucketInfo::BIShardsHashType hash_type, string *bucket_obj, int *shard);

  void get_bucket_index_object(const string& bucket_oid_base, uint32_t num_shards,
                               int shard_id, string *bucket_obj);
# 2423 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
  int check_disk_state(librados::IoCtx io_ctx,
                       const RGWBucketInfo& bucket_info,
                       rgw_bucket_dir_entry& list_state,
                       rgw_bucket_dir_entry& object,
                       bufferlist& suggested_updates);







  int pool_iterate_begin(const rgw_pool& pool, RGWPoolIterCtx& ctx);
# 2444 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
  int pool_iterate_begin(const rgw_pool& pool, const string& cursor, RGWPoolIterCtx& ctx);






  string pool_iterate_get_cursor(RGWPoolIterCtx& ctx);
# 2462 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
  int pool_iterate(RGWPoolIterCtx& ctx, uint32_t num, vector<rgw_bucket_dir_entry>& objs,
                   bool *is_truncated, RGWAccessListFilter *filter);

  uint64_t next_bucket_id();
};

class RGWStoreManager {
public:
  RGWStoreManager() {}
  static RGWRados *get_storage(CephContext *cct, bool use_gc_thread, bool use_lc_thread, bool quota_threads,
          bool run_sync_thread, bool run_reshard_thread, bool use_cache = true) {
    RGWRados *store = init_storage_provider(cct, use_gc_thread, use_lc_thread, quota_threads, run_sync_thread,
         run_reshard_thread, use_cache);
    return store;
  }
  static RGWRados *get_raw_storage(CephContext *cct) {
    RGWRados *store = init_raw_storage_provider(cct);
    return store;
  }
  static RGWRados *init_storage_provider(CephContext *cct, bool use_gc_thread, bool use_lc_thread, bool quota_threads, bool run_sync_thread, bool run_reshard_thread, bool use_metadata_cache);
  static RGWRados *init_raw_storage_provider(CephContext *cct);
  static void close_storage(RGWRados *store);

};

class RGWMPObj {
  string oid;
  string prefix;
  string meta;
  string upload_id;
public:
  RGWMPObj() {}
  RGWMPObj(const string& _oid, const string& _upload_id) {
    init(_oid, _upload_id, _upload_id);
  }
  void init(const string& _oid, const string& _upload_id) {
    init(_oid, _upload_id, _upload_id);
  }
  void init(const string& _oid, const string& _upload_id, const string& part_unique_str) {
    if (_oid.empty()) {
      clear();
      return;
    }
    oid = _oid;
    upload_id = _upload_id;
    prefix = oid + ".";
    meta = prefix + upload_id + MP_META_SUFFIX;
    prefix.append(part_unique_str);
  }
  const string& get_meta() const { return meta; }
  string get_part(int num) const {
    char buf[16];
    snprintf(buf, 16, ".%d", num);
    string s = prefix;
    s.append(buf);
    return s;
  }
  string get_part(const string& part) const {
    string s = prefix;
    s.append(".");
    s.append(part);
    return s;
  }
  const string& get_upload_id() const {
    return upload_id;
  }
  const string& get_key() const {
    return oid;
  }
  bool from_meta(string& meta) {
    int end_pos = meta.rfind('.');
    if (end_pos < 0)
      return false;
    int mid_pos = meta.rfind('.', end_pos - 1);
    if (mid_pos < 0)
      return false;
    oid = meta.substr(0, mid_pos);
    upload_id = meta.substr(mid_pos + 1, end_pos - mid_pos - 1);
    init(oid, upload_id, upload_id);
    return true;
  }
  void clear() {
    oid = "";
    prefix = "";
    meta = "";
    upload_id = "";
  }
};


class RGWRadosThread {
  class Worker : public Thread {
    CephContext *cct;
    RGWRadosThread *processor;
    Mutex lock;
    Cond cond;

    void wait() {
      Mutex::Locker l(lock);
      cond.Wait(lock);
    };

    void wait_interval(const utime_t& wait_time) {
      Mutex::Locker l(lock);
      cond.WaitInterval(lock, wait_time);
    }

  public:
    Worker(CephContext *_cct, RGWRadosThread *_p) : cct(_cct), processor(_p), lock("RGWRadosThread::Worker") {}
    void *entry() override;
    void signal() {
      Mutex::Locker l(lock);
      cond.Signal();
    }
  };

  Worker *worker;

protected:
  CephContext *cct;
  RGWRados *store;

  std::atomic<bool> down_flag = { false };

  string thread_name;

  virtual uint64_t interval_msec() = 0;
  virtual void stop_process() {}
public:
  RGWRadosThread(RGWRados *_store, const string& thread_name = "radosgw")
    : worker(
# 2592 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 3 4
            __null
# 2592 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h"
                ), cct(_store->ctx()), store(_store), thread_name(thread_name) {}
  virtual ~RGWRadosThread() {
    stop();
  }

  virtual int init() { return 0; }
  virtual int process() = 0;

  bool going_down() { return down_flag; }

  void start();
  void stop();

  void signal() {
    if (worker) {
      worker->signal();
    }
  }
};
# 38 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h"
class RGWRados;
class RGWSysObjectCtx;
struct RGWObjVersionTracker;
class optional_yield;

struct obj_version;

int rgw_init_ioctx(librados::Rados *rados, const rgw_pool& pool,
                   librados::IoCtx& ioctx,
     bool create = false,
     bool mostly_omap = false);

int rgw_put_system_obj(RGWRados *rgwstore, const rgw_pool& pool, const string& oid, bufferlist& data, bool exclusive,
                       RGWObjVersionTracker *objv_tracker, real_time set_mtime, map<string, bufferlist> *pattrs = 
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h" 3 4
                                                                                                                 __null
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h"
                                                                                                                     );
int rgw_get_system_obj(RGWRados *rgwstore, RGWSysObjectCtx& obj_ctx, const rgw_pool& pool, const string& key, bufferlist& bl,
                       RGWObjVersionTracker *objv_tracker, real_time *pmtime, map<string, bufferlist> *pattrs = 
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h" 3 4
                                                                                                               __null
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h"
                                                                                                                   ,
                       rgw_cache_entry_info *cache_info = 
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h" 3 4
                                                         __null
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tools.h"
                                                             ,
         boost::optional<obj_version> refresh_version = boost::none);
int rgw_delete_system_obj(RGWRados *rgwstore, const rgw_pool& pool, const string& oid,
                          RGWObjVersionTracker *objv_tracker);

const char *rgw_find_mime_by_ext(string& ext);

void rgw_filter_attrset(map<string, bufferlist>& unfiltered_attrset, const string& check_prefix,
                        map<string, bufferlist> *attrset);



extern thread_local bool is_asio_thread;


int rgw_rados_operate(librados::IoCtx& ioctx, const std::string& oid,
                      librados::ObjectReadOperation *op, bufferlist* pbl,
                      optional_yield y);
int rgw_rados_operate(librados::IoCtx& ioctx, const std::string& oid,
                      librados::ObjectWriteOperation *op, optional_yield y);

int rgw_tools_init(CephContext *cct);
void rgw_tools_cleanup();

template<class H, size_t S>
class RGWEtag
{
  H hash;

public:
  RGWEtag() {}

  void update(const char *buf, size_t len) {
    hash.Update((const unsigned char *)buf, len);
  }

  void update(bufferlist& bl) {
    if (bl.length() > 0) {
      update(bl.c_str(), bl.length());
    }
  }

  void update(const string& s) {
    if (!s.empty()) {
      update(s.c_str(), s.size());
    }
  }
  void finish(string *etag) {
    char etag_buf[S];
    char etag_buf_str[S * 2 + 16];

    hash.Final((unsigned char *)etag_buf);
    buf_to_hex((const unsigned char *)etag_buf, S,
        etag_buf_str);

    *etag = etag_buf_str;
  }
};

using RGWMD5Etag = RGWEtag<MD5, 16>;

class RGWDataAccess
{
  RGWRados *store;
  std::unique_ptr<RGWSysObjectCtx> sysobj_ctx;

public:
  RGWDataAccess(RGWRados *_store);

  class Object;
  class Bucket;

  using BucketRef = std::shared_ptr<Bucket>;
  using ObjectRef = std::shared_ptr<Object>;

  class Bucket : public enable_shared_from_this<Bucket> {
    friend class RGWDataAccess;
    friend class Object;

    RGWDataAccess *sd{nullptr};
    RGWBucketInfo bucket_info;
    string tenant;
    string name;
    string bucket_id;
    ceph::real_time mtime;
    map<std::string, bufferlist> attrs;

    RGWAccessControlPolicy policy;
    int finish_init();

    Bucket(RGWDataAccess *_sd,
    const string& _tenant,
    const string& _name,
    const string& _bucket_id) : sd(_sd),
                                       tenant(_tenant),
                                       name(_name),
           bucket_id(_bucket_id) {}
    Bucket(RGWDataAccess *_sd) : sd(_sd) {}
    int init();
    int init(const RGWBucketInfo& _bucket_info, const map<string, bufferlist>& _attrs);
  public:
    int get_object(const rgw_obj_key& key,
     ObjectRef *obj);

  };


  class Object {
    RGWDataAccess *sd{nullptr};
    BucketRef bucket;
    rgw_obj_key key;

    ceph::real_time mtime;
    string etag;
    std::optional<uint64_t> olh_epoch;
    ceph::real_time delete_at;
    std::optional<string> user_data;

    std::optional<bufferlist> aclbl;

    Object(RGWDataAccess *_sd,
           BucketRef&& _bucket,
           const rgw_obj_key& _key) : sd(_sd),
                                      bucket(_bucket),
                                      key(_key) {}
  public:
    int put(bufferlist& data, map<string, bufferlist>& attrs);

    void set_mtime(const ceph::real_time& _mtime) {
      mtime = _mtime;
    }

    void set_etag(const string& _etag) {
      etag = _etag;
    }

    void set_olh_epoch(uint64_t epoch) {
      olh_epoch = epoch;
    }

    void set_delete_at(ceph::real_time _delete_at) {
      delete_at = _delete_at;
    }

    void set_user_data(const string& _user_data) {
      user_data = _user_data;
    }

    void set_policy(const RGWAccessControlPolicy& policy);

    friend class Bucket;
  };

  int get_bucket(const string& tenant,
   const string name,
   const string bucket_id,
   BucketRef *bucket) {
    bucket->reset(new Bucket(this, tenant, name, bucket_id));
    return (*bucket)->init();
  }

  int get_bucket(const RGWBucketInfo& bucket_info,
   const map<string, bufferlist>& attrs,
   BucketRef *bucket) {
    bucket->reset(new Bucket(this));
    return (*bucket)->init(bucket_info, attrs);
  }
  friend class Bucket;
  friend class Object;
};

using RGWDataAccessRef = std::shared_ptr<RGWDataAccess>;
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 2






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_formats.h" 1
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_formats.h"
struct plain_stack_entry {
  int size;
  bool is_array;
};





class RGWFormatter_Plain : public Formatter {
  void reset_buf();
public:
  explicit RGWFormatter_Plain(bool use_kv = false);
  ~RGWFormatter_Plain() override;

  void set_status(int status, const char* status_name) override {};
  void output_header() override {};
  void output_footer() override {};
  void enable_line_break() override {};
  void flush(ostream& os) override;
  void reset() override;

  void open_array_section(const char *name) override;
  void open_array_section_in_ns(const char *name, const char *ns) override;
  void open_object_section(const char *name) override;
  void open_object_section_in_ns(const char *name, const char *ns) override;
  void close_section() override;
  void dump_unsigned(const char *name, uint64_t u) override;
  void dump_int(const char *name, int64_t u) override;
  void dump_float(const char *name, double d) override;
  void dump_string(const char *name, std::string_view s) override;
  std::ostream& dump_stream(const char *name) override;
  void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
  int get_len() const override;
  void write_raw_data(const char *data) override;

private:
  void write_data(const char *fmt, ...);
  void dump_value_int(const char *name, const char *fmt, ...);

  char *buf = nullptr;
  int len = 0;
  int max_len = 0;

  std::list<struct plain_stack_entry> stack;
  size_t min_stack_level = 0;
  bool use_kv;
  bool wrote_something = 0;
};



class RGWSwiftWebsiteListingFormatter {
  std::ostream& ss;
  const std::string prefix;
protected:
  std::string format_name(const std::string& item_name) const;
public:
  RGWSwiftWebsiteListingFormatter(std::ostream& ss,
                                  std::string prefix)
    : ss(ss),
      prefix(std::move(prefix)) {
  }



  void generate_header(const std::string& dir_path,
                       const std::string& css_path);
  void generate_footer();
  void dump_object(const rgw_bucket_dir_entry& objent);
  void dump_subdir(const std::string& name);
};


class RGWFormatterFlusher {
protected:
  Formatter *formatter;
  bool flushed;
  bool started;
  virtual void do_flush() = 0;
  virtual void do_start(int ret) {}
  void set_formatter(Formatter *f) {
    formatter = f;
  }
public:
  explicit RGWFormatterFlusher(Formatter *f) : formatter(f), flushed(false), started(false) {}
  virtual ~RGWFormatterFlusher() {}

  void flush() {
    do_flush();
    flushed = true;
  }

  virtual void start(int client_ret) {
    if (!started)
      do_start(client_ret);
    started = true;
  }

  Formatter *get_formatter() { return formatter; }
  bool did_flush() { return flushed; }
  bool did_start() { return started; }
};

class RGWStreamFlusher : public RGWFormatterFlusher {
  ostream& os;
protected:
  void do_flush() override {
    formatter->flush(os);
  }
public:
  RGWStreamFlusher(Formatter *f, ostream& _os) : RGWFormatterFlusher(f), os(_os) {}
};

class RGWNullFlusher : public RGWFormatterFlusher {
protected:
  void do_flush() override {
  }
public:
  RGWNullFlusher() : RGWFormatterFlusher(nullptr) {}
};
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 2
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
struct RGWUID
{
  rgw_user user_id;
  void encode(bufferlist& bl) const {
    string s;
    user_id.to_str(s);
    using ceph::encode;
    encode(s, bl);
  }
  void decode(bufferlist::const_iterator& bl) {
    string s;
    using ceph::decode;
    decode(s, bl);
    user_id.from_str(s);
  }
};
inline void encode(const RGWUID &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWUID &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

extern int rgw_user_sync_all_stats(RGWRados *store, const rgw_user& user_id);
extern int rgw_user_get_all_buckets_stats(RGWRados *store, const rgw_user& user_id, map<string, cls_user_bucket_entry>&buckets_usage_map);




extern void rgw_get_anon_user(RGWUserInfo& info);





extern int rgw_store_user_info(RGWRados *store,
                               RGWUserInfo& info,
                               RGWUserInfo *old_info,
                               RGWObjVersionTracker *objv_tracker,
                               real_time mtime,
                               bool exclusive,
                               map<string, bufferlist> *pattrs = 
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                __null
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                    );





extern int rgw_get_user_info_by_uid(RGWRados *store,
                                    const rgw_user& user_id,
                                    RGWUserInfo& info,
                                    RGWObjVersionTracker *objv_tracker = 
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                        __null
# 79 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                            ,
                                    real_time *pmtime = 
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                           __null
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                               ,
                                    rgw_cache_entry_info *cache_info = 
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                        __null
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                            ,
                                    map<string, bufferlist> *pattrs = 
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                        __null
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                            );




extern int rgw_get_user_info_by_email(RGWRados *store, string& email, RGWUserInfo& info,
                                      RGWObjVersionTracker *objv_tracker = 
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                          __null
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                              , real_time *pmtime = 
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                                                    __null
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                                                        );




extern int rgw_get_user_info_by_swift(RGWRados *store,
                                      const string& swift_name,
                                      RGWUserInfo& info,
                                      RGWObjVersionTracker *objv_tracker = nullptr,
                                      real_time *pmtime = nullptr);




extern int rgw_get_user_info_by_access_key(RGWRados* store,
                                           const std::string& access_key,
                                           RGWUserInfo& info,
                                           RGWObjVersionTracker* objv_tracker = nullptr,
                                           real_time* pmtime = nullptr);





extern int rgw_get_user_attrs_by_uid(RGWRados *store,
                                     const rgw_user& user_id,
                                     map<string, bufferlist>& attrs,
                                     RGWObjVersionTracker *objv_tracker = 
# 115 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                         __null
# 115 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                             );



extern int rgw_delete_user(RGWRados *store, RGWUserInfo& user, RGWObjVersionTracker& objv_tracker);




extern int rgw_remove_key_index(RGWRados *store, RGWAccessKey& access_key);
extern int rgw_remove_uid_index(RGWRados *store, rgw_user& uid);
extern int rgw_remove_email_index(RGWRados *store, string& email);
extern int rgw_remove_swift_name_index(RGWRados *store, string& swift_name);

extern void rgw_perm_to_str(uint32_t mask, char *buf, int len);
extern uint32_t rgw_str_to_perm(const char *str);

extern int rgw_validate_tenant_name(const string& t);

enum ObjectKeyType {
  KEY_TYPE_SWIFT,
  KEY_TYPE_S3,
  KEY_TYPE_UNDEFINED
};

enum RGWKeyPoolOp {
  GENERATE_KEY,
  MODIFY_KEY
};

enum RGWUserId {
  RGW_USER_ID,
  RGW_SWIFT_USERNAME,
  RGW_USER_EMAIL,
  RGW_ACCESS_KEY,
};





struct RGWUserAdminOpState {

  RGWUserInfo info;
  rgw_user user_id;
  std::string user_email;
  std::string display_name;
  int32_t max_buckets;
  __u8 suspended;
  __u8 admin;
  __u8 system;
  __u8 exclusive;
  __u8 fetch_stats;
  __u8 sync_stats;
  std::string caps;
  RGWObjVersionTracker objv;
  uint32_t op_mask;
  map<int, string> temp_url_keys;


  std::string subuser;
  uint32_t perm_mask;


  std::string id;
  std::string key;
  int32_t key_type;

  std::set<string> mfa_ids;


  bool existing_user;
  bool existing_key;
  bool existing_subuser;
  bool existing_email;
  bool subuser_specified;
  bool gen_secret;
  bool gen_access;
  bool gen_subuser;
  bool id_specified;
  bool key_specified;
  bool type_specified;
  bool key_type_setbycontext;
  bool purge_data;
  bool purge_keys;
  bool display_name_specified;
  bool user_email_specified;
  bool max_buckets_specified;
  bool perm_specified;
  bool op_mask_specified;
  bool caps_specified;
  bool suspension_op;
  bool admin_specified = false;
  bool system_specified;
  bool key_op;
  bool temp_url_key_specified;
  bool found_by_uid;
  bool found_by_email;
  bool found_by_key;
  bool mfa_ids_specified;


  bool populated;
  bool initialized;
  bool key_params_checked;
  bool subuser_params_checked;
  bool user_params_checked;

  bool bucket_quota_specified;
  bool user_quota_specified;

  RGWQuotaInfo bucket_quota;
  RGWQuotaInfo user_quota;


  std::string marker;
  uint32_t max_entries;

  void set_access_key(const std::string& access_key) {
    if (access_key.empty())
      return;

    id = access_key;
    id_specified = true;
    gen_access = false;
    key_op = true;
  }

  void set_secret_key(const std::string& secret_key) {
    if (secret_key.empty())
      return;

    key = secret_key;
    key_specified = true;
    gen_secret = false;
    key_op = true;
  }

  void set_user_id(rgw_user& id) {
    if (id.empty())
      return;

    user_id = id;
  }

  void set_user_email(std::string& email) {

    boost::algorithm::to_lower(email);
    user_email = email;
    user_email_specified = true;
  }

  void set_display_name(const std::string& name) {
    if (name.empty())
      return;

    display_name = name;
    display_name_specified = true;
  }

  void set_subuser(std::string& _subuser) {
    if (_subuser.empty())
      return;

    size_t pos = _subuser.find(":");
    if (pos != string::npos) {
      rgw_user tmp_id;
      tmp_id.from_str(_subuser.substr(0, pos));
      if (tmp_id.tenant.empty()) {
        user_id.id = tmp_id.id;
      } else {
        user_id = tmp_id;
      }
      subuser = _subuser.substr(pos+1);
    } else {
      subuser = _subuser;
    }

    subuser_specified = true;
  }

  void set_caps(const std::string& _caps) {
    if (_caps.empty())
      return;

    caps = _caps;
    caps_specified = true;
  }

  void set_perm(uint32_t perm) {
    perm_mask = perm;
    perm_specified = true;
  }

  void set_op_mask(uint32_t mask) {
    op_mask = mask;
    op_mask_specified = true;
  }

  void set_temp_url_key(const string& key, int index) {
    temp_url_keys[index] = key;
    temp_url_key_specified = true;
  }

  void set_key_type(int32_t type) {
    key_type = type;
    type_specified = true;
  }

  void set_suspension(__u8 is_suspended) {
    suspended = is_suspended;
    suspension_op = true;
  }

  void set_admin(__u8 is_admin) {
    admin = is_admin;
    admin_specified = true;
  }

  void set_system(__u8 is_system) {
    system = is_system;
    system_specified = true;
  }

  void set_exclusive(__u8 is_exclusive) {
    exclusive = is_exclusive;
  }

  void set_fetch_stats(__u8 is_fetch_stats) {
    fetch_stats = is_fetch_stats;
  }

  void set_sync_stats(__u8 is_sync_stats) {
    sync_stats = is_sync_stats;
  }

  void set_user_info(RGWUserInfo& user_info) {
    user_id = user_info.user_id;
    info = user_info;
  }

  void set_max_buckets(int32_t mb) {
    max_buckets = mb;
    max_buckets_specified = true;
  }

  void set_gen_access() {
    gen_access = true;
    key_op = true;
  }

  void set_gen_secret() {
    gen_secret = true;
    key_op = true;
  }

  void set_generate_key() {
    if (id.empty())
      gen_access = true;
    if (key.empty())
      gen_secret = true;
    key_op = true;
  }

  void clear_generate_key() {
    gen_access = false;
    gen_secret = false;
  }

  void set_purge_keys() {
    purge_keys = true;
    key_op = true;
  }

  void set_bucket_quota(RGWQuotaInfo& quota) {
    bucket_quota = quota;
    bucket_quota_specified = true;
  }

  void set_user_quota(RGWQuotaInfo& quota) {
    user_quota = quota;
    user_quota_specified = true;
  }

  void set_mfa_ids(const std::set<string>& ids) {
    mfa_ids = ids;
    mfa_ids_specified = true;
  }

  bool is_populated() { return populated; }
  bool is_initialized() { return initialized; }
  bool has_existing_user() { return existing_user; }
  bool has_existing_key() { return existing_key; }
  bool has_existing_subuser() { return existing_subuser; }
  bool has_existing_email() { return existing_email; }
  bool has_subuser() { return subuser_specified; }
  bool has_key_op() { return key_op; }
  bool has_caps_op() { return caps_specified; }
  bool has_suspension_op() { return suspension_op; }
  bool has_subuser_perm() { return perm_specified; }
  bool has_op_mask() { return op_mask_specified; }
  bool will_gen_access() { return gen_access; }
  bool will_gen_secret() { return gen_secret; }
  bool will_gen_subuser() { return gen_subuser; }
  bool will_purge_keys() { return purge_keys; }
  bool will_purge_data() { return purge_data; }
  bool will_generate_subuser() { return gen_subuser; }
  bool has_bucket_quota() { return bucket_quota_specified; }
  bool has_user_quota() { return user_quota_specified; }
  void set_populated() { populated = true; }
  void clear_populated() { populated = false; }
  void set_initialized() { initialized = true; }
  void set_existing_user(bool flag) { existing_user = flag; }
  void set_existing_key(bool flag) { existing_key = flag; }
  void set_existing_subuser(bool flag) { existing_subuser = flag; }
  void set_existing_email(bool flag) { existing_email = flag; }
  void set_purge_data(bool flag) { purge_data = flag; }
  void set_generate_subuser(bool flag) { gen_subuser = flag; }
  __u8 get_suspension_status() { return suspended; }
  int32_t get_key_type() {return key_type; }
  uint32_t get_subuser_perm() { return perm_mask; }
  int32_t get_max_buckets() { return max_buckets; }
  uint32_t get_op_mask() { return op_mask; }
  RGWQuotaInfo& get_bucket_quota() { return bucket_quota; }
  RGWQuotaInfo& get_user_quota() { return user_quota; }
  set<string>& get_mfa_ids() { return mfa_ids; }

  rgw_user& get_user_id() { return user_id; }
  std::string get_subuser() { return subuser; }
  std::string get_access_key() { return id; }
  std::string get_secret_key() { return key; }
  std::string get_caps() { return caps; }
  std::string get_user_email() { return user_email; }
  std::string get_display_name() { return display_name; }
  map<int, std::string>& get_temp_url_keys() { return temp_url_keys; }

  RGWUserInfo& get_user_info() { return info; }

  map<std::string, RGWAccessKey> *get_swift_keys() { return &info.swift_keys; }
  map<std::string, RGWAccessKey> *get_access_keys() { return &info.access_keys; }
  map<std::string, RGWSubUser> *get_subusers() { return &info.subusers; }

  RGWUserCaps *get_caps_obj() { return &info.caps; }

  std::string build_default_swift_kid() {
    if (user_id.empty() || subuser.empty())
      return "";

    std::string kid;
    user_id.to_str(kid);
    kid.append(":");
    kid.append(subuser);

    return kid;
  }

  std::string generate_subuser() {
    if (user_id.empty())
      return "";

    std::string generated_subuser;
    user_id.to_str(generated_subuser);
    std::string rand_suffix;

    int sub_buf_size = 5 + 1;
    char sub_buf[5 + 1];

    gen_rand_alphanumeric_upper(g_ceph_context, sub_buf, sub_buf_size);

    rand_suffix = sub_buf;
    if (rand_suffix.empty())
      return "";

    generated_subuser.append(rand_suffix);
    subuser = generated_subuser;

    return generated_subuser;
  }

  RGWUserAdminOpState() : user_id("anonymous")
  {
    max_buckets = 1000;
    key_type = -1;
    perm_mask = 0x00;
    suspended = 0;
    admin = 0;
    system = 0;
    exclusive = 0;
    fetch_stats = 0;
    op_mask = 0;

    existing_user = false;
    existing_key = false;
    existing_subuser = false;
    existing_email = false;
    subuser_specified = false;
    caps_specified = false;
    purge_keys = false;
    gen_secret = false;
    gen_access = false;
    gen_subuser = false;
    id_specified = false;
    key_specified = false;
    type_specified = false;
    key_type_setbycontext = false;
    purge_data = false;
    display_name_specified = false;
    user_email_specified = false;
    max_buckets_specified = false;
    perm_specified = false;
    op_mask_specified = false;
    suspension_op = false;
    system_specified = false;
    key_op = false;
    populated = false;
    initialized = false;
    key_params_checked = false;
    subuser_params_checked = false;
    user_params_checked = false;
    bucket_quota_specified = false;
    temp_url_key_specified = false;
    user_quota_specified = false;
    found_by_uid = false;
    found_by_email = false;
    found_by_key = false;
    mfa_ids_specified = false;
    max_entries = 1000;
    marker = "";
  }
};

class RGWUser;

class RGWAccessKeyPool
{
  RGWUser *user;

  std::map<std::string, int, ltstr_nocase> key_type_map;
  rgw_user user_id;
  RGWRados *store;

  map<std::string, RGWAccessKey> *swift_keys;
  map<std::string, RGWAccessKey> *access_keys;


  bool keys_allowed;

private:
  int create_key(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                      __null
# 563 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                          );
  int generate_key(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 564 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                        __null
# 564 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                            );
  int modify_key(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 565 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                      __null
# 565 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                          );

  int check_key_owner(RGWUserAdminOpState& op_state);
  bool check_existing_key(RGWUserAdminOpState& op_state);
  int check_op(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 569 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                    __null
# 569 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                        );


  int execute_add(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int execute_remove(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int remove_subuser_keys(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);

  int add(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int remove(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
public:
  explicit RGWAccessKeyPool(RGWUser* usr);
  ~RGWAccessKeyPool();

  int init(RGWUserAdminOpState& op_state);


  int add(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 585 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                               __null
# 585 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                   );
  int remove(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                  __null
# 586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                      );

  friend class RGWUser;
  friend class RGWSubUserPool;
};

class RGWSubUserPool
{
  RGWUser *user;

  rgw_user user_id;
  RGWRados *store;
  bool subusers_allowed;

  map<string, RGWSubUser> *subuser_map;

private:
  int check_op(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 603 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                    __null
# 603 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                        );


  int execute_add(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int execute_remove(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int execute_modify(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);

  int add(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int remove(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int modify(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
public:
  explicit RGWSubUserPool(RGWUser *user);
  ~RGWSubUserPool();

  bool exists(std::string subuser);
  int init(RGWUserAdminOpState& op_state);


  int add(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 621 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                               __null
# 621 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                   );
  int remove(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 622 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                  __null
# 622 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                      );
  int modify(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 623 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                  __null
# 623 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                      );

  friend class RGWUser;
};

class RGWUserCapPool
{
  RGWUserCaps *caps;
  bool caps_allowed;
  RGWUser *user;

private:
  int add(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);
  int remove(RGWUserAdminOpState& op_state, std::string *err_msg, bool defer_save);

public:
  explicit RGWUserCapPool(RGWUser *user);
  ~RGWUserCapPool();

  int init(RGWUserAdminOpState& op_state);


  int add(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 645 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                               __null
# 645 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                   );
  int remove(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 646 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                  __null
# 646 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                      );

  friend class RGWUser;
};

class RGWUser
{

private:
  RGWUserInfo old_info;
  RGWRados *store;

  rgw_user user_id;
  bool info_stored;

  void set_populated() { info_stored = true; }
  void clear_populated() { info_stored = false; }
  bool is_populated() { return info_stored; }

  int check_op(RGWUserAdminOpState& req, std::string *err_msg);
  int update(RGWUserAdminOpState& op_state, std::string *err_msg);

  void clear_members();
  void init_default();


  int execute_add(RGWUserAdminOpState& op_state, std::string *err_msg);
  int execute_remove(RGWUserAdminOpState& op_state, std::string *err_msg);
  int execute_modify(RGWUserAdminOpState& op_state, std::string *err_msg);

public:
  RGWUser();
  ~RGWUser();

  int init(RGWRados *storage, RGWUserAdminOpState& op_state);

  int init_storage(RGWRados *storage);
  int init(RGWUserAdminOpState& op_state);
  int init_members(RGWUserAdminOpState& op_state);

  RGWRados *get_store() { return store; }


  RGWUserCapPool caps;
  RGWAccessKeyPool keys;
  RGWSubUserPool subusers;


  int add(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 694 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                               __null
# 694 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                   );
  int remove(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 695 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                  __null
# 695 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                      );


  int remove(std::string *err_msg = 
# 698 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                   __null
# 698 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                       );

  int modify(RGWUserAdminOpState& op_state, std::string *err_msg = 
# 700 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                  __null
# 700 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                      );


  int info(RGWUserAdminOpState& op_state, RGWUserInfo& fetched_info, std::string *err_msg = 
# 703 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                                                           __null
# 703 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                                               );


  int info (RGWUserInfo& fetched_info, std::string *err_msg = 
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h" 3 4
                                                             __null
# 706 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_user.h"
                                                                 );


  int list(RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  friend class RGWAccessKeyPool;
  friend class RGWSubUserPool;
  friend class RGWUserCapPool;
};



class RGWUserAdminOp_User
{
public:
  static int list(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int info(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int create(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int modify(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int remove(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);
};

class RGWUserAdminOp_Subuser
{
public:
  static int create(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int modify(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int remove(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);
};

class RGWUserAdminOp_Key
{
public:
  static int create(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int remove(RGWRados *store,
                  RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);
};

class RGWUserAdminOp_Caps
{
public:
  static int add(RGWRados *store,
    RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);

  static int remove(RGWRados *store,
    RGWUserAdminOpState& op_state, RGWFormatterFlusher& flusher);
};

class RGWMetadataManager;

extern void rgw_user_init(RGWRados *store);
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
extern void rgw_get_buckets_obj(const rgw_user& user_id, string& buckets_obj_id);

extern int rgw_bucket_store_info(RGWRados *store, const string& bucket_name, bufferlist& bl, bool exclusive,
                                 map<string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker,
                                 real_time mtime);
extern int rgw_bucket_instance_store_info(RGWRados *store, string& oid, bufferlist& bl, bool exclusive,
                                 map<string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker,
                                 real_time mtime);

extern int rgw_bucket_parse_bucket_instance(const string& bucket_instance, string *target_bucket_instance, int *shard_id);
extern int rgw_bucket_parse_bucket_key(CephContext *cct, const string& key,
                                       rgw_bucket* bucket, int *shard_id);

extern int rgw_bucket_instance_remove_entry(RGWRados *store, const string& entry,
         RGWObjVersionTracker *objv_tracker);
extern void rgw_bucket_instance_key_to_oid(string& key);
extern void rgw_bucket_instance_oid_to_key(string& oid);

extern int rgw_bucket_delete_bucket_obj(RGWRados *store,
                                        const string& tenant_name,
                                        const string& bucket_name,
                                        RGWObjVersionTracker& objv_tracker);

extern int rgw_bucket_sync_user_stats(RGWRados *store, const rgw_user& user_id, const RGWBucketInfo& bucket_info);
extern int rgw_bucket_sync_user_stats(RGWRados *store, const string& tenant_name, const string& bucket_name);

extern std::string rgw_make_bucket_entry_name(const std::string& tenant_name,
                                              const std::string& bucket_name);
static inline void rgw_make_bucket_entry_name(const string& tenant_name,
                                              const string& bucket_name,
                                              std::string& bucket_entry) {
  bucket_entry = rgw_make_bucket_entry_name(tenant_name, bucket_name);
}

extern void rgw_parse_url_bucket(const string& bucket,
                                 const string& auth_tenant,
                                 string &tenant_name, string &bucket_name);

struct RGWBucketCompleteInfo {
  RGWBucketInfo info;
  map<string, bufferlist> attrs;

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};

class RGWBucketEntryMetadataObject : public RGWMetadataObject {
  RGWBucketEntryPoint ep;
public:
  RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, obj_version& v, real_time m) : ep(_ep) {
    objv = v;
    mtime = m;
  }

  void dump(Formatter *f) const override {
    ep.dump(f);
  }
};

class RGWBucketInstanceMetadataObject : public RGWMetadataObject {
  RGWBucketCompleteInfo info;
public:
  RGWBucketInstanceMetadataObject() {}
  RGWBucketInstanceMetadataObject(RGWBucketCompleteInfo& i, obj_version& v, real_time m) : info(i) {
    objv = v;
    mtime = m;
  }

  void dump(Formatter *f) const override {
    info.dump(f);
  }

  void decode_json(JSONObj *obj) {
    info.decode_json(obj);
  }

  RGWBucketInfo& get_bucket_info() { return info.info; }
};




class RGWUserBuckets
{
  std::map<std::string, RGWBucketEnt> buckets;

public:
  RGWUserBuckets() = default;
  RGWUserBuckets(RGWUserBuckets&&) = default;

  RGWUserBuckets& operator=(const RGWUserBuckets&) = default;

  void encode(bufferlist& bl) const {
    using ceph::encode;
    encode(buckets, bl);
  }
  void decode(bufferlist::const_iterator& bl) {
    using ceph::decode;
    decode(buckets, bl);
  }



  bool owns(string& name) {
    map<string, RGWBucketEnt>::iterator iter;
    iter = buckets.find(name);
    return (iter != buckets.end());
  }




  void add(const RGWBucketEnt& bucket) {
    buckets[bucket.bucket.name] = bucket;
  }




  void remove(const string& name) {
    map<string, RGWBucketEnt>::iterator iter;
    iter = buckets.find(name);
    if (iter != buckets.end()) {
      buckets.erase(iter);
    }
  }




  map<string, RGWBucketEnt>& get_buckets() { return buckets; }




  void clear() { buckets.clear(); }

  size_t count() { return buckets.size(); }
};
inline void encode(const RGWUserBuckets &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWUserBuckets &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWMetadataManager;
class RGWMetadataHandler;

class RGWBucketMetaHandlerAllocator {
public:
  static RGWMetadataHandler *alloc();
};

class RGWBucketInstanceMetaHandlerAllocator {
public:
  static RGWMetadataHandler *alloc();
};

class RGWArchiveBucketMetaHandlerAllocator {
public:
  static RGWMetadataHandler *alloc();
};

class RGWArchiveBucketInstanceMetaHandlerAllocator {
public:
  static RGWMetadataHandler *alloc();
};

extern void rgw_bucket_init(RGWMetadataManager *mm);




extern int rgw_read_user_buckets(RGWRados *store,
                                 const rgw_user& user_id,
                                 RGWUserBuckets& buckets,
                                 const string& marker,
                                 const string& end_marker,
                                 uint64_t max,
                                 bool need_stats,
     bool* is_truncated,
                                 uint64_t default_amount = 1000);

extern int rgw_link_bucket(RGWRados* store,
                           const rgw_user& user_id,
                           rgw_bucket& bucket,
                           ceph::real_time creation_time,
                           bool update_entrypoint = true);
extern int rgw_unlink_bucket(RGWRados *store, const rgw_user& user_id,
                             const string& tenant_name, const string& bucket_name, bool update_entrypoint = true);

extern int rgw_remove_object(RGWRados *store, const RGWBucketInfo& bucket_info, const rgw_bucket& bucket, rgw_obj_key& key);
extern int rgw_remove_bucket(RGWRados *store, rgw_bucket& bucket, bool delete_children);
extern int rgw_remove_bucket_bypass_gc(RGWRados *store, rgw_bucket& bucket, int concurrent_max);

extern int rgw_bucket_set_attrs(RGWRados *store, RGWBucketInfo& bucket_info,
                                map<string, bufferlist>& attrs,
                                RGWObjVersionTracker *objv_tracker);
extern int rgw_object_get_attr(RGWRados* store, const RGWBucketInfo& bucket_info,
                               const rgw_obj& obj, const char* attr_name,
                               bufferlist& out_bl);

extern void check_bad_user_bucket_mapping(RGWRados *store, const rgw_user& user_id, bool fix);

struct RGWBucketAdminOpState {
  rgw_user uid;
  std::string display_name;
  std::string bucket_name;
  std::string bucket_id;
  std::string object_name;

  bool list_buckets;
  bool stat_buckets;
  bool check_objects;
  bool fix_index;
  bool delete_child_objects;
  bool bucket_stored;
  int max_aio = 0;

  rgw_bucket bucket;

  RGWQuotaInfo quota;

  void set_fetch_stats(bool value) { stat_buckets = value; }
  void set_check_objects(bool value) { check_objects = value; }
  void set_fix_index(bool value) { fix_index = value; }
  void set_delete_children(bool value) { delete_child_objects = value; }

  void set_max_aio(int value) { max_aio = value; }

  void set_user_id(const rgw_user& user_id) {
    if (!user_id.empty())
      uid = user_id;
  }
  void set_bucket_name(const std::string& bucket_str) {
    bucket_name = bucket_str;
  }
  void set_object(std::string& object_str) {
    object_name = object_str;
  }
  void set_quota(RGWQuotaInfo& value) {
    quota = value;
  }


  rgw_user& get_user_id() { return uid; }
  std::string& get_user_display_name() { return display_name; }
  std::string& get_bucket_name() { return bucket_name; }
  std::string& get_object_name() { return object_name; }

  rgw_bucket& get_bucket() { return bucket; }
  void set_bucket(rgw_bucket& _bucket) {
    bucket = _bucket;
    bucket_stored = true;
  }

  void set_bucket_id(const string& bi) {
    bucket_id = bi;
  }
  const string& get_bucket_id() { return bucket_id; }

  bool will_fetch_stats() { return stat_buckets; }
  bool will_fix_index() { return fix_index; }
  bool will_delete_children() { return delete_child_objects; }
  bool will_check_objects() { return check_objects; }
  bool is_user_op() { return !uid.empty(); }
  bool is_system_op() { return uid.empty(); }
  bool has_bucket_stored() { return bucket_stored; }
  int get_max_aio() { return max_aio; }

  RGWBucketAdminOpState() : list_buckets(false), stat_buckets(false), check_objects(false),
                            fix_index(false), delete_child_objects(false),
                            bucket_stored(false) {}
};





class RGWBucket
{
  RGWUserBuckets buckets;
  RGWRados *store;
  RGWAccessHandle handle;

  RGWUserInfo user_info;
  std::string tenant;
  std::string bucket_name;

  bool failure;

  RGWBucketInfo bucket_info;

public:
  RGWBucket() : store(
# 314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                     __null
# 314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                         ), handle(
# 314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                   __null
# 314 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                       ), failure(false) {}
  int init(RGWRados *storage, RGWBucketAdminOpState& op_state);

  int check_bad_index_multipart(RGWBucketAdminOpState& op_state,
              RGWFormatterFlusher& flusher, std::string *err_msg = 
# 318 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                                                  __null
# 318 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                                      );

  int check_object_index(RGWBucketAdminOpState& op_state,
                         RGWFormatterFlusher& flusher,
                         std::string *err_msg = 
# 322 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                               __null
# 322 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                   );

  int check_index(RGWBucketAdminOpState& op_state,
          map<RGWObjCategory, RGWStorageStats>& existing_stats,
          map<RGWObjCategory, RGWStorageStats>& calculated_stats,
          std::string *err_msg = 
# 327 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                __null
# 327 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                    );

  int remove(RGWBucketAdminOpState& op_state, bool bypass_gc = false, bool keep_index_consistent = true, std::string *err_msg = 
# 329 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                                                                                                               __null
# 329 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                                                                                                   );
  int link(RGWBucketAdminOpState& op_state, std::string *err_msg = 
# 330 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                                                  __null
# 330 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                                      );
  int unlink(RGWBucketAdminOpState& op_state, std::string *err_msg = 
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                                                    __null
# 331 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                                        );
  int set_quota(RGWBucketAdminOpState& op_state, std::string *err_msg = 
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                                                       __null
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                                           );

  int remove_object(RGWBucketAdminOpState& op_state, std::string *err_msg = 
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                                                           __null
# 334 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                                               );
  int policy_bl_to_stream(bufferlist& bl, ostream& o);
  int get_policy(RGWBucketAdminOpState& op_state, RGWAccessControlPolicy& policy);

  void clear_failure() { failure = false; }

  const RGWBucketInfo& get_bucket_info() const { return bucket_info; }
};

class RGWBucketAdminOp
{
public:
  static int get_policy(RGWRados *store, RGWBucketAdminOpState& op_state,
                  RGWFormatterFlusher& flusher);
  static int get_policy(RGWRados *store, RGWBucketAdminOpState& op_state,
                  RGWAccessControlPolicy& policy);
  static int dump_s3_policy(RGWRados *store, RGWBucketAdminOpState& op_state,
                  ostream& os);

  static int unlink(RGWRados *store, RGWBucketAdminOpState& op_state);
  static int link(RGWRados *store, RGWBucketAdminOpState& op_state, string *err_msg = 
# 354 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                                                                     __null
# 354 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                                                                         );

  static int check_index(RGWRados *store, RGWBucketAdminOpState& op_state,
                  RGWFormatterFlusher& flusher);

  static int remove_bucket(RGWRados *store, RGWBucketAdminOpState& op_state, bool bypass_gc = false, bool keep_index_consistent = true);
  static int remove_object(RGWRados *store, RGWBucketAdminOpState& op_state);
  static int info(RGWRados *store, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher);
  static int limit_check(RGWRados *store, RGWBucketAdminOpState& op_state,
    const std::list<std::string>& user_ids,
    RGWFormatterFlusher& flusher,
    bool warnings_only = false);
  static int set_quota(RGWRados *store, RGWBucketAdminOpState& op_state);

  static int list_stale_instances(RGWRados *store, RGWBucketAdminOpState& op_state,
      RGWFormatterFlusher& flusher);

  static int clear_stale_instances(RGWRados *store, RGWBucketAdminOpState& op_state,
       RGWFormatterFlusher& flusher);
  static int fix_lc_shards(RGWRados *store, RGWBucketAdminOpState& op_state,
                           RGWFormatterFlusher& flusher);
  static int fix_obj_expiry(RGWRados *store, RGWBucketAdminOpState& op_state,
       RGWFormatterFlusher& flusher, bool dry_run = false);
};


enum DataLogEntityType {
  ENTITY_TYPE_UNKNOWN = 0,
  ENTITY_TYPE_BUCKET = 1,
};

struct rgw_data_change {
  DataLogEntityType entity_type;
  string key;
  real_time timestamp;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    uint8_t t = (uint8_t)entity_type;
    encode(t, bl);
    encode(key, bl);
    encode(timestamp, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     uint8_t t;
     decode(t, bl);
     entity_type = (DataLogEntityType)t;
     decode(key, bl);
     decode(timestamp, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const rgw_data_change &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_data_change &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_data_change_log_entry {
  string log_id;
  real_time log_timestamp;
  rgw_data_change entry;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(log_id, bl);
    encode(log_timestamp, bl);
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(log_id, bl);
     decode(log_timestamp, bl);
     decode(entry, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};
inline void encode(const rgw_data_change_log_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_data_change_log_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWDataChangesLogInfo {
  string marker;
  real_time last_update;

  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);
};

namespace rgw {
struct BucketChangeObserver;
}

class RGWDataChangesLog {
  CephContext *cct;
  RGWRados *store;
  rgw::BucketChangeObserver *observer = nullptr;

  int num_shards;
  string *oids;

  Mutex lock;
  RWLock modified_lock;
  map<int, set<string> > modified_shards;

  std::atomic<bool> down_flag = { false };

  struct ChangeStatus {
    real_time cur_expiration;
    real_time cur_sent;
    bool pending;
    RefCountedCond *cond;
    Mutex *lock;

    ChangeStatus() : pending(false), cond(
# 473 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h" 3 4
                                         __null
# 473 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_bucket.h"
                                             ) {
      lock = new Mutex("RGWDataChangesLog::ChangeStatus");
    }

    ~ChangeStatus() {
      delete lock;
    }
  };

  typedef std::shared_ptr<ChangeStatus> ChangeStatusPtr;

  lru_map<rgw_bucket_shard, ChangeStatusPtr> changes;

  map<rgw_bucket_shard, bool> cur_cycle;

  void _get_change(const rgw_bucket_shard& bs, ChangeStatusPtr& status);
  void register_renew(rgw_bucket_shard& bs);
  void update_renewed(rgw_bucket_shard& bs, real_time& expiration);

  class ChangesRenewThread : public Thread {
    CephContext *cct;
    RGWDataChangesLog *log;
    Mutex lock;
    Cond cond;

  public:
    ChangesRenewThread(CephContext *_cct, RGWDataChangesLog *_log) : cct(_cct), log(_log), lock("ChangesRenewThread::lock") {}
    void *entry() override;
    void stop();
  };

  ChangesRenewThread *renew_thread;

public:

  RGWDataChangesLog(CephContext *_cct, RGWRados *_store) : cct(_cct), store(_store),
                                                           lock("RGWDataChangesLog::lock"), modified_lock("RGWDataChangesLog::modified_lock"),
                                                           changes(cct->_conf->rgw_data_log_changes_size) {
    num_shards = cct->_conf->rgw_data_log_num_shards;

    oids = new string[num_shards];

    string prefix = cct->_conf->rgw_data_log_obj_prefix;

    if (prefix.empty()) {
      prefix = "data_log";
    }

    for (int i = 0; i < num_shards; i++) {
      char buf[16];
      snprintf(buf, sizeof(buf), "%s.%d", prefix.c_str(), i);
      oids[i] = buf;
    }

    renew_thread = new ChangesRenewThread(cct, this);
    renew_thread->create("rgw_dt_lg_renew");
  }

  ~RGWDataChangesLog();

  int choose_oid(const rgw_bucket_shard& bs);
  const std::string& get_oid(int shard_id) const { return oids[shard_id]; }
  int add_entry(rgw_bucket& bucket, int shard_id);
  int get_log_shard_id(rgw_bucket& bucket, int shard_id);
  int renew_entries();
  int list_entries(int shard, const real_time& start_time, const real_time& end_time, int max_entries,
     list<rgw_data_change_log_entry>& entries,
     const string& marker,
     string *out_marker,
     bool *truncated);
  int trim_entries(int shard_id, const real_time& start_time, const real_time& end_time,
                   const string& start_marker, const string& end_marker);
  int get_info(int shard_id, RGWDataChangesLogInfo *info);
  int lock_exclusive(int shard_id, timespan duration, string& zone_id, string& owner_id);
  int unlock(int shard_id, string& zone_id, string& owner_id);
  struct LogMarker {
    int shard;
    string marker;

    LogMarker() : shard(0) {}
  };
  int list_entries(const real_time& start_time, const real_time& end_time, int max_entries,
               list<rgw_data_change_log_entry>& entries, LogMarker& marker, bool *ptruncated);

  void mark_modified(int shard_id, const rgw_bucket_shard& bs);
  void read_clear_modified(map<int, set<string> > &modified);

  void set_observer(rgw::BucketChangeObserver *observer) {
    this->observer = observer;
  }

  bool going_down();
};
# 40 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_putobj.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_putobj.h"
       



namespace rgw::putobj {


class DataProcessor {
 public:
  virtual ~DataProcessor() {}




  virtual int process(bufferlist&& data, uint64_t offset) = 0;
};


class Pipe : public DataProcessor {
  DataProcessor *next;
 public:
  explicit Pipe(DataProcessor *next) : next(next) {}


  int process(bufferlist&& data, uint64_t offset) override {
    return next->process(std::move(data), offset);
  }
};


class ChunkProcessor : public Pipe {
  uint64_t chunk_size;
  bufferlist chunk;
 public:
  ChunkProcessor(DataProcessor *next, uint64_t chunk_size)
    : Pipe(next), chunk_size(chunk_size)
  {}

  int process(bufferlist&& data, uint64_t offset) override;
};



class StripeGenerator {
 public:
  virtual ~StripeGenerator() {}

  virtual int next(uint64_t offset, uint64_t *stripe_size) = 0;
};


class StripeProcessor : public Pipe {
  StripeGenerator *gen;
  std::pair<uint64_t, uint64_t> bounds;
 public:
  StripeProcessor(DataProcessor *next, StripeGenerator *gen,
                  uint64_t first_stripe_size)
    : Pipe(next), gen(gen), bounds(0, first_stripe_size)
  {}

  int process(bufferlist&& data, uint64_t data_offset) override;
};

}
# 44 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h" 1
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_multi.h" 1
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_multi.h"
class RGWMultiCompleteUpload : public XMLObj
{
public:
  RGWMultiCompleteUpload() {}
  ~RGWMultiCompleteUpload() override {}
  bool xml_end(const char *el) override;

  std::map<int, string> parts;
};

class RGWMultiPart : public XMLObj
{
  string etag;
  int num;
public:
  RGWMultiPart() : num(0) {}
  ~RGWMultiPart() override {}
  bool xml_end(const char *el) override;

  string& get_etag() { return etag; }
  int get_num() { return num; }
};

class RGWMultiPartNumber : public XMLObj
{
public:
  RGWMultiPartNumber() {}
  ~RGWMultiPartNumber() override {}
};

class RGWMultiETag : public XMLObj
{
public:
  RGWMultiETag() {}
  ~RGWMultiETag() override {}
};

class RGWMultiXMLParser : public RGWXMLParser
{
  XMLObj *alloc_obj(const char *el) override;
public:
  RGWMultiXMLParser() {}
  ~RGWMultiXMLParser() override {}
};
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_multi.h"
class MultipartMetaFilter : public RGWAccessListFilter {
public:
  MultipartMetaFilter() {}
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_multi.h"
  bool filter(const string& name, string& key) override;
};

extern bool is_v2_upload_id(const string& upload_id);

extern int list_multipart_parts(RGWRados *store, RGWBucketInfo& bucket_info,
    CephContext *cct,
                                const string& upload_id,
                                const string& meta_oid, int num_parts,
                                int marker, map<uint32_t, RGWUploadPartInfo>& parts,
                                int *next_marker, bool *truncated,
                                bool assume_unsorted = false);

extern int list_multipart_parts(RGWRados *store, struct req_state *s,
                                const string& upload_id,
                                const string& meta_oid, int num_parts,
                                int marker, map<uint32_t, RGWUploadPartInfo>& parts,
                                int *next_marker, bool *truncated,
                                bool assume_unsorted = false);

extern int abort_multipart_upload(RGWRados *store, CephContext *cct, RGWObjectCtx *obj_ctx,
                                RGWBucketInfo& bucket_info, RGWMPObj& mp_obj);

extern int list_bucket_multiparts(RGWRados *store, RGWBucketInfo& bucket_info,
      const string& prefix,
      const string& marker,
      const string& delim,
      const int& max_uploads,
      vector<rgw_bucket_dir_entry> *objs,
      map<string, bool> *common_prefixes, bool *is_truncated);

extern int abort_bucket_multiparts(RGWRados *store, CephContext *cct, RGWBucketInfo& bucket_info,
                                string& prefix, string& delim);
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tag.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tag.h"
class RGWObjTags
{
 protected:
  using tag_map_t = boost::container::flat_map <std::string, std::string>;
  tag_map_t tag_map;
 public:
  RGWObjTags() {}
  ~RGWObjTags() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(tag_map, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(tag_map,bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  bool add_tag(const std::string& key, const std::string& val="");
  bool emplace_tag(std::string&& key, std::string&& val);
  int check_and_add_tag(const std::string& key, const std::string& val="");
  size_t count() const {return tag_map.size();}
  int set_from_string(const std::string& input);
  void clear() { tag_map.clear(); }
  bool empty() const noexcept { return tag_map.empty(); }
  const tag_map_t& get_tags() const {return tag_map;}
};
inline void encode(const RGWObjTags &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWObjTags &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h" 2





static string lc_oid_prefix = "lc";
static string lc_index_lock_name = "lc_process";

extern const char* LC_STATUS[];

typedef enum {
  lc_uninitial = 0,
  lc_processing,
  lc_failed,
  lc_complete,
} LC_BUCKET_STATUS;

class LCExpiration
{
protected:
  string days;

  string date;
public:
  LCExpiration() {}
  LCExpiration(const string& _days, const string& _date) : days(_days), date(_date) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(days, bl);
    encode(date, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (3 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "3" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(days, bl);
    if (struct_v >= 3) {
      decode(date, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;

  void set_days(const string& _days) { days = _days; }
  string get_days_str() const {
    return days;
  }
  int get_days() const {return atoi(days.c_str()); }
  bool has_days() const {
    return !days.empty();
  }
  void set_date(const string& _date) { date = _date; }
  string get_date() const {
    return date;
  }
  bool has_date() const {
    return !date.empty();
  }
  bool empty() const {
    return days.empty() && date.empty();
  }
  bool valid() const {
    if (!days.empty() && !date.empty()) {
      return false;
    } else if (!days.empty() && get_days() < 0) {
      return false;
    }

    return true;
  }
};
inline void encode(const LCExpiration &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(LCExpiration &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class LCTransition
{
protected:
  string days;
  string date;
  string storage_class;

public:
  int get_days() const {
    return atoi(days.c_str());
  }

  string get_date() const {
    return date;
  }

  string get_storage_class() const {
    return storage_class;
  }

  bool has_days() const {
    return !days.empty();
  }

  bool has_date() const {
    return !date.empty();
  }

  bool empty() const {
    return days.empty() && date.empty();
  }

  bool valid() const {
    if (!days.empty() && !date.empty()) {
      return false;
    } else if (!days.empty() && get_days() <=0) {
      return false;
    }

    return true;
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(days, bl);
    encode(date, bl);
    encode(storage_class, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(days, bl);
    decode(date, bl);
    decode(storage_class, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
};
inline void encode(const LCTransition &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(LCTransition &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class LCFilter
{
 protected:
  std::string prefix;
  RGWObjTags obj_tags;

 public:

  const std::string& get_prefix() const {
    return prefix;
  }

  const RGWObjTags& get_tags() const {
    return obj_tags;
  }

  bool empty() const {
    return !(has_prefix() || has_tags());
  }


  bool has_multi_condition() const {
    if (obj_tags.count() > 1)
      return true;
    else if (has_prefix() && has_tags())
      return true;

    return false;
  }

  bool has_prefix() const {
    return !prefix.empty();
  }

  bool has_tags() const {
    return !obj_tags.empty();
  }

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(prefix, bl);
    encode(obj_tags, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(prefix, bl);
    if (struct_v >= 2) {
      decode(obj_tags, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
};
inline void encode(const LCFilter &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(LCFilter &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }



class LCRule
{
protected:
  string id;
  string prefix;
  string status;
  LCExpiration expiration;
  LCExpiration noncur_expiration;
  LCExpiration mp_expiration;
  LCFilter filter;
  map<string, LCTransition> transitions;
  map<string, LCTransition> noncur_transitions;
  bool dm_expiration = false;

public:

  LCRule(){};
  ~LCRule(){};

  const string& get_id() const {
      return id;
  }

  const string& get_status() const {
      return status;
  }

  bool is_enabled() const {
    return status == "Enabled";
  }

  void set_enabled(bool flag) {
    status = (flag ? "Enabled" : "Disabled");
  }

  const string& get_prefix() const {
      return prefix;
  }

  const LCFilter& get_filter() const {
    return filter;
  }

  const LCExpiration& get_expiration() const {
    return expiration;
  }

  const LCExpiration& get_noncur_expiration() const {
    return noncur_expiration;
  }

  const LCExpiration& get_mp_expiration() const {
    return mp_expiration;
  }

  bool get_dm_expiration() const {
    return dm_expiration;
  }

  const map<string, LCTransition>& get_transitions() const {
    return transitions;
  }

  const map<string, LCTransition>& get_noncur_transitions() const {
    return noncur_transitions;
  }

  void set_id(const string& _id) {
    id = _id;
  }

  void set_prefix(const string& _prefix) {
    prefix = _prefix;
  }

  void set_status(const string& _status) {
    status = _status;
  }

  void set_expiration(const LCExpiration& _expiration) {
    expiration = _expiration;
  }

  void set_noncur_expiration(const LCExpiration& _noncur_expiration) {
    noncur_expiration = _noncur_expiration;
  }

  void set_mp_expiration(const LCExpiration& _mp_expiration) {
    mp_expiration = _mp_expiration;
  }

  void set_dm_expiration(bool _dm_expiration) {
    dm_expiration = _dm_expiration;
  }

  bool add_transition(const LCTransition& _transition) {
    auto ret = transitions.emplace(_transition.get_storage_class(), _transition);
    return ret.second;
  }

  bool add_noncur_transition(const LCTransition& _noncur_transition) {
    auto ret = noncur_transitions.emplace(_noncur_transition.get_storage_class(), _noncur_transition);
    return ret.second;
  }

  bool valid() const;

  void encode(bufferlist& bl) const {
     __u8 struct_v = 6; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
     encode(id, bl);
     encode(prefix, bl);
     encode(status, bl);
     encode(expiration, bl);
     encode(noncur_expiration, bl);
     encode(mp_expiration, bl);
     encode(dm_expiration, bl);
     encode(filter, bl);
     encode(transitions, bl);
     encode(noncur_transitions, bl);
     } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
   }
   void decode(bufferlist::const_iterator& bl) {
     using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (6 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "6" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
     decode(id, bl);
     decode(prefix, bl);
     decode(status, bl);
     decode(expiration, bl);
     if (struct_v >=2) {
       decode(noncur_expiration, bl);
     }
     if (struct_v >= 3) {
       decode(mp_expiration, bl);
     }
     if (struct_v >= 4) {
        decode(dm_expiration, bl);
     }
     if (struct_v >= 5) {
       decode(filter, bl);
     }
     if (struct_v >= 6) {
       decode(transitions, bl);
       decode(noncur_transitions, bl);
     }
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
   }
  void dump(Formatter *f) const;

  void init_simple_days_rule(std::string_view _id, std::string_view _prefix, int num_days);
};
inline void encode(const LCRule &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(LCRule &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct transition_action
{
  int days;
  boost::optional<ceph::real_time> date;
  string storage_class;
  transition_action() : days(0) {}
};


struct lc_op
{
  string id;
  bool status{false};
  bool dm_expiration{false};
  int expiration{0};
  int noncur_expiration{0};
  int mp_expiration{0};
  boost::optional<ceph::real_time> expiration_date;
  boost::optional<RGWObjTags> obj_tags;
  map<string, transition_action> transitions;
  map<string, transition_action> noncur_transitions;


  lc_op() = delete;

  lc_op(const std::string id) : id(id)
    {}

  void dump(Formatter *f) const;
};

class RGWLifecycleConfiguration
{
protected:
  CephContext *cct;
  multimap<string, lc_op> prefix_map;
  multimap<string, LCRule> rule_map;
  bool _add_rule(const LCRule& rule);
  bool has_same_action(const lc_op& first, const lc_op& second);
public:
  explicit RGWLifecycleConfiguration(CephContext *_cct) : cct(_cct) {}
  RGWLifecycleConfiguration() : cct(
# 408 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h" 3 4
                                   __null
# 408 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h"
                                       ) {}

  void set_ctx(CephContext *ctx) {
    cct = ctx;
  }

  virtual ~RGWLifecycleConfiguration() {}



  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(rule_map, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator& bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(rule_map, bl);
    multimap<string, LCRule>::iterator iter;
    for (iter = rule_map.begin(); iter != rule_map.end(); ++iter) {
      LCRule& rule = iter->second;
      _add_rule(rule);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<RGWLifecycleConfiguration*>& o);

  void add_rule(const LCRule& rule);

  int check_and_add_rule(const LCRule& rule);

  bool valid();

  multimap<string, LCRule>& get_rule_map() { return rule_map; }
  multimap<string, lc_op>& get_prefix_map() { return prefix_map; }







};
inline void encode(const RGWLifecycleConfiguration &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWLifecycleConfiguration &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWLC : public DoutPrefixProvider {
  CephContext *cct;
  RGWRados *store;
  int max_objs{0};
  string *obj_names{nullptr};
  std::atomic<bool> down_flag = { false };
  string cookie;

  class LCWorker : public Thread {
    const DoutPrefixProvider *dpp;
    CephContext *cct;
    RGWLC *lc;
    Mutex lock;
    Cond cond;

  public:
    LCWorker(const DoutPrefixProvider* _dpp, CephContext *_cct, RGWLC *_lc) : dpp(_dpp), cct(_cct), lc(_lc), lock("LCWorker") {}
    void *entry() override;
    void stop();
    bool should_work(utime_t& now);
    int schedule_next_start_time(utime_t& start, utime_t& now);
  };

  public:
  LCWorker *worker;
  RGWLC() : cct(
# 479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h" 3 4
               __null
# 479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h"
                   ), store(
# 479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h" 3 4
                            __null
# 479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h"
                                ), worker(
# 479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h" 3 4
                                          __null
# 479 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc.h"
                                              ) {}
  ~RGWLC() {
    stop_processor();
    finalize();
  }

  void initialize(CephContext *_cct, RGWRados *_store);
  void finalize();

  int process();
  int process(int index, int max_secs);
  bool if_already_run_today(time_t& start_date);
  int list_lc_progress(const string& marker, uint32_t max_entries, map<string, int> *progress_map);
  int bucket_lc_prepare(int index);
  int bucket_lc_process(string& shard_id);
  int bucket_lc_post(int index, int max_lock_sec, pair<string, int >& entry, int& result);
  bool going_down();
  void start_processor();
  void stop_processor();
  int set_bucket_config(RGWBucketInfo& bucket_info,
                        const map<string, bufferlist>& bucket_attrs,
                        RGWLifecycleConfiguration *config);
  int remove_bucket_config(RGWBucketInfo& bucket_info,
                           const map<string, bufferlist>& bucket_attrs);

  CephContext *get_cct() const override { return store->ctx(); }
  unsigned get_subsys() const;
  std::ostream& gen_prefix(std::ostream& out) const;

  private:

  int handle_multipart_expiration(RGWRados::Bucket *target,
      const multimap<string, lc_op>& prefix_map);
};

namespace rgw::lc {

int fix_lc_shard_entry(RGWRados *store, const RGWBucketInfo& bucket_info,
         const map<std::string,bufferlist>& battrs);

}
# 46 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_torrent.h" 1
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_torrent.h"
using ceph::crypto::SHA1;

struct req_state;
# 36 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_torrent.h"
class TorrentBencode
{
public:
  TorrentBencode() {}
  ~TorrentBencode() {}


  void bencode_dict(bufferlist& bl) { bl.append('d'); }
  void bencode_list(bufferlist& bl) { bl.append('l'); }
  void bencode_end(bufferlist& bl) { bl.append('e'); }


  void bencode(int value, bufferlist& bl)
  {
    bl.append('i');
    char info[100] = { 0 };
    sprintf(info, "%d", value);
    bl.append(info, strlen(info));
    bencode_end(bl);
  }


  void bencode(const std::string& str, bufferlist& bl)
  {
    bencode_key(str, bl);
  }


  void bencode(const std::string& key, int value, bufferlist& bl)
  {
    bencode_key(key, bl);
    bencode(value, bl);
  }


  void bencode(const std::string& key, const std::string& value, bufferlist& bl)
  {
    bencode_key(key, bl);
    bencode(value, bl);
  }


  void bencode_key(const std::string& key, bufferlist& bl)
  {
    int len = key.length();
    char info[100] = { 0 };
    sprintf(info, "%d:", len);
    bl.append(info, strlen(info));
    bl.append(key.c_str(), len);
  }
};


class seed
{
private:
  struct
  {
    int piece_length;
    bufferlist sha1_bl;
    string name;
    off_t len;
  }info;

  string announce;
  string origin;
  time_t create_date{0};
  string comment;
  string create_by;
  string encoding;
  uint64_t sha_len;
  bool is_torrent;
  bufferlist bl;

  struct req_state *s{nullptr};
  RGWRados *store{nullptr};
  SHA1 h;

  TorrentBencode dencode;
public:
  seed();
  ~seed();

  int get_params();
  void init(struct req_state *p_req, RGWRados *p_store);
  int get_torrent_file(RGWRados::Object::Read &read_op,
                       uint64_t &total_len,
                       ceph::bufferlist &bl_data,
                       rgw_obj &obj);

  off_t get_data_len();
  bool get_flag();

  void set_create_date(ceph::real_time& value);
  void set_info_name(const string& value);
  void update(bufferlist &bl);
  int complete();

private:
  void do_encode ();
  void set_announce();
  void set_exist(bool exist);
  void set_info_pieces(char *buff);
  void sha1(SHA1 *h, bufferlist &bl, off_t bl_len);
  int save_torrent_file();
};
# 47 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/lock/cls_lock_client.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/lock/cls_lock_client.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/rados/librados_fwd.hpp" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/lock/cls_lock_client.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/lock/cls_lock_types.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/lock/cls_lock_types.h"
enum ClsLockType {
  LOCK_NONE = 0,
  LOCK_EXCLUSIVE = 1,
  LOCK_SHARED = 2,
  LOCK_EXCLUSIVE_EPHEMERAL = 3,
};

inline const char *cls_lock_type_str(ClsLockType type)
{
    switch (type) {
      case LOCK_NONE:
 return "none";
      case LOCK_EXCLUSIVE:
 return "exclusive";
      case LOCK_SHARED:
 return "shared";
      case LOCK_EXCLUSIVE_EPHEMERAL:
 return "exclusive-ephemeral";
      default:
 return "<unknown>";
    }
}

inline bool cls_lock_is_exclusive(ClsLockType type) {
  return LOCK_EXCLUSIVE == type || LOCK_EXCLUSIVE_EPHEMERAL == type;
}

inline bool cls_lock_is_ephemeral(ClsLockType type) {
  return LOCK_EXCLUSIVE_EPHEMERAL == type;
}

inline bool cls_lock_is_valid(ClsLockType type) {
  return LOCK_SHARED == type ||
    LOCK_EXCLUSIVE == type ||
    LOCK_EXCLUSIVE_EPHEMERAL == type;
}

namespace rados {
  namespace cls {
    namespace lock {




      struct locker_id_t {
        entity_name_t locker;
        string cookie;

        locker_id_t() {}
        locker_id_t(entity_name_t& _n, const string& _c) : locker(_n), cookie(_c) {}

        void encode(bufferlist &bl) const {
          __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
          encode(locker, bl);
          encode(cookie, bl);
          } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
        }
        void decode(bufferlist::const_iterator &bl) {
          using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
          decode(locker, bl);
          decode(cookie, bl);
          } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
        }

        bool operator<(const locker_id_t& rhs) const {
          if (locker == rhs.locker)
            return cookie.compare(rhs.cookie) < 0;
          if (locker < rhs.locker)
            return true;
          return false;
        }
        void dump(Formatter *f) const;
 friend std::ostream& operator<<(std::ostream& out,
     const locker_id_t& data) {
   out << data.locker;
   return out;
 }
        static void generate_test_instances(list<locker_id_t*>& o);
      };
      inline void encode(const locker_id_t &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(locker_id_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

      struct locker_info_t
      {
        utime_t expiration;
        entity_addr_t addr;
        string description;

        locker_info_t() {}
        locker_info_t(const utime_t& _e, const entity_addr_t& _a,
                      const string& _d) : expiration(_e), addr(_a), description(_d) {}

        void encode(bufferlist &bl, uint64_t features) const {
          __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
          encode(expiration, bl);
          encode(addr, bl, features);
          encode(description, bl);
          } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
        }
        void decode(bufferlist::const_iterator &bl) {
          using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
          decode(expiration, bl);
          decode(addr, bl);
          decode(description, bl);
          } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
        }
        void dump(Formatter *f) const;
 friend std::ostream& operator<<(std::ostream& out,
     const locker_info_t& data) {
   out << "{addr:" << data.addr << ", exp:";

   const auto& exp = data.expiration;
   if (exp.is_zero()) {
     out << "never}";
   } else {
     out << exp.to_real_time() << "}";
   }

   return out;
 }
        static void generate_test_instances(list<locker_info_t *>& o);
      };
      inline void encode(const locker_info_t &c, ::ceph::bufferlist &bl, uint64_t features) { ; c.encode(bl, features); ; } inline void decode(locker_info_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

      struct lock_info_t {
        map<locker_id_t, locker_info_t> lockers;
        ClsLockType lock_type;
        string tag;



        void encode(bufferlist &bl, uint64_t features) const {
          __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
          encode(lockers, bl, features);
          uint8_t t = (uint8_t)lock_type;
          encode(t, bl);
          encode(tag, bl);
          } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
        }
        void decode(bufferlist::const_iterator &bl) {
          using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 1) { __u8 struct_compat; decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 1) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
          decode(lockers, bl);
          uint8_t t;
          decode(t, bl);
          lock_type = (ClsLockType)t;
          decode(tag, bl);
          } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
        }
        lock_info_t() : lock_type(LOCK_NONE) {}
        void dump(Formatter *f) const;
        static void generate_test_instances(list<lock_info_t *>& o);
      };
      inline void encode(const lock_info_t &c, ::ceph::bufferlist &bl, uint64_t features) { ; c.encode(bl, features); ; } inline void decode(lock_info_t &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); };
    }
  }
}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/lock/cls_lock_client.h" 2

namespace rados {
  namespace cls {
    namespace lock {
      extern void lock(librados::ObjectWriteOperation *rados_op,
         const std::string& name, ClsLockType type,
         const std::string& cookie, const std::string& tag,
         const std::string& description, const utime_t& duration,
         uint8_t flags);

      extern int lock(librados::IoCtx *ioctx,
        const std::string& oid,
        const std::string& name, ClsLockType type,
        const std::string& cookie, const std::string& tag,
        const std::string& description, const utime_t& duration,
        uint8_t flags);

      extern void unlock(librados::ObjectWriteOperation *rados_op,
    const std::string& name, const std::string& cookie);

      extern int unlock(librados::IoCtx *ioctx, const std::string& oid,
   const std::string& name, const std::string& cookie);

      extern int aio_unlock(librados::IoCtx *ioctx, const std::string& oid,
       const std::string& name, const std::string& cookie,
       librados::AioCompletion *completion);

      extern void break_lock(librados::ObjectWriteOperation *op,
        const std::string& name, const std::string& cookie,
        const entity_name_t& locker);

      extern int break_lock(librados::IoCtx *ioctx, const std::string& oid,
       const std::string& name, const std::string& cookie,
       const entity_name_t& locker);

      extern int list_locks(librados::IoCtx *ioctx, const std::string& oid,
       list<std::string> *locks);
      extern void get_lock_info_start(librados::ObjectReadOperation *rados_op,
          const std::string& name);
      extern int get_lock_info_finish(ceph::bufferlist::const_iterator *out,
          map<locker_id_t, locker_info_t> *lockers,
          ClsLockType *type, std::string *tag);

      extern int get_lock_info(librados::IoCtx *ioctx, const std::string& oid,
          const std::string& name,
          map<locker_id_t, locker_info_t> *lockers,
          ClsLockType *type, std::string *tag);

      extern void assert_locked(librados::ObjectOperation *rados_op,
                                const std::string& name, ClsLockType type,
                                const std::string& cookie,
                                const std::string& tag);

      extern void set_cookie(librados::ObjectWriteOperation *rados_op,
                             const std::string& name, ClsLockType type,
                             const std::string& cookie, const std::string& tag,
                             const std::string& new_cookie);

      class Lock {
 std::string name;
 std::string cookie;
 std::string tag;
 std::string description;
 utime_t duration;
 uint8_t flags;

      public:

 Lock(const std::string& _n) : name(_n), flags(0) {}

 void set_cookie(const std::string& c) { cookie = c; }
 void set_tag(const std::string& t) { tag = t; }
 void set_description(const std::string& desc) { description = desc; }
 void set_duration(const utime_t& e) { duration = e; }
 void set_duration(const ceph::timespan& d) {
   duration = utime_t(ceph::real_clock::zero() + d);
 }

 void set_may_renew(bool renew) {
   if (renew) {
     flags |= 0x1;
     flags &= ~0x2;
   } else {
     flags &= ~0x1;
   }
 }

 void set_must_renew(bool renew) {
   if (renew) {
     flags |= 0x2;
     flags &= ~0x1;
   } else {
     flags &= ~0x2;
   }
 }

        void assert_locked_shared(librados::ObjectOperation *rados_op);
        void assert_locked_exclusive(librados::ObjectOperation *rados_op);
        void assert_locked_exclusive_ephemeral(librados::ObjectOperation *rados_op);


 void lock_shared(librados::ObjectWriteOperation *ioctx);
 void lock_exclusive(librados::ObjectWriteOperation *ioctx);






 void lock_exclusive_ephemeral(librados::ObjectWriteOperation *ioctx);
 void unlock(librados::ObjectWriteOperation *ioctx);
 void break_lock(librados::ObjectWriteOperation *ioctx,
   const entity_name_t& locker);


 int lock_shared(librados::IoCtx *ioctx, const std::string& oid);
 int lock_exclusive(librados::IoCtx *ioctx, const std::string& oid);


 int lock_exclusive_ephemeral(librados::IoCtx *ioctx,
         const std::string& oid);
 int unlock(librados::IoCtx *ioctx, const std::string& oid);
 int break_lock(librados::IoCtx *ioctx, const std::string& oid,
         const entity_name_t& locker);
      };

    }
  }
}
# 50 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_ops.h" 1





struct rgw_cls_tag_timeout_op
{
  uint64_t tag_timeout;

  rgw_cls_tag_timeout_op() : tag_timeout(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(tag_timeout, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(tag_timeout, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_cls_tag_timeout_op*>& ls);
};
inline void encode(const rgw_cls_tag_timeout_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_tag_timeout_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_obj_prepare_op
{
  RGWModifyOp op;
  cls_rgw_obj_key key;
  string tag;
  string locator;
  bool log_op;
  uint16_t bilog_flags;
  rgw_zone_set zones_trace;

  rgw_cls_obj_prepare_op() : op(CLS_RGW_OP_UNKNOWN), log_op(false), bilog_flags(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 7; __u8 struct_compat = 5; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    uint8_t c = (uint8_t)op;
    encode(c, bl);
    encode(tag, bl);
    encode(locator, bl);
    encode(log_op, bl);
    encode(key, bl);
    encode(bilog_flags, bl);
    encode(zones_trace, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (7 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "7" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    uint8_t c;
    decode(c, bl);
    op = (RGWModifyOp)c;
    if (struct_v < 5) {
      decode(key.name, bl);
    }
    decode(tag, bl);
    if (struct_v >= 2) {
      decode(locator, bl);
    }
    if (struct_v >= 4) {
      decode(log_op, bl);
    }
    if (struct_v >= 5) {
      decode(key, bl);
    }
    if (struct_v >= 6) {
      decode(bilog_flags, bl);
    }
    if (struct_v >= 7) {
      decode(zones_trace, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_cls_obj_prepare_op*>& o);
};
inline void encode(const rgw_cls_obj_prepare_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_obj_prepare_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_obj_complete_op
{
  RGWModifyOp op;
  cls_rgw_obj_key key;
  string locator;
  rgw_bucket_entry_ver ver;
  rgw_bucket_dir_entry_meta meta;
  string tag;
  bool log_op;
  uint16_t bilog_flags;

  list<cls_rgw_obj_key> remove_objs;
  rgw_zone_set zones_trace;

  rgw_cls_obj_complete_op() : op(CLS_RGW_OP_ADD), log_op(false), bilog_flags(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 9; __u8 struct_compat = 7; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    uint8_t c = (uint8_t)op;
    encode(c, bl);
    encode(ver.epoch, bl);
    encode(meta, bl);
    encode(tag, bl);
    encode(locator, bl);
    encode(remove_objs, bl);
    encode(ver, bl);
    encode(log_op, bl);
    encode(key, bl);
    encode(bilog_flags, bl);
    encode(zones_trace, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
 }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 3) { __u8 struct_compat; decode(struct_compat, bl); if (9 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "9" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 3) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    uint8_t c;
    decode(c, bl);
    op = (RGWModifyOp)c;
    if (struct_v < 7) {
      decode(key.name, bl);
    }
    decode(ver.epoch, bl);
    decode(meta, bl);
    decode(tag, bl);
    if (struct_v >= 2) {
      decode(locator, bl);
    }
    if (struct_v >= 4 && struct_v < 7) {
      list<string> old_remove_objs;
      decode(old_remove_objs, bl);

      for (list<string>::iterator iter = old_remove_objs.begin();
           iter != old_remove_objs.end(); ++iter) {
        cls_rgw_obj_key k;
        k.name = *iter;
        remove_objs.push_back(k);
      }
    } else {
      decode(remove_objs, bl);
    }
    if (struct_v >= 5) {
      decode(ver, bl);
    } else {
      ver.pool = -1;
    }
    if (struct_v >= 6) {
      decode(log_op, bl);
    }
    if (struct_v >= 7) {
      decode(key, bl);
    }
    if (struct_v >= 8) {
      decode(bilog_flags, bl);
    }
    if (struct_v >= 9) {
      decode(zones_trace, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_cls_obj_complete_op*>& o);
};
inline void encode(const rgw_cls_obj_complete_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_obj_complete_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_link_olh_op {
  cls_rgw_obj_key key;
  string olh_tag;
  bool delete_marker;
  string op_tag;
  rgw_bucket_dir_entry_meta meta;
  uint64_t olh_epoch;
  bool log_op;
  uint16_t bilog_flags;
  real_time unmod_since;
  bool high_precision_time;
  rgw_zone_set zones_trace;

  rgw_cls_link_olh_op() : delete_marker(false), olh_epoch(0), log_op(false), bilog_flags(0), high_precision_time(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 5; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key, bl);
    encode(olh_tag, bl);
    encode(delete_marker, bl);
    encode(op_tag, bl);
    encode(meta, bl);
    encode(olh_epoch, bl);
    encode(log_op, bl);
    encode(bilog_flags, bl);
    uint64_t t = ceph::real_clock::to_time_t(unmod_since);
    encode(t, bl);
    encode(unmod_since, bl);
    encode(high_precision_time, bl);
    encode(zones_trace, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (5 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "5" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(key, bl);
    decode(olh_tag, bl);
    decode(delete_marker, bl);
    decode(op_tag, bl);
    decode(meta, bl);
    decode(olh_epoch, bl);
    decode(log_op, bl);
    decode(bilog_flags, bl);
    if (struct_v == 2) {
      uint64_t t;
      decode(t, bl);
      unmod_since = ceph::real_clock::from_time_t(static_cast<time_t>(t));
    }
    if (struct_v >= 3) {
      uint64_t t;
      decode(t, bl);
      decode(unmod_since, bl);
    }
    if (struct_v >= 4) {
      decode(high_precision_time, bl);
    }
    if (struct_v >= 5) {
      decode(zones_trace, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  static void generate_test_instances(list<rgw_cls_link_olh_op *>& o);
  void dump(Formatter *f) const;
};
inline void encode(const rgw_cls_link_olh_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_link_olh_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_unlink_instance_op {
  cls_rgw_obj_key key;
  string op_tag;
  uint64_t olh_epoch;
  bool log_op;
  uint16_t bilog_flags;
  string olh_tag;
  rgw_zone_set zones_trace;

  rgw_cls_unlink_instance_op() : olh_epoch(0), log_op(false), bilog_flags(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key, bl);
    encode(op_tag, bl);
    encode(olh_epoch, bl);
    encode(log_op, bl);
    encode(bilog_flags, bl);
    encode(olh_tag, bl);
    encode(zones_trace, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (3 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "3" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(key, bl);
    decode(op_tag, bl);
    decode(olh_epoch, bl);
    decode(log_op, bl);
    decode(bilog_flags, bl);
    if (struct_v >= 2) {
      decode(olh_tag, bl);
    }
    if (struct_v >= 3) {
      decode(zones_trace, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  static void generate_test_instances(list<rgw_cls_unlink_instance_op *>& o);
  void dump(Formatter *f) const;
};
inline void encode(const rgw_cls_unlink_instance_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_unlink_instance_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_read_olh_log_op
{
  cls_rgw_obj_key olh;
  uint64_t ver_marker;
  string olh_tag;

  rgw_cls_read_olh_log_op() : ver_marker(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(olh, bl);
    encode(ver_marker, bl);
    encode(olh_tag, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(olh, bl);
    decode(ver_marker, bl);
    decode(olh_tag, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<rgw_cls_read_olh_log_op *>& o);
  void dump(Formatter *f) const;
};
inline void encode(const rgw_cls_read_olh_log_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_read_olh_log_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }


struct rgw_cls_read_olh_log_ret
{
  map<uint64_t, vector<rgw_bucket_olh_log_entry> > log;
  bool is_truncated;

  rgw_cls_read_olh_log_ret() : is_truncated(false) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(log, bl);
    encode(is_truncated, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(log, bl);
    decode(is_truncated, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<rgw_cls_read_olh_log_ret *>& o);
  void dump(Formatter *f) const;
};
inline void encode(const rgw_cls_read_olh_log_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_read_olh_log_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_trim_olh_log_op
{
  cls_rgw_obj_key olh;
  uint64_t ver;
  string olh_tag;

  rgw_cls_trim_olh_log_op() : ver(0) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(olh, bl);
    encode(ver, bl);
    encode(olh_tag, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(olh, bl);
    decode(ver, bl);
    decode(olh_tag, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<rgw_cls_trim_olh_log_op *>& o);
  void dump(Formatter *f) const;
};
inline void encode(const rgw_cls_trim_olh_log_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_trim_olh_log_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_bucket_clear_olh_op {
  cls_rgw_obj_key key;
  string olh_tag;

  rgw_cls_bucket_clear_olh_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key, bl);
    encode(olh_tag, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(key, bl);
    decode(olh_tag, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  static void generate_test_instances(list<rgw_cls_bucket_clear_olh_op *>& o);
  void dump(Formatter *f) const;
};
inline void encode(const rgw_cls_bucket_clear_olh_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bucket_clear_olh_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_list_op
{
  cls_rgw_obj_key start_obj;
  uint32_t num_entries;
  string filter_prefix;
  bool list_versions;

  rgw_cls_list_op() : num_entries(0), list_versions(false) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 5; __u8 struct_compat = 4; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(num_entries, bl);
    encode(filter_prefix, bl);
    encode(start_obj, bl);
    encode(list_versions, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (5 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "5" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    if (struct_v < 4) {
      decode(start_obj.name, bl);
    }
    decode(num_entries, bl);
    if (struct_v >= 3)
      decode(filter_prefix, bl);
    if (struct_v >= 4)
      decode(start_obj, bl);
    if (struct_v >= 5)
      decode(list_versions, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_cls_list_op*>& o);
};
inline void encode(const rgw_cls_list_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_list_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_list_ret {
  rgw_bucket_dir dir;
  bool is_truncated;

  rgw_cls_list_ret() : is_truncated(false) {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(dir, bl);
    encode(is_truncated, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    using ::ceph::decode; __u8 struct_v; decode(struct_v, bl); if (struct_v >= 2) { __u8 struct_compat; decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); } unsigned struct_end = 0; if (struct_v >= 2) { __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); struct_end = bl.get_off() + struct_len; } do {;
    decode(dir, bl);
    decode(is_truncated, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_cls_list_ret*>& o);
};
inline void encode(const rgw_cls_list_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_list_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_check_index_ret
{
  rgw_bucket_dir_header existing_header;
  rgw_bucket_dir_header calculated_header;

  rgw_cls_check_index_ret() {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(existing_header, bl);
    encode(calculated_header, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(existing_header, bl);
    decode(calculated_header, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_cls_check_index_ret *>& o);
};
inline void encode(const rgw_cls_check_index_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_check_index_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_bucket_update_stats_op
{
  bool absolute{false};
  map<RGWObjCategory, rgw_bucket_category_stats> stats;

  rgw_cls_bucket_update_stats_op() {}

  void encode(bufferlist &bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(absolute, bl);
    encode(stats, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }
  void decode(bufferlist::const_iterator &bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(absolute, bl);
    decode(stats, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  void dump(Formatter *f) const;
  static void generate_test_instances(list<rgw_cls_bucket_update_stats_op *>& o);
};
inline void encode(const rgw_cls_bucket_update_stats_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bucket_update_stats_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_obj_remove_op {
  list<string> keep_attr_prefixes;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(keep_attr_prefixes, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(keep_attr_prefixes, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_obj_remove_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_obj_remove_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_obj_store_pg_ver_op {
  string attr;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(attr, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(attr, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_obj_store_pg_ver_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_obj_store_pg_ver_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_obj_check_attrs_prefix {
  string check_prefix;
  bool fail_if_exist;

  rgw_cls_obj_check_attrs_prefix() : fail_if_exist(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(check_prefix, bl);
    encode(fail_if_exist, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(check_prefix, bl);
    decode(fail_if_exist, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_obj_check_attrs_prefix &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_obj_check_attrs_prefix &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_obj_check_mtime {
  ceph::real_time mtime;
  RGWCheckMTimeType type;
  bool high_precision_time;

  rgw_cls_obj_check_mtime() : type(CLS_RGW_CHECK_TIME_MTIME_EQ), high_precision_time(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(mtime, bl);
    encode((uint8_t)type, bl);
    encode(high_precision_time, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(mtime, bl);
    uint8_t c;
    decode(c, bl);
    type = (RGWCheckMTimeType)c;
    if (struct_v >= 2) {
      decode(high_precision_time, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_obj_check_mtime &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_obj_check_mtime &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_usage_log_add_op {
  rgw_usage_log_info info;
  rgw_user user;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(info, bl);
    encode(user.to_str(), bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(info, bl);
    if (struct_v >= 2) {
      string s;
      decode(s, bl);
      user.from_str(s);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_usage_log_add_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_usage_log_add_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_bi_get_op {
  cls_rgw_obj_key key;
  BIIndexType type;

  rgw_cls_bi_get_op() : type(BIIndexType::Plain) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(key, bl);
    encode((uint8_t)type, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(key, bl);
    uint8_t c;
    decode(c, bl);
    type = (BIIndexType)c;
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_bi_get_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bi_get_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_bi_get_ret {
  rgw_cls_bi_entry entry;

  rgw_cls_bi_get_ret() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_bi_get_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bi_get_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_bi_put_op {
  rgw_cls_bi_entry entry;

  rgw_cls_bi_put_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_bi_put_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bi_put_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_bi_list_op {
  uint32_t max;
  string name;
  string marker;

  rgw_cls_bi_list_op() : max(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(max, bl);
    encode(name, bl);
    encode(marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(max, bl);
    decode(name, bl);
    decode(marker, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_bi_list_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bi_list_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_bi_list_ret {
  list<rgw_cls_bi_entry> entries;
  bool is_truncated;

  rgw_cls_bi_list_ret() : is_truncated(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entries, bl);
    encode(is_truncated, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entries, bl);
    decode(is_truncated, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_bi_list_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_bi_list_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_usage_log_read_op {
  uint64_t start_epoch;
  uint64_t end_epoch;
  string owner;
  string bucket;

  string iter;
  uint32_t max_entries;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(start_epoch, bl);
    encode(end_epoch, bl);
    encode(owner, bl);
    encode(iter, bl);
    encode(max_entries, bl);
    encode(bucket, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(start_epoch, bl);
    decode(end_epoch, bl);
    decode(owner, bl);
    decode(iter, bl);
    decode(max_entries, bl);
    if (struct_v >= 2) {
      decode(bucket, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_usage_log_read_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_usage_log_read_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_usage_log_read_ret {
  map<rgw_user_bucket, rgw_usage_log_entry> usage;
  bool truncated;
  string next_iter;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(usage, bl);
    encode(truncated, bl);
    encode(next_iter, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(usage, bl);
    decode(truncated, bl);
    decode(next_iter, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_usage_log_read_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_usage_log_read_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct rgw_cls_usage_log_trim_op {
  uint64_t start_epoch;
  uint64_t end_epoch;
  string user;
  string bucket;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 2; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(start_epoch, bl);
    encode(end_epoch, bl);
    encode(user, bl);
    encode(bucket, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (3 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "3" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(start_epoch, bl);
    decode(end_epoch, bl);
    decode(user, bl);
    if (struct_v >= 3) {
      decode(bucket, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const rgw_cls_usage_log_trim_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_cls_usage_log_trim_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_gc_set_entry_op {
  uint32_t expiration_secs;
  cls_rgw_gc_obj_info info;
  cls_rgw_gc_set_entry_op() : expiration_secs(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(expiration_secs, bl);
    encode(info, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(expiration_secs, bl);
    decode(info, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_gc_set_entry_op*>& ls);
};
inline void encode(const cls_rgw_gc_set_entry_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_gc_set_entry_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_gc_defer_entry_op {
  uint32_t expiration_secs;
  string tag;
  cls_rgw_gc_defer_entry_op() : expiration_secs(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(expiration_secs, bl);
    encode(tag, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(expiration_secs, bl);
    decode(tag, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_gc_defer_entry_op*>& ls);
};
inline void encode(const cls_rgw_gc_defer_entry_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_gc_defer_entry_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_gc_list_op {
  string marker;
  uint32_t max;
  bool expired_only;

  cls_rgw_gc_list_op() : max(0), expired_only(true) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(marker, bl);
    encode(max, bl);
    encode(expired_only, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(marker, bl);
    decode(max, bl);
    if (struct_v >= 2) {
      decode(expired_only, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_gc_list_op*>& ls);
};
inline void encode(const cls_rgw_gc_list_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_gc_list_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_gc_list_ret {
  list<cls_rgw_gc_obj_info> entries;
  string next_marker;
  bool truncated;

  cls_rgw_gc_list_ret() : truncated(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entries, bl);
    encode(next_marker, bl);
    encode(truncated, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entries, bl);
    if (struct_v >= 2)
      decode(next_marker, bl);
    decode(truncated, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_gc_list_ret*>& ls);
};
inline void encode(const cls_rgw_gc_list_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_gc_list_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_gc_remove_op {
  vector<string> tags;

  cls_rgw_gc_remove_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(tags, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(tags, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_gc_remove_op*>& ls);
};
inline void encode(const cls_rgw_gc_remove_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_gc_remove_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_bi_log_list_op {
  string marker;
  uint32_t max;

  cls_rgw_bi_log_list_op() : max(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(marker, bl);
    encode(max, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(marker, bl);
    decode(max, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_bi_log_list_op*>& ls);
};
inline void encode(const cls_rgw_bi_log_list_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_bi_log_list_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_bi_log_trim_op {
  string start_marker;
  string end_marker;

  cls_rgw_bi_log_trim_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(start_marker, bl);
    encode(end_marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(start_marker, bl);
    decode(end_marker, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_bi_log_trim_op*>& ls);
};
inline void encode(const cls_rgw_bi_log_trim_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_bi_log_trim_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_bi_log_list_ret {
  list<rgw_bi_log_entry> entries;
  bool truncated;

  cls_rgw_bi_log_list_ret() : truncated(false) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entries, bl);
    encode(truncated, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entries, bl);
    decode(truncated, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void dump(Formatter *f) const;
  static void generate_test_instances(list<cls_rgw_bi_log_list_ret*>& ls);
};
inline void encode(const cls_rgw_bi_log_list_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_bi_log_list_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_get_next_entry_op {
  string marker;
  cls_rgw_lc_get_next_entry_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(marker, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const cls_rgw_lc_get_next_entry_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_get_next_entry_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

using rgw_lc_entry_t = std::pair<std::string, int>;

struct cls_rgw_lc_get_next_entry_ret {
  rgw_lc_entry_t entry;
  cls_rgw_lc_get_next_entry_ret() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

};
inline void encode(const cls_rgw_lc_get_next_entry_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_get_next_entry_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_get_entry_op {
  string marker;
  cls_rgw_lc_get_entry_op() {}
  cls_rgw_lc_get_entry_op(const std::string& _marker) : marker(_marker) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(marker, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const cls_rgw_lc_get_entry_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_get_entry_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_get_entry_ret {
  rgw_lc_entry_t entry;
  cls_rgw_lc_get_entry_ret() {}
  cls_rgw_lc_get_entry_ret(rgw_lc_entry_t&& _entry) : entry(std::move(_entry)) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

};
inline void encode(const cls_rgw_lc_get_entry_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_get_entry_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }


struct cls_rgw_lc_rm_entry_op {
  rgw_lc_entry_t entry;
  cls_rgw_lc_rm_entry_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const cls_rgw_lc_rm_entry_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_rm_entry_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_set_entry_op {
  rgw_lc_entry_t entry;
  cls_rgw_lc_set_entry_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const cls_rgw_lc_set_entry_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_set_entry_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_put_head_op {
  cls_rgw_lc_obj_head head;


  cls_rgw_lc_put_head_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(head, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(head, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

};
inline void encode(const cls_rgw_lc_put_head_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_put_head_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_get_head_ret {
  cls_rgw_lc_obj_head head;

  cls_rgw_lc_get_head_ret() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(head, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(head, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

};
inline void encode(const cls_rgw_lc_get_head_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_get_head_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_list_entries_op {
  string marker;
  uint32_t max_entries = 0;

  cls_rgw_lc_list_entries_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(marker, bl);
    encode(max_entries, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(marker, bl);
    decode(max_entries, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

};
inline void encode(const cls_rgw_lc_list_entries_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_list_entries_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_lc_list_entries_ret {
  map<string, int> entries;
  bool is_truncated{false};

  cls_rgw_lc_list_entries_ret() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 2; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entries, bl);
    encode(is_truncated, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entries, bl);
    if (struct_v >= 2) {
      decode(is_truncated, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

};
inline void encode(const cls_rgw_lc_list_entries_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_lc_list_entries_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_reshard_add_op {
 cls_rgw_reshard_entry entry;

  cls_rgw_reshard_add_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_reshard_add_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_reshard_add_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_reshard_add_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_reshard_list_op {
  uint32_t max{0};
  string marker;

  cls_rgw_reshard_list_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(max, bl);
    encode(marker, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(max, bl);
    decode(marker, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_reshard_list_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_reshard_list_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_reshard_list_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }


struct cls_rgw_reshard_list_ret {
  list<cls_rgw_reshard_entry> entries;
  bool is_truncated{false};

  cls_rgw_reshard_list_ret() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entries, bl);
    encode(is_truncated, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entries, bl);
    decode(is_truncated, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_reshard_list_ret*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_reshard_list_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_reshard_list_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_reshard_get_op {
  cls_rgw_reshard_entry entry;

  cls_rgw_reshard_get_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_reshard_get_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_reshard_get_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_reshard_get_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_reshard_get_ret {
  cls_rgw_reshard_entry entry;

  cls_rgw_reshard_get_ret() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_reshard_get_ret*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_reshard_get_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_reshard_get_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_reshard_remove_op {
  string tenant;
  string bucket_name;
  string bucket_id;

  cls_rgw_reshard_remove_op() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(tenant, bl);
    encode(bucket_name, bl);
    encode(bucket_id, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(tenant, bl);
    decode(bucket_name, bl);
    decode(bucket_id, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_reshard_remove_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_reshard_remove_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_reshard_remove_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_set_bucket_resharding_op {
  cls_rgw_bucket_instance_entry entry;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entry, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(entry, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_set_bucket_resharding_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_set_bucket_resharding_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_set_bucket_resharding_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_clear_bucket_resharding_op {
  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
  static void generate_test_instances(list<cls_rgw_clear_bucket_resharding_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_clear_bucket_resharding_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_clear_bucket_resharding_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_guard_bucket_resharding_op {
  int ret_err{0};

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(ret_err, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(ret_err, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  static void generate_test_instances(list<cls_rgw_guard_bucket_resharding_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_guard_bucket_resharding_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_guard_bucket_resharding_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_get_bucket_resharding_op {

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  static void generate_test_instances(list<cls_rgw_get_bucket_resharding_op*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_get_bucket_resharding_op &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_get_bucket_resharding_op &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct cls_rgw_get_bucket_resharding_ret {
  cls_rgw_bucket_instance_entry new_instance;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(new_instance, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(new_instance, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  static void generate_test_instances(list<cls_rgw_get_bucket_resharding_ret*>& o);
  void dump(Formatter *f) const;
};
inline void encode(const cls_rgw_get_bucket_resharding_ret &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(cls_rgw_get_bucket_resharding_ret &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_const.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 2







class BucketIndexAioManager;




struct BucketIndexAioArg : public RefCountedObject {
  BucketIndexAioArg(int _id, BucketIndexAioManager* _manager) :
    id(_id), manager(_manager) {}
  int id;
  BucketIndexAioManager* manager;
};






class BucketIndexAioManager {
private:
  map<int, librados::AioCompletion*> pendings;
  map<int, librados::AioCompletion*> completions;
  map<int, string> pending_objs;
  map<int, string> completion_objs;
  int next;
  Mutex lock;
  Cond cond;



  static void bucket_index_op_completion_cb(void* cb, void* arg) {
    BucketIndexAioArg* cb_arg = (BucketIndexAioArg*) arg;
    cb_arg->manager->do_completion(cb_arg->id);
    cb_arg->put();
  }






  int get_next() { return next++; }
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
  void add_pending(int id, librados::AioCompletion* completion, const string& oid) {
    pendings[id] = completion;
    pending_objs[id] = oid;
  }
public:



  BucketIndexAioManager() : next(0), lock("BucketIndexAioManager::lock") {}





  void do_completion(int id);
# 94 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
  bool wait_for_completions(int valid_ret_code, int *num_completions, int *ret_code,
      map<int, string> *objs);




  bool aio_operate(librados::IoCtx& io_ctx, const string& oid, librados::ObjectReadOperation *op) {
    Mutex::Locker l(lock);
    BucketIndexAioArg *arg = new BucketIndexAioArg(get_next(), this);
    librados::AioCompletion *c = librados::Rados::aio_create_completion((void*)arg, 
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
                                                                                   __null
# 103 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                                                                                       , bucket_index_op_completion_cb);
    int r = io_ctx.aio_operate(oid, c, (librados::ObjectReadOperation*)op, 
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
                                                                          __null
# 104 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                                                                              );
    if (r >= 0) {
      add_pending(arg->id, c, oid);
    } else {
      c->release();
    }
    return r;
  }




  bool aio_operate(librados::IoCtx& io_ctx, const string& oid, librados::ObjectWriteOperation *op) {
    Mutex::Locker l(lock);
    BucketIndexAioArg *arg = new BucketIndexAioArg(get_next(), this);
    librados::AioCompletion *c = librados::Rados::aio_create_completion((void*)arg, 
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
                                                                                   __null
# 119 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                                                                                       , bucket_index_op_completion_cb);
    int r = io_ctx.aio_operate(oid, c, (librados::ObjectWriteOperation*)op);
    if (r >= 0) {
      add_pending(arg->id, c, oid);
    } else {
      c->release();
    }
    return r;
  }
};

class RGWGetDirHeader_CB : public RefCountedObject {
public:
  ~RGWGetDirHeader_CB() override {}
  virtual void handle_response(int r, rgw_bucket_dir_header& header) = 0;
};

class BucketIndexShardsManager {
private:

  map<int, string> value_by_shards;
public:
  const static string KEY_VALUE_SEPARATOR;
  const static string SHARDS_SEPARATOR;

  void add(int shard, const string& value) {
    value_by_shards[shard] = value;
  }

  const string& get(int shard, const string& default_value) {
    map<int, string>::iterator iter = value_by_shards.find(shard);
    return (iter == value_by_shards.end() ? default_value : iter->second);
  }

  map<int, string>& get() {
    return value_by_shards;
  }

  bool empty() {
    return value_by_shards.empty();
  }

  void to_string(string *out) const {
    if (!out) {
      return;
    }
    out->clear();
    map<int, string>::const_iterator iter = value_by_shards.begin();
    for (; iter != value_by_shards.end(); ++iter) {
      if (out->length()) {

        out->append(SHARDS_SEPARATOR);
      }
      char buf[16];
      snprintf(buf, sizeof(buf), "%d", iter->first);
      out->append(buf);
      out->append(KEY_VALUE_SEPARATOR);
      out->append(iter->second);
    }
  }

  static bool is_shards_marker(const string& marker) {
    return marker.find(KEY_VALUE_SEPARATOR) != string::npos;
  }
# 195 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
  int from_string(const string& composed_marker, int shard_id) {
    value_by_shards.clear();
    vector<string> shards;
    get_str_vec(composed_marker, SHARDS_SEPARATOR.c_str(), shards);
    if (shards.size() > 1 && shard_id >= 0) {
      return -
# 200 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
             22
# 200 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                   ;
    }
    vector<string>::const_iterator iter = shards.begin();
    for (; iter != shards.end(); ++iter) {
      size_t pos = iter->find(KEY_VALUE_SEPARATOR);
      if (pos == string::npos) {
        if (!value_by_shards.empty()) {
          return -
# 207 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
                 22
# 207 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                       ;
        }
        if (shard_id < 0) {
          add(0, *iter);
        } else {
          add(shard_id, *iter);
        }
        return 0;
      }
      string shard_str = iter->substr(0, pos);
      string err;
      int shard = (int)strict_strtol(shard_str.c_str(), 10, &err);
      if (!err.empty()) {
        return -
# 220 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
               22
# 220 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                     ;
      }
      add(shard, iter->substr(pos + 1));
    }
    return 0;
  }


  static std::string get_shard_marker(const std::string& marker) {
    auto p = marker.find(KEY_VALUE_SEPARATOR);
    if (p == marker.npos) {
      return marker;
    }
    return marker.substr(p + 1);
  }
};


void cls_rgw_bucket_init_index(librados::ObjectWriteOperation& o);

class CLSRGWConcurrentIO {
protected:
  librados::IoCtx& io_ctx;
  map<int, string>& objs_container;
  map<int, string>::iterator iter;
  uint32_t max_aio;
  BucketIndexAioManager manager;

  virtual int issue_op(int shard_id, const string& oid) = 0;

  virtual void cleanup() {}
  virtual int valid_ret_code() { return 0; }


  virtual bool need_multiple_rounds() { return false; }

  virtual void add_object(int shard, const string& oid) {}
  virtual void reset_container(map<int, string>& objs) {}

public:

  CLSRGWConcurrentIO(librados::IoCtx& ioc,
       map<int, string>& _objs_container,
       uint32_t _max_aio) :
  io_ctx(ioc), objs_container(_objs_container), max_aio(_max_aio)
  {}

  virtual ~CLSRGWConcurrentIO()
  {}

  int operator()() {
    int ret = 0;
    iter = objs_container.begin();
    for (; iter != objs_container.end() && max_aio-- > 0; ++iter) {
      ret = issue_op(iter->first, iter->second);
      if (ret < 0)
        break;
    }

    int num_completions = 0, r = 0;
    map<int, string> objs;
    map<int, string> *pobjs = (need_multiple_rounds() ? &objs : 
# 281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
                                                               __null
# 281 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                                                                   );
    while (manager.wait_for_completions(valid_ret_code(), &num_completions, &r, pobjs)) {
      if (r >= 0 && ret >= 0) {
        for (; num_completions && iter != objs_container.end(); --num_completions, ++iter) {
          int issue_ret = issue_op(iter->first, iter->second);
          if (issue_ret < 0) {
            ret = issue_ret;
            break;
          }
        }
      } else if (ret >= 0) {
        ret = r;
      }
      if (need_multiple_rounds() && iter == objs_container.end() && !objs.empty()) {


        reset_container(objs);
        iter = objs_container.begin();
        for (; num_completions && iter != objs_container.end(); --num_completions, ++iter) {
          int issue_ret = issue_op(iter->first, iter->second);
          if (issue_ret < 0) {
            ret = issue_ret;
            break;
          }
        }
      }
    }

    if (ret < 0) {
      cleanup();
    }
    return ret;
  }
};

class CLSRGWIssueBucketIndexInit : public CLSRGWConcurrentIO {
protected:
  int issue_op(int shard_id, const string& oid) override;
  int valid_ret_code() override { return -
# 319 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
                                         17
# 319 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                                               ; }
  void cleanup() override;
public:
  CLSRGWIssueBucketIndexInit(librados::IoCtx& ioc, map<int, string>& _bucket_objs,
                     uint32_t _max_aio) :
    CLSRGWConcurrentIO(ioc, _bucket_objs, _max_aio) {}
};


class CLSRGWIssueBucketIndexClean : public CLSRGWConcurrentIO {
protected:
  int issue_op(int shard_id, const string& oid) override;
  int valid_ret_code() override {
    return -
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
           2
# 332 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                 ;
  }

public:
  CLSRGWIssueBucketIndexClean(librados::IoCtx& ioc,
         map<int, string>& _bucket_objs,
         uint32_t _max_aio) :
  CLSRGWConcurrentIO(ioc, _bucket_objs, _max_aio)
  {}
};


class CLSRGWIssueSetTagTimeout : public CLSRGWConcurrentIO {
  uint64_t tag_timeout;
protected:
  int issue_op(int shard_id, const string& oid) override;
public:
  CLSRGWIssueSetTagTimeout(librados::IoCtx& ioc, map<int, string>& _bucket_objs,
                     uint32_t _max_aio, uint64_t _tag_timeout) :
    CLSRGWConcurrentIO(ioc, _bucket_objs, _max_aio), tag_timeout(_tag_timeout) {}
};

void cls_rgw_bucket_update_stats(librados::ObjectWriteOperation& o,
                                 bool absolute,
                                 const map<RGWObjCategory, rgw_bucket_category_stats>& stats);

void cls_rgw_bucket_prepare_op(librados::ObjectWriteOperation& o, RGWModifyOp op, string& tag,
                               const cls_rgw_obj_key& key, const string& locator, bool log_op,
                               uint16_t bilog_op, rgw_zone_set& zones_trace);

void cls_rgw_bucket_complete_op(librados::ObjectWriteOperation& o, RGWModifyOp op, string& tag,
                                rgw_bucket_entry_ver& ver,
                                const cls_rgw_obj_key& key,
                                rgw_bucket_dir_entry_meta& dir_meta,
    list<cls_rgw_obj_key> *remove_objs, bool log_op,
                                uint16_t bilog_op, rgw_zone_set *zones_trace);

void cls_rgw_remove_obj(librados::ObjectWriteOperation& o, list<string>& keep_attr_prefixes);
void cls_rgw_obj_store_pg_ver(librados::ObjectWriteOperation& o, const string& attr);
void cls_rgw_obj_check_attrs_prefix(librados::ObjectOperation& o, const string& prefix, bool fail_if_exist);
void cls_rgw_obj_check_mtime(librados::ObjectOperation& o, const ceph::real_time& mtime, bool high_precision_time, RGWCheckMTimeType type);

int cls_rgw_bi_get(librados::IoCtx& io_ctx, const string oid,
                   BIIndexType index_type, cls_rgw_obj_key& key,
                   rgw_cls_bi_entry *entry);
int cls_rgw_bi_put(librados::IoCtx& io_ctx, const string oid, rgw_cls_bi_entry& entry);
void cls_rgw_bi_put(librados::ObjectWriteOperation& op, const string oid, rgw_cls_bi_entry& entry);
int cls_rgw_bi_list(librados::IoCtx& io_ctx, const string oid,
                   const string& name, const string& marker, uint32_t max,
                   list<rgw_cls_bi_entry> *entries, bool *is_truncated);


int cls_rgw_bucket_link_olh(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op,
                            const string& oid, const cls_rgw_obj_key& key, bufferlist& olh_tag,
                            bool delete_marker, const string& op_tag, rgw_bucket_dir_entry_meta *meta,
                            uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time, bool log_op, rgw_zone_set& zones_trace);
int cls_rgw_bucket_unlink_instance(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op,
                                   const string& oid, const cls_rgw_obj_key& key, const string& op_tag,
                                   const string& olh_tag, uint64_t olh_epoch, bool log_op, rgw_zone_set& zones_trace);
int cls_rgw_get_olh_log(librados::IoCtx& io_ctx, string& oid, librados::ObjectReadOperation& op, const cls_rgw_obj_key& olh, uint64_t ver_marker,
                        const string& olh_tag,
                        map<uint64_t, vector<rgw_bucket_olh_log_entry> > *log, bool *is_truncated);
void cls_rgw_trim_olh_log(librados::ObjectWriteOperation& op, const cls_rgw_obj_key& olh, uint64_t ver, const string& olh_tag);
int cls_rgw_clear_olh(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op, string& oid, const cls_rgw_obj_key& olh, const string& olh_tag);
# 414 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
class CLSRGWIssueBucketList : public CLSRGWConcurrentIO {
  cls_rgw_obj_key start_obj;
  string filter_prefix;
  uint32_t num_entries;
  bool list_versions;
  map<int, rgw_cls_list_ret>& result;
protected:
  int issue_op(int shard_id, const string& oid) override;
public:
  CLSRGWIssueBucketList(librados::IoCtx& io_ctx, const cls_rgw_obj_key& _start_obj,
                        const string& _filter_prefix, uint32_t _num_entries,
                        bool _list_versions,
                        map<int, string>& oids,
                        map<int, rgw_cls_list_ret>& list_results,
                        uint32_t max_aio) :
  CLSRGWConcurrentIO(io_ctx, oids, max_aio),
  start_obj(_start_obj), filter_prefix(_filter_prefix), num_entries(_num_entries), list_versions(_list_versions), result(list_results) {}
};

void cls_rgw_bucket_list_op(librados::ObjectReadOperation& op,
                            const cls_rgw_obj_key& start_obj,
                            const std::string& filter_prefix,
                            uint32_t num_entries,
                            bool list_versions,
                            rgw_cls_list_ret* result);

class CLSRGWIssueBILogList : public CLSRGWConcurrentIO {
  map<int, cls_rgw_bi_log_list_ret>& result;
  BucketIndexShardsManager& marker_mgr;
  uint32_t max;
protected:
  int issue_op(int shard_id, const string& oid) override;
public:
  CLSRGWIssueBILogList(librados::IoCtx& io_ctx, BucketIndexShardsManager& _marker_mgr, uint32_t _max,
                       map<int, string>& oids,
                       map<int, cls_rgw_bi_log_list_ret>& bi_log_lists, uint32_t max_aio) :
    CLSRGWConcurrentIO(io_ctx, oids, max_aio), result(bi_log_lists),
    marker_mgr(_marker_mgr), max(_max) {}
};

class CLSRGWIssueBILogTrim : public CLSRGWConcurrentIO {
  BucketIndexShardsManager& start_marker_mgr;
  BucketIndexShardsManager& end_marker_mgr;
protected:
  int issue_op(int shard_id, const string& oid) override;

  int valid_ret_code() override { return -
# 460 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h" 3 4
                                         61
# 460 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
                                                ; }
  bool need_multiple_rounds() override { return true; }
  void add_object(int shard, const string& oid) override { objs_container[shard] = oid; }
  void reset_container(map<int, string>& objs) override {
    objs_container.swap(objs);
    iter = objs_container.begin();
    objs.clear();
  }
public:
  CLSRGWIssueBILogTrim(librados::IoCtx& io_ctx, BucketIndexShardsManager& _start_marker_mgr,
      BucketIndexShardsManager& _end_marker_mgr, map<int, string>& _bucket_objs, uint32_t max_aio) :
    CLSRGWConcurrentIO(io_ctx, _bucket_objs, max_aio),
    start_marker_mgr(_start_marker_mgr), end_marker_mgr(_end_marker_mgr) {}
};
# 484 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/cls/rgw/cls_rgw_client.h"
class CLSRGWIssueBucketCheck : public CLSRGWConcurrentIO {
  map<int, rgw_cls_check_index_ret>& result;
protected:
  int issue_op(int shard_id, const string& oid) override;
public:
  CLSRGWIssueBucketCheck(librados::IoCtx& ioc, map<int, string>& oids,
    map<int, rgw_cls_check_index_ret>& bucket_objs_ret,
    uint32_t _max_aio) :
    CLSRGWConcurrentIO(ioc, oids, _max_aio), result(bucket_objs_ret) {}
};

class CLSRGWIssueBucketRebuild : public CLSRGWConcurrentIO {
protected:
  int issue_op(int shard_id, const string& oid) override;
public:
  CLSRGWIssueBucketRebuild(librados::IoCtx& io_ctx, map<int, string>& bucket_objs,
                           uint32_t max_aio) : CLSRGWConcurrentIO(io_ctx, bucket_objs, max_aio) {}
};

class CLSRGWIssueGetDirHeader : public CLSRGWConcurrentIO {
  map<int, rgw_cls_list_ret>& result;
protected:
  int issue_op(int shard_id, const string& oid) override;
public:
  CLSRGWIssueGetDirHeader(librados::IoCtx& io_ctx, map<int, string>& oids, map<int, rgw_cls_list_ret>& dir_headers,
                          uint32_t max_aio) :
    CLSRGWConcurrentIO(io_ctx, oids, max_aio), result(dir_headers) {}
};

class CLSRGWIssueSetBucketResharding : public CLSRGWConcurrentIO {
  cls_rgw_bucket_instance_entry entry;
protected:
  int issue_op(int shard_id, const string& oid) override;
public:
  CLSRGWIssueSetBucketResharding(librados::IoCtx& ioc, map<int, string>& _bucket_objs,
                                 const cls_rgw_bucket_instance_entry& _entry,
                                 uint32_t _max_aio) : CLSRGWConcurrentIO(ioc, _bucket_objs, _max_aio), entry(_entry) {}
};

class CLSRGWIssueResyncBucketBILog : public CLSRGWConcurrentIO {
protected:
  int issue_op(int shard_id, const string& oid);
public:
  CLSRGWIssueResyncBucketBILog(librados::IoCtx& io_ctx, map<int, string>& _bucket_objs, uint32_t max_aio) :
    CLSRGWConcurrentIO(io_ctx, _bucket_objs, max_aio) {}
};

class CLSRGWIssueBucketBILogStop : public CLSRGWConcurrentIO {
protected:
  int issue_op(int shard_id, const string& oid);
public:
  CLSRGWIssueBucketBILogStop(librados::IoCtx& io_ctx, map<int, string>& _bucket_objs, uint32_t max_aio) :
    CLSRGWConcurrentIO(io_ctx, _bucket_objs, max_aio) {}
};

int cls_rgw_get_dir_header_async(librados::IoCtx& io_ctx, string& oid, RGWGetDirHeader_CB *ctx);

void cls_rgw_encode_suggestion(char op, rgw_bucket_dir_entry& dirent, bufferlist& updates);

void cls_rgw_suggest_changes(librados::ObjectWriteOperation& o, bufferlist& updates);


int cls_rgw_usage_log_read(librados::IoCtx& io_ctx, const string& oid, const string& user, const string& bucket,
                           uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries, string& read_iter,
      map<rgw_user_bucket, rgw_usage_log_entry>& usage, bool *is_truncated);

int cls_rgw_usage_log_trim(librados::IoCtx& io_ctx, const string& oid, const string& user, const string& bucket,
                           uint64_t start_epoch, uint64_t end_epoch);

void cls_rgw_usage_log_clear(librados::ObjectWriteOperation& op);
void cls_rgw_usage_log_add(librados::ObjectWriteOperation& op, rgw_usage_log_info& info);


void cls_rgw_gc_set_entry(librados::ObjectWriteOperation& op, uint32_t expiration_secs, cls_rgw_gc_obj_info& info);
void cls_rgw_gc_defer_entry(librados::ObjectWriteOperation& op, uint32_t expiration_secs, const string& tag);

int cls_rgw_gc_list(librados::IoCtx& io_ctx, string& oid, string& marker, uint32_t max, bool expired_only,
                    list<cls_rgw_gc_obj_info>& entries, bool *truncated, string& next_marker);

void cls_rgw_gc_remove(librados::ObjectWriteOperation& op, const vector<string>& tags);


int cls_rgw_lc_get_head(librados::IoCtx& io_ctx, const string& oid, cls_rgw_lc_obj_head& head);
int cls_rgw_lc_put_head(librados::IoCtx& io_ctx, const string& oid, cls_rgw_lc_obj_head& head);
int cls_rgw_lc_get_next_entry(librados::IoCtx& io_ctx, const string& oid, string& marker, pair<string, int>& entry);
int cls_rgw_lc_rm_entry(librados::IoCtx& io_ctx, const string& oid, const pair<string, int>& entry);
int cls_rgw_lc_set_entry(librados::IoCtx& io_ctx, const string& oid, const pair<string, int>& entry);
int cls_rgw_lc_get_entry(librados::IoCtx& io_ctx, const string& oid, const std::string& marker, rgw_lc_entry_t& entry);
int cls_rgw_lc_list(librados::IoCtx& io_ctx, const string& oid,
                    const string& marker,
                    uint32_t max_entries,
                    map<string, int>& entries);


void cls_rgw_reshard_add(librados::ObjectWriteOperation& op, const cls_rgw_reshard_entry& entry);
int cls_rgw_reshard_list(librados::IoCtx& io_ctx, const string& oid, string& marker, uint32_t max,
                         list<cls_rgw_reshard_entry>& entries, bool* is_truncated);
int cls_rgw_reshard_get(librados::IoCtx& io_ctx, const string& oid, cls_rgw_reshard_entry& entry);
int cls_rgw_reshard_get_head(librados::IoCtx& io_ctx, const string& oid, cls_rgw_reshard_entry& entry);
void cls_rgw_reshard_remove(librados::ObjectWriteOperation& op, const cls_rgw_reshard_entry& entry);


int cls_rgw_set_bucket_resharding(librados::IoCtx& io_ctx, const string& oid,
                                  const cls_rgw_bucket_instance_entry& entry);
int cls_rgw_clear_bucket_resharding(librados::IoCtx& io_ctx, const string& oid);
void cls_rgw_guard_bucket_resharding(librados::ObjectOperation& op, int ret_err);
int cls_rgw_get_bucket_resharding(librados::IoCtx& io_ctx, const string& oid,
                                  cls_rgw_bucket_instance_entry *entry);
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj.h" 1






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_rados.h" 1
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj_core.h" 1
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj_core.h"
class RGWSI_Zone;

struct rgw_cache_entry_info;

struct RGWSysObjState {
  rgw_raw_obj obj;
  bool has_attrs{false};
  bool exists{false};
  uint64_t size{0};
  ceph::real_time mtime;
  uint64_t epoch{0};
  bufferlist obj_tag;
  bool has_data{false};
  bufferlist data;
  bool prefetch_data{false};
  uint64_t pg_ver{0};



  RGWObjVersionTracker objv_tracker;

  map<string, bufferlist> attrset;
  RGWSysObjState() {}
  RGWSysObjState(const RGWSysObjState& rhs) : obj (rhs.obj) {
    has_attrs = rhs.has_attrs;
    exists = rhs.exists;
    size = rhs.size;
    mtime = rhs.mtime;
    epoch = rhs.epoch;
    if (rhs.obj_tag.length()) {
      obj_tag = rhs.obj_tag;
    }
    has_data = rhs.has_data;
    if (rhs.data.length()) {
      data = rhs.data;
    }
    prefetch_data = rhs.prefetch_data;
    pg_ver = rhs.pg_ver;
    objv_tracker = rhs.objv_tracker;
  }
};

class RGWSysObjectCtxBase {
  std::map<rgw_raw_obj, RGWSysObjState> objs_state;
  RWLock lock;

public:
  explicit RGWSysObjectCtxBase() : lock("RGWSysObjectCtxBase") {}

  RGWSysObjectCtxBase(const RGWSysObjectCtxBase& rhs) : objs_state(rhs.objs_state),
                                                  lock("RGWSysObjectCtxBase") {}
  RGWSysObjectCtxBase(const RGWSysObjectCtxBase&& rhs) : objs_state(std::move(rhs.objs_state)),
                                                   lock("RGWSysObjectCtxBase") {}

  RGWSysObjState *get_state(const rgw_raw_obj& obj) {
    RGWSysObjState *result;
    std::map<rgw_raw_obj, RGWSysObjState>::iterator iter;
    lock.get_read();
    
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj_core.h" 3 4
   (static_cast<void> (0))
# 68 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj_core.h"
                        ;
    iter = objs_state.find(obj);
    if (iter != objs_state.end()) {
      result = &iter->second;
      lock.unlock();
    } else {
      lock.unlock();
      lock.get_write();
      result = &objs_state[obj];
      lock.unlock();
    }
    return result;
  }

  void set_prefetch_data(rgw_raw_obj& obj) {
    RWLock::WLocker wl(lock);
    
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj_core.h" 3 4
   (static_cast<void> (0))
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj_core.h"
                        ;
    objs_state[obj].prefetch_data = true;
  }
  void invalidate(rgw_raw_obj& obj) {
    RWLock::WLocker wl(lock);
    auto iter = objs_state.find(obj);
    if (iter == objs_state.end()) {
      return;
    }
    objs_state.erase(iter);
  }
};

class RGWSI_SysObj_Core : public RGWServiceInstance
{
  friend class RGWServices_Def;
  friend class RGWSI_SysObj;

protected:
  RGWSI_RADOS *rados_svc{nullptr};
  RGWSI_Zone *zone_svc{nullptr};

  struct GetObjState {
    RGWSI_RADOS::Obj rados_obj;
    bool has_rados_obj{false};
    uint64_t last_ver{0};

    GetObjState() {}

    int get_rados_obj(RGWSI_RADOS *rados_svc,
                      RGWSI_Zone *zone_svc,
                      const rgw_raw_obj& obj,
                      RGWSI_RADOS::Obj **pobj);
  };


  void core_init(RGWSI_RADOS *_rados_svc,
                 RGWSI_Zone *_zone_svc) {
    rados_svc = _rados_svc;
    zone_svc = _zone_svc;
  }
  int get_rados_obj(RGWSI_Zone *zone_svc, const rgw_raw_obj& obj, RGWSI_RADOS::Obj *pobj);

  virtual int raw_stat(const rgw_raw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch,
                       map<string, bufferlist> *attrs, bufferlist *first_chunk,
                       RGWObjVersionTracker *objv_tracker);

  virtual int read(RGWSysObjectCtxBase& obj_ctx,
                   GetObjState& read_state,
                   RGWObjVersionTracker *objv_tracker,
                   const rgw_raw_obj& obj,
                   bufferlist *bl, off_t ofs, off_t end,
                   map<string, bufferlist> *attrs,
     bool raw_attrs,
                   rgw_cache_entry_info *cache_info,
                   boost::optional<obj_version>);

  virtual int remove(RGWSysObjectCtxBase& obj_ctx,
                     RGWObjVersionTracker *objv_tracker,
                     const rgw_raw_obj& obj);

  virtual int write(const rgw_raw_obj& obj,
                    real_time *pmtime,
                    map<std::string, bufferlist>& attrs,
                    bool exclusive,
                    const bufferlist& data,
                    RGWObjVersionTracker *objv_tracker,
                    real_time set_mtime);

  virtual int write_data(const rgw_raw_obj& obj,
                         const bufferlist& bl,
                         bool exclusive,
                         RGWObjVersionTracker *objv_tracker);

  virtual int get_attr(const rgw_raw_obj& obj, const char *name, bufferlist *dest);

  virtual int set_attrs(const rgw_raw_obj& obj,
                        map<string, bufferlist>& attrs,
                        map<string, bufferlist> *rmattrs,
                        RGWObjVersionTracker *objv_tracker);

  virtual int omap_get_all(const rgw_raw_obj& obj, std::map<string, bufferlist> *m);
  virtual int omap_get_vals(const rgw_raw_obj& obj,
                            const string& marker,
                            uint64_t count,
                            std::map<string, bufferlist> *m,
                            bool *pmore);
  virtual int omap_set(const rgw_raw_obj& obj, const std::string& key, bufferlist& bl, bool must_exist = false);
  virtual int omap_set(const rgw_raw_obj& obj, const map<std::string, bufferlist>& m, bool must_exist = false);
  virtual int omap_del(const rgw_raw_obj& obj, const std::string& key);

  virtual int notify(const rgw_raw_obj& obj,
       bufferlist& bl,
       uint64_t timeout_ms,
       bufferlist *pbl);


  int get_system_obj_state_impl(RGWSysObjectCtxBase *rctx, const rgw_raw_obj& obj, RGWSysObjState **state, RGWObjVersionTracker *objv_tracker);
  int get_system_obj_state(RGWSysObjectCtxBase *rctx, const rgw_raw_obj& obj, RGWSysObjState **state, RGWObjVersionTracker *objv_tracker);

  int stat(RGWSysObjectCtxBase& obj_ctx,
           GetObjState& state,
           const rgw_raw_obj& obj,
           map<string, bufferlist> *attrs,
    bool raw_attrs,
           real_time *lastmod,
           uint64_t *obj_size,
           RGWObjVersionTracker *objv_tracker);

public:
  RGWSI_SysObj_Core(CephContext *cct): RGWServiceInstance(cct) {}

  RGWSI_Zone *get_zone_svc() {
    return zone_svc;
  }
};
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/services/svc_sys_obj.h" 2


class RGWSI_Zone;
class RGWSI_SysObj;
class RGWSysObjectCtx;

struct rgw_cache_entry_info;

class RGWSI_SysObj : public RGWServiceInstance
{
  friend struct RGWServices_Def;

public:
  class Obj {
    friend class ROp;

    RGWSI_SysObj_Core *core_svc;
    RGWSysObjectCtx& ctx;
    rgw_raw_obj obj;

  public:
    Obj(RGWSI_SysObj_Core *_core_svc,
        RGWSysObjectCtx& _ctx,
        const rgw_raw_obj& _obj) : core_svc(_core_svc),
                                   ctx(_ctx),
                                   obj(_obj) {}

    void invalidate();

    RGWSysObjectCtx& get_ctx() {
      return ctx;
    }

    rgw_raw_obj& get_obj() {
      return obj;
    }

    struct ROp {
      Obj& source;

      RGWSI_SysObj_Core::GetObjState state;

      RGWObjVersionTracker *objv_tracker{nullptr};
      map<string, bufferlist> *attrs{nullptr};
      bool raw_attrs{false};
      boost::optional<obj_version> refresh_version{boost::none};
      ceph::real_time *lastmod{nullptr};
      uint64_t *obj_size{nullptr};
      rgw_cache_entry_info *cache_info{nullptr};

      ROp& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
        objv_tracker = _objv_tracker;
        return *this;
      }

      ROp& set_last_mod(ceph::real_time *_lastmod) {
        lastmod = _lastmod;
        return *this;
      }

      ROp& set_obj_size(uint64_t *_obj_size) {
        obj_size = _obj_size;
        return *this;
      }

      ROp& set_attrs(map<string, bufferlist> *_attrs) {
        attrs = _attrs;
        return *this;
      }

      ROp& set_raw_attrs(bool ra) {
 raw_attrs = ra;
 return *this;
      }

      ROp& set_refresh_version(boost::optional<obj_version>& rf) {
        refresh_version = rf;
        return *this;
      }

      ROp& set_cache_info(rgw_cache_entry_info *ci) {
        cache_info = ci;
        return *this;
      }

      ROp(Obj& _source) : source(_source) {}

      int stat();
      int read(int64_t ofs, int64_t end, bufferlist *pbl);
      int read(bufferlist *pbl) {
        return read(0, -1, pbl);
      }
      int get_attr(const char *name, bufferlist *dest);
    };

    struct WOp {
      Obj& source;

      RGWObjVersionTracker *objv_tracker{nullptr};
      map<string, bufferlist> attrs;
      ceph::real_time mtime;
      ceph::real_time *pmtime{nullptr};
      bool exclusive{false};

      WOp& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
        objv_tracker = _objv_tracker;
        return *this;
      }

      WOp& set_attrs(map<string, bufferlist>& _attrs) {
        attrs = _attrs;
        return *this;
      }

      WOp& set_attrs(map<string, bufferlist>&& _attrs) {
        attrs = _attrs;
        return *this;
      }

      WOp& set_mtime(const ceph::real_time& _mtime) {
        mtime = _mtime;
        return *this;
      }

      WOp& set_pmtime(ceph::real_time *_pmtime) {
        pmtime = _pmtime;
        return *this;
      }

      WOp& set_exclusive(bool _exclusive = true) {
        exclusive = _exclusive;
        return *this;
      }

      WOp(Obj& _source) : source(_source) {}

      int remove();
      int write(bufferlist& bl);

      int write_data(bufferlist& bl);
      int write_attrs();
      int write_attr(const char *name, bufferlist& bl);
    };

    struct OmapOp {
      Obj& source;

      bool must_exist{false};

      OmapOp& set_must_exist(bool _must_exist = true) {
        must_exist = _must_exist;
        return *this;
      }

      OmapOp(Obj& _source) : source(_source) {}

      int get_all(std::map<string, bufferlist> *m);
      int get_vals(const string& marker,
                        uint64_t count,
                        std::map<string, bufferlist> *m,
                        bool *pmore);
      int set(const std::string& key, bufferlist& bl);
      int set(const map<std::string, bufferlist>& m);
      int del(const std::string& key);
    };

    struct WNOp {
      Obj& source;

      WNOp(Obj& _source) : source(_source) {}

      int notify(bufferlist& bl,
   uint64_t timeout_ms,
   bufferlist *pbl);
    };
    ROp rop() {
      return ROp(*this);
    }

    WOp wop() {
      return WOp(*this);
    }

    OmapOp omap() {
      return OmapOp(*this);
    }

    WNOp wn() {
      return WNOp(*this);
    }
  };

  class Pool {
    friend class Op;

    RGWSI_RADOS *rados_svc;
    RGWSI_SysObj_Core *core_svc;
    rgw_pool pool;

  public:
    Pool(RGWSI_RADOS *_rados_svc,
  RGWSI_SysObj_Core *_core_svc,
         const rgw_pool& _pool) : rados_svc(_rados_svc),
                                  core_svc(_core_svc),
                                  pool(_pool) {}

    rgw_pool& get_pool() {
      return pool;
    }

    struct Op {
      Pool& source;

      Op(Pool& _source) : source(_source) {}

      int list_prefixed_objs(const std::string& prefix, std::list<std::string> *result);
    };

    Op op() {
      return Op(*this);
    }
  };

  friend class Obj;
  friend class Obj::ROp;
  friend class Obj::WOp;
  friend class Pool;
  friend class Pool::Op;

protected:
  RGWSI_RADOS *rados_svc{nullptr};
  RGWSI_SysObj_Core *core_svc{nullptr};

  void init(RGWSI_RADOS *_rados_svc,
            RGWSI_SysObj_Core *_core_svc) {
    rados_svc = _rados_svc;
    core_svc = _core_svc;
  }

public:
  RGWSI_SysObj(CephContext *cct): RGWServiceInstance(cct) {}

  RGWSysObjectCtx init_obj_ctx();
  Obj get_obj(RGWSysObjectCtx& obj_ctx, const rgw_raw_obj& obj);

  Pool get_pool(const rgw_pool& pool) {
    return Pool(rados_svc, core_svc, pool);
  }

  RGWSI_Zone *get_zone_svc();
};

using RGWSysObj = RGWSI_SysObj::Obj;

class RGWSysObjectCtx : public RGWSysObjectCtxBase
{
  RGWSI_SysObj *sysobj_svc;
public:
  RGWSysObjectCtx(RGWSI_SysObj *_sysobj_svc) : sysobj_svc(_sysobj_svc) {}

  RGWSI_SysObj::Obj get_obj(const rgw_raw_obj& obj) {
    return sysobj_svc->get_obj(*this, obj);
  }
};
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 2



using ceph::crypto::SHA1;

struct req_state;
class RGWOp;


namespace rgw {
namespace auth {
namespace registry {

class StrategyRegistry;

}
}
}

int rgw_op_get_bucket_policy_from_attr(CephContext *cct,
                                       RGWRados *store,
                                       RGWBucketInfo& bucket_info,
                                       map<string, bufferlist>& bucket_attrs,
                                       RGWAccessControlPolicy *policy);

class RGWHandler {
protected:
  RGWRados* store;
  struct req_state* s;

  int do_init_permissions();
  int do_read_permissions(RGWOp* op, bool only_bucket);

public:
  RGWHandler()
    : store(nullptr),
      s(nullptr) {
  }
  virtual ~RGWHandler();

  virtual int init(RGWRados* store,
                   struct req_state* _s,
                   rgw::io::BasicClient* cio);

  virtual int init_permissions(RGWOp*) {
    return 0;
  }

  virtual int retarget(RGWOp* op, RGWOp** new_op) {
    *new_op = op;
    return 0;
  }

  virtual int read_permissions(RGWOp* op) = 0;
  virtual int authorize(const DoutPrefixProvider* dpp) = 0;
  virtual int postauth_init() = 0;
  virtual int error_handler(int err_no, std::string* error_content);
  virtual void dump(const string& code, const string& message) const {}

  virtual bool supports_quota() {
    return true;
  }
};



void rgw_bucket_object_pre_exec(struct req_state *s);

namespace dmc = rgw::dmclock;




class RGWOp : public DoutPrefixProvider {
protected:
  struct req_state *s;
  RGWHandler *dialect_handler;
  RGWRados *store;
  RGWCORSConfiguration bucket_cors;
  bool cors_exist;
  RGWQuotaInfo bucket_quota;
  RGWQuotaInfo user_quota;
  int op_ret;
  int do_aws4_auth_completion();

  virtual int init_quota();

public:
  RGWOp()
    : s(nullptr),
      dialect_handler(nullptr),
      store(nullptr),
      cors_exist(false),
      op_ret(0) {
  }

  virtual ~RGWOp() = default;

  int get_ret() const { return op_ret; }

  virtual int init_processing() {
    if (dialect_handler->supports_quota()) {
      op_ret = init_quota();
      if (op_ret < 0)
        return op_ret;
    }

    return 0;
  }

  virtual void init(RGWRados *store, struct req_state *s, RGWHandler *dialect_handler) {
    this->store = store;
    this->s = s;
    this->dialect_handler = dialect_handler;
  }
  int read_bucket_cors();
  bool generate_cors_headers(string& origin, string& method, string& headers, string& exp_headers, unsigned *max_age);

  virtual int verify_params() { return 0; }
  virtual bool prefetch_data() { return false; }
# 183 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
  virtual int verify_requester(const rgw::auth::StrategyRegistry& auth_registry) {

    return dialect_handler->authorize(this);
  }
  virtual int verify_permission() = 0;
  virtual int verify_op_mask();
  virtual void pre_exec() {}
  virtual void execute() = 0;
  virtual void send_response() {}
  virtual void complete() {
    send_response();
  }
  virtual const char* name() const = 0;
  virtual RGWOpType get_type() { return RGW_OP_UNKNOWN; }

  virtual uint32_t op_mask() { return 0; }

  virtual int error_handler(int err_no, string *error_content);


  std::ostream& gen_prefix(std::ostream& out) const override;
  CephContext* get_cct() const override { return s->cct; }
  unsigned get_subsys() const override { return ceph_subsys_rgw; }

  virtual dmc::client_id dmclock_client() { return dmc::client_id::metadata; }
  virtual dmc::Cost dmclock_cost() { return 1; }
};

class RGWDefaultResponseOp : public RGWOp {
public:
  void send_response() override;
};

class RGWGetObj_Filter : public RGWGetDataCB
{
protected:
  RGWGetObj_Filter *next{nullptr};
public:
  RGWGetObj_Filter() {}
  explicit RGWGetObj_Filter(RGWGetObj_Filter *next): next(next) {}
  ~RGWGetObj_Filter() override {}





  int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
    if (next) {
      return next->handle_data(bl, bl_ofs, bl_len);
    }
    return 0;
  }




  virtual int flush() {
    if (next) {
      return next->flush();
    }
    return 0;
  }



  virtual int fixup_range(off_t& ofs, off_t& end) {
    if (next) {
      return next->fixup_range(ofs, end);
    }
    return 0;
  }
};

class RGWGetObj : public RGWOp {
protected:
  seed torrent;
  const char *range_str;
  const char *if_mod;
  const char *if_unmod;
  const char *if_match;
  const char *if_nomatch;
  uint32_t mod_zone_id;
  uint64_t mod_pg_ver;
  off_t ofs;
  uint64_t total_len;
  off_t start;
  off_t end;
  ceph::real_time mod_time;
  ceph::real_time lastmod;
  ceph::real_time unmod_time;
  ceph::real_time *mod_ptr;
  ceph::real_time *unmod_ptr;
  map<string, bufferlist> attrs;
  bool get_data;
  bool partial_content;
  bool ignore_invalid_range;
  bool range_parsed;
  bool skip_manifest;
  bool skip_decrypt{false};
  rgw_obj obj;
  utime_t gc_invalidate_time;
  bool is_slo;
  string lo_etag;
  bool rgwx_stat;
  string version_id;


  RGWCompressionInfo cs_info;
  off_t first_block, last_block;
  off_t q_ofs, q_len;
  bool first_data;
  uint64_t cur_ofs;
  bufferlist waiting;
  uint64_t action = 0;

  bool get_retention;
  bool get_legal_hold;

  int init_common();
public:
  RGWGetObj() {
    range_str = 
# 304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               __null
# 304 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                   ;
    if_mod = 
# 305 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
            __null
# 305 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                ;
    if_unmod = 
# 306 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
              __null
# 306 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                  ;
    if_match = 
# 307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
              __null
# 307 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                  ;
    if_nomatch = 
# 308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                __null
# 308 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                    ;
    mod_zone_id = 0;
    mod_pg_ver = 0;
    start = 0;
    ofs = 0;
    total_len = 0;
    end = -1;
    mod_ptr = 
# 315 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
             __null
# 315 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                 ;
    unmod_ptr = 
# 316 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               __null
# 316 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                   ;
    get_data = false;
    partial_content = false;
    range_parsed = false;
    skip_manifest = false;
    is_slo = false;
    first_block = 0;
    last_block = 0;
    q_ofs = 0;
    q_len = 0;
    first_data = true;
    cur_ofs = 0;
    get_retention = false;
    get_legal_hold = false;
 }

  bool prefetch_data() override;

  void set_get_data(bool get_data) {
    this->get_data = get_data;
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  int parse_range();
  int read_user_manifest_part(
    rgw_bucket& bucket,
    const rgw_bucket_dir_entry& ent,
    RGWAccessControlPolicy * const bucket_acl,
    const boost::optional<rgw::IAM::Policy>& bucket_policy,
    const off_t start_ofs,
    const off_t end_ofs,
    bool swift_slo);
  int handle_user_manifest(const char *prefix);
  int handle_slo_manifest(bufferlist& bl);

  int get_data_cb(bufferlist& bl, off_t ofs, off_t len);

  virtual int get_params() = 0;
  virtual int send_response_data_error() = 0;
  virtual int send_response_data(bufferlist& bl, off_t ofs, off_t len) = 0;

  const char* name() const override { return "get_obj"; }
  RGWOpType get_type() override { return RGW_OP_GET_OBJ; }
  uint32_t op_mask() override { return 0x01; }
  virtual bool need_object_expiration() { return false; }



  virtual int get_decrypt_filter(std::unique_ptr<RGWGetObj_Filter>* filter, RGWGetObj_Filter* cb, bufferlist* manifest_bl) {
    *filter = nullptr;
    return 0;
  }
  dmc::client_id dmclock_client() override { return dmc::client_id::data; }
};

class RGWGetObj_CB : public RGWGetObj_Filter
{
  RGWGetObj *op;
public:
  explicit RGWGetObj_CB(RGWGetObj *_op) : op(_op) {}
  ~RGWGetObj_CB() override {}

  int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
    return op->get_data_cb(bl, bl_ofs, bl_len);
  }
};

class RGWGetObjTags : public RGWOp {
 protected:
  bufferlist tags_bl;
  bool has_tags{false};
 public:
  int verify_permission() override;
  void execute() override;
  void pre_exec() override;

  virtual void send_response_data(bufferlist& bl) = 0;
  const char* name() const override { return "get_obj_tags"; }
  virtual uint32_t op_mask() override { return 0x01; }
  RGWOpType get_type() override { return RGW_OP_GET_OBJ_TAGGING; }

};

class RGWPutObjTags : public RGWOp {
 protected:
  bufferlist tags_bl;
 public:
  int verify_permission() override;
  void execute() override;

  virtual void send_response() override = 0;
  virtual int get_params() = 0;
  const char* name() const override { return "put_obj_tags"; }
  virtual uint32_t op_mask() override { return 0x02; }
  RGWOpType get_type() override { return RGW_OP_PUT_OBJ_TAGGING; }

};

class RGWDeleteObjTags: public RGWOp {
 public:
  void pre_exec() override;
  int verify_permission() override;
  void execute() override;

  const char* name() const override { return "delete_obj_tags"; }
  virtual uint32_t op_mask() override { return 0x04; }
  RGWOpType get_type() override { return RGW_OP_DELETE_OBJ_TAGGING;}
};

class RGWBulkDelete : public RGWOp {
public:
  struct acct_path_t {
    std::string bucket_name;
    rgw_obj_key obj_key;
  };

  struct fail_desc_t {
    int err;
    acct_path_t path;
  };

  class Deleter {
  protected:
    const DoutPrefixProvider * dpp;
    unsigned int num_deleted;
    unsigned int num_unfound;
    std::list<fail_desc_t> failures;

    RGWRados * const store;
    req_state * const s;

  public:
    Deleter(const DoutPrefixProvider* dpp, RGWRados * const str, req_state * const s)
      : dpp(dpp),
        num_deleted(0),
        num_unfound(0),
        store(str),
        s(s) {
    }

    unsigned int get_num_deleted() const {
      return num_deleted;
    }

    unsigned int get_num_unfound() const {
      return num_unfound;
    }

    const std::list<fail_desc_t> get_failures() const {
      return failures;
    }

    bool verify_permission(RGWBucketInfo& binfo,
                           map<string, bufferlist>& battrs,
                           ACLOwner& bucket_owner );
    bool delete_single(const acct_path_t& path);
    bool delete_chunk(const std::list<acct_path_t>& paths);
  };


  static const size_t MAX_CHUNK_ENTRIES = 1024;

protected:
  std::unique_ptr<Deleter> deleter;

public:
  RGWBulkDelete()
    : deleter(nullptr) {
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_data(std::list<acct_path_t>& items,
                       bool * is_truncated) = 0;
  void send_response() override = 0;

  const char* name() const override { return "bulk_delete"; }
  RGWOpType get_type() override { return RGW_OP_BULK_DELETE; }
  uint32_t op_mask() override { return 0x04; }
  dmc::client_id dmclock_client() override { return dmc::client_id::data; }
};

inline ostream& operator<<(ostream& out, const RGWBulkDelete::acct_path_t &o) {
  return out << o.bucket_name << "/" << o.obj_key;
}


class RGWBulkUploadOp : public RGWOp {
  boost::optional<RGWSysObjectCtx> dir_ctx;

protected:
  class fail_desc_t {
  public:
    fail_desc_t(const int err, std::string path)
      : err(err),
        path(std::move(path)) {
    }

    const int err;
    const std::string path;
  };

  static constexpr std::array<int, 2> terminal_errors = {
    { -
# 523 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
      13
# 523 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
            , -
# 523 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               1 
# 523 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                     }
  };


  std::vector<fail_desc_t> failures;
  size_t num_created;

  class StreamGetter;
  class DecoratedStreamGetter;
  class AlignedStreamGetter;

  virtual std::unique_ptr<StreamGetter> create_stream() = 0;
  virtual void send_response() override = 0;

  boost::optional<std::pair<std::string, rgw_obj_key>>
  parse_path(const boost::string_ref& path);

  std::pair<std::string, std::string>
  handle_upload_path(struct req_state *s);

  bool handle_file_verify_permission(RGWBucketInfo& binfo,
         const rgw_obj& obj,
         std::map<std::string, ceph::bufferlist>& battrs,
                                     ACLOwner& bucket_owner );
  int handle_file(boost::string_ref path,
                  size_t size,
                  AlignedStreamGetter& body);

  int handle_dir_verify_permission();
  int handle_dir(boost::string_ref path);

public:
  RGWBulkUploadOp()
    : num_created(0) {
  }

  void init(RGWRados* const store,
            struct req_state* const s,
            RGWHandler* const h) override;

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  const char* name() const override { return "bulk_upload"; }

  RGWOpType get_type() override {
    return RGW_OP_BULK_UPLOAD;
  }

  uint32_t op_mask() override {
    return 0x02;
  }
  dmc::client_id dmclock_client() override { return dmc::client_id::data; }
};


class RGWBulkUploadOp::StreamGetter {
public:
  StreamGetter() = default;
  virtual ~StreamGetter() = default;

  virtual ssize_t get_at_most(size_t want, ceph::bufferlist& dst) = 0;
  virtual ssize_t get_exactly(size_t want, ceph::bufferlist& dst) = 0;
};


class RGWBulkUploadOp::DecoratedStreamGetter : public StreamGetter {
  StreamGetter& decoratee;

protected:
  StreamGetter& get_decoratee() {
    return decoratee;
  }

public:
  explicit DecoratedStreamGetter(StreamGetter& decoratee)
    : decoratee(decoratee) {
  }
  virtual ~DecoratedStreamGetter() = default;

  ssize_t get_at_most(const size_t want, ceph::bufferlist& dst) override {
    return get_decoratee().get_at_most(want, dst);
  }

  ssize_t get_exactly(const size_t want, ceph::bufferlist& dst) override {
    return get_decoratee().get_exactly(want, dst);
  }
};


class RGWBulkUploadOp::AlignedStreamGetter
  : public RGWBulkUploadOp::DecoratedStreamGetter {
  size_t position;
  size_t length;
  size_t alignment;

public:
  template <typename U>
  AlignedStreamGetter(const size_t position,
                      const size_t length,
                      const size_t alignment,
                      U&& decoratee)
    : DecoratedStreamGetter(std::forward<U>(decoratee)),
      position(position),
      length(length),
      alignment(alignment) {
  }
  virtual ~AlignedStreamGetter();
  ssize_t get_at_most(size_t want, ceph::bufferlist& dst) override;
  ssize_t get_exactly(size_t want, ceph::bufferlist& dst) override;
};


struct RGWUsageStats {
  uint64_t bytes_used = 0;
  uint64_t bytes_used_rounded = 0;
  uint64_t buckets_count = 0;
  uint64_t objects_count = 0;
};



class RGWListBuckets : public RGWOp {
protected:
  bool sent_data;
  std::string marker;
  std::string end_marker;
  int64_t limit;
  uint64_t limit_max;
  std::map<std::string, ceph::bufferlist> attrs;
  bool is_truncated;

  RGWUsageStats global_stats;
  std::map<std::string, RGWUsageStats> policies_stats;

  virtual uint64_t get_default_max() const {
    return 1000;
  }

public:
  RGWListBuckets()
    : sent_data(false),
      limit(10000),
      limit_max(10000),
      is_truncated(false) {
  }

  int verify_permission() override;
  void execute() override;

  virtual int get_params() = 0;
  virtual void handle_listing_chunk(RGWUserBuckets&& buckets) {




    return send_response_data(buckets);
  }
  virtual void send_response_begin(bool has_buckets) = 0;
  virtual void send_response_data(RGWUserBuckets& buckets) = 0;
  virtual void send_response_end() = 0;
  void send_response() override {}

  virtual bool should_get_stats() { return false; }
  virtual bool supports_account_metadata() { return false; }

  const char* name() const override { return "list_buckets"; }
  RGWOpType get_type() override { return RGW_OP_LIST_BUCKETS; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWGetUsage : public RGWOp {
protected:
  bool sent_data;
  string start_date;
  string end_date;
  int show_log_entries;
  int show_log_sum;
  map<string, bool> categories;
  map<rgw_user_bucket, rgw_usage_log_entry> usage;
  map<string, rgw_usage_log_entry> summary_map;
  map<string, cls_user_bucket_entry> buckets_usage;
  cls_user_header header;
public:
  RGWGetUsage() : sent_data(false), show_log_entries(true), show_log_sum(true){
  }

  int verify_permission() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override {}

  virtual bool should_get_stats() { return false; }

  const char* name() const override { return "get_usage"; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWStatAccount : public RGWOp {
protected:
  RGWUsageStats global_stats;
  std::map<std::string, RGWUsageStats> policies_stats;

public:
  RGWStatAccount() = default;

  int verify_permission() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "stat_account"; }
  RGWOpType get_type() override { return RGW_OP_STAT_ACCOUNT; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWListBucket : public RGWOp {
protected:
  RGWBucketEnt bucket;
  string prefix;
  rgw_obj_key marker;
  rgw_obj_key next_marker;
  rgw_obj_key end_marker;
  string max_keys;
  string delimiter;
  string encoding_type;
  bool list_versions;
  int max;
  vector<rgw_bucket_dir_entry> objs;
  map<string, bool> common_prefixes;

  int default_max;
  bool is_truncated;
  bool allow_unordered;

  int shard_id;

  int parse_max_keys();

public:
  RGWListBucket() : list_versions(false), max(0),
                    default_max(0), is_truncated(false),
      allow_unordered(false), shard_id(-1) {}
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "list_bucket"; }
  RGWOpType get_type() override { return RGW_OP_LIST_BUCKET; }
  uint32_t op_mask() override { return 0x01; }
  virtual bool need_container_stats() { return false; }
};

class RGWGetBucketLogging : public RGWOp {
public:
  RGWGetBucketLogging() {}
  int verify_permission() override;
  void execute() override { }

  void send_response() override = 0;
  const char* name() const override { return "get_bucket_logging"; }
  RGWOpType get_type() override { return RGW_OP_GET_BUCKET_LOGGING; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWGetBucketLocation : public RGWOp {
public:
  RGWGetBucketLocation() {}
  ~RGWGetBucketLocation() override {}
  int verify_permission() override;
  void execute() override { }

  void send_response() override = 0;
  const char* name() const override { return "get_bucket_location"; }
  RGWOpType get_type() override { return RGW_OP_GET_BUCKET_LOCATION; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWGetBucketVersioning : public RGWOp {
protected:
  bool versioned{false};
  bool versioning_enabled{false};
  bool mfa_enabled{false};
public:
  RGWGetBucketVersioning() = default;

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "get_bucket_versioning"; }
  RGWOpType get_type() override { return RGW_OP_GET_BUCKET_VERSIONING; }
  uint32_t op_mask() override { return 0x01; }
};

enum BucketVersionStatus {
  VersioningStatusInvalid = -1,
  VersioningNotChanged = 0,
  VersioningEnabled = 1,
  VersioningSuspended =2,
};

class RGWSetBucketVersioning : public RGWOp {
protected:
  int versioning_status;
  bool mfa_set_status{false};
  bool mfa_status{false};
  bufferlist in_data;
public:
  RGWSetBucketVersioning() : versioning_status(VersioningNotChanged) {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() { return 0; }

  void send_response() override = 0;
  const char* name() const override { return "set_bucket_versioning"; }
  RGWOpType get_type() override { return RGW_OP_SET_BUCKET_VERSIONING; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWGetBucketWebsite : public RGWOp {
public:
  RGWGetBucketWebsite() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "get_bucket_website"; }
  RGWOpType get_type() override { return RGW_OP_GET_BUCKET_WEBSITE; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWSetBucketWebsite : public RGWOp {
protected:
  bufferlist in_data;
  RGWBucketWebsiteConf website_conf;
public:
  RGWSetBucketWebsite() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() { return 0; }

  void send_response() override = 0;
  const char* name() const override { return "set_bucket_website"; }
  RGWOpType get_type() override { return RGW_OP_SET_BUCKET_WEBSITE; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWDeleteBucketWebsite : public RGWOp {
public:
  RGWDeleteBucketWebsite() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "delete_bucket_website"; }
  RGWOpType get_type() override { return RGW_OP_SET_BUCKET_WEBSITE; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWStatBucket : public RGWOp {
protected:
  RGWBucketEnt bucket;

public:
  RGWStatBucket() {}
  ~RGWStatBucket() override {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "stat_bucket"; }
  RGWOpType get_type() override { return RGW_OP_STAT_BUCKET; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWCreateBucket : public RGWOp {
protected:
  RGWAccessControlPolicy policy;
  string location_constraint;
  rgw_placement_rule placement_rule;
  RGWBucketInfo info;
  obj_version ep_objv;
  bool has_cors;
  bool relaxed_region_enforcement;
  bool obj_lock_enabled;
  RGWCORSConfiguration cors_config;
  boost::optional<std::string> swift_ver_location;
  map<string, buffer::list> attrs;
  set<string> rmattr_names;

  bufferlist in_data;

  virtual bool need_metadata_upload() const { return false; }

public:
  RGWCreateBucket() : has_cors(false), relaxed_region_enforcement(false), obj_lock_enabled(false) {}

  void emplace_attr(std::string&& key, buffer::list&& bl) {
    attrs.emplace(std::move(key), std::move(bl));
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy.set_ctx(s->cct);
    relaxed_region_enforcement =
 s->cct->_conf.get_val<bool>("rgw_relaxed_region_enforcement");
  }
  virtual int get_params() { return 0; }
  void send_response() override = 0;
  const char* name() const override { return "create_bucket"; }
  RGWOpType get_type() override { return RGW_OP_CREATE_BUCKET; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWDeleteBucket : public RGWOp {
protected:
  RGWObjVersionTracker objv_tracker;

public:
  RGWDeleteBucket() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "delete_bucket"; }
  RGWOpType get_type() override { return RGW_OP_DELETE_BUCKET; }
  uint32_t op_mask() override { return 0x04; }
};

struct rgw_slo_entry {
  string path;
  string etag;
  uint64_t size_bytes;

  rgw_slo_entry() : size_bytes(0) {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(path, bl);
    encode(etag, bl);
    encode(size_bytes, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(path, bl);
     decode(etag, bl);
     decode(size_bytes, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  void decode_json(JSONObj *obj);
};
inline void encode(const rgw_slo_entry &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(rgw_slo_entry &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

struct RGWSLOInfo {
  vector<rgw_slo_entry> entries;
  uint64_t total_size;


  bufferlist raw_data;

  RGWSLOInfo() : total_size(0) {}
  ~RGWSLOInfo() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(entries, bl);
    encode(total_size, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
     __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
     decode(entries, bl);
     decode(total_size, bl);
     } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const RGWSLOInfo &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWSLOInfo &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class RGWPutObj : public RGWOp {
protected:
  seed torrent;
  off_t ofs;
  const char *supplied_md5_b64;
  const char *supplied_etag;
  const char *if_match;
  const char *if_nomatch;
  std::string copy_source;
  const char *copy_source_range;
  RGWBucketInfo copy_source_bucket_info;
  string copy_source_tenant_name;
  string copy_source_bucket_name;
  string copy_source_object_name;
  string copy_source_version_id;
  off_t copy_source_range_fst;
  off_t copy_source_range_lst;
  string etag;
  bool chunked_upload;
  RGWAccessControlPolicy policy;
  std::unique_ptr <RGWObjTags> obj_tags;
  const char *dlo_manifest;
  RGWSLOInfo *slo_info;
  map<string, bufferlist> attrs;
  ceph::real_time mtime;
  uint64_t olh_epoch;
  string version_id;
  bufferlist bl_aux;
  map<string, string> crypt_http_responses;
  string user_data;

  std::string multipart_upload_id;
  std::string multipart_part_str;
  int multipart_part_num = 0;

  boost::optional<ceph::real_time> delete_at;

  bool append;
  uint64_t position;
  uint64_t cur_accounted_size;


  RGWObjectRetention *obj_retention;
  RGWObjectLegalHold *obj_legal_hold;

public:
  RGWPutObj() : ofs(0),
                supplied_md5_b64(
# 1074 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                                __null
# 1074 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                    ),
                supplied_etag(
# 1075 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                             __null
# 1075 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                 ),
                if_match(
# 1076 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                        __null
# 1076 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                            ),
                if_nomatch(
# 1077 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                          __null
# 1077 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                              ),
                copy_source_range(
# 1078 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                                 __null
# 1078 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                     ),
                copy_source_range_fst(0),
                copy_source_range_lst(0),
                chunked_upload(0),
                dlo_manifest(
# 1082 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                            __null
# 1082 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                ),
                slo_info(
# 1083 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                        __null
# 1083 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                            ),
                olh_epoch(0),
                append(false),
                position(0),
                cur_accounted_size(0),
                obj_retention(nullptr),
                obj_legal_hold(nullptr) {}

  ~RGWPutObj() override {
    delete slo_info;
    delete obj_retention;
    delete obj_legal_hold;
  }

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy.set_ctx(s->cct);
  }

  void emplace_attr(std::string&& key, buffer::list&& bl) {
    attrs.emplace(std::move(key), std::move(bl));
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;


  virtual int get_decrypt_filter(std::unique_ptr<RGWGetObj_Filter>* filter,
                                 RGWGetObj_Filter* cb,
                                 map<string, bufferlist>& attrs,
                                 bufferlist* manifest_bl) {
    *filter = nullptr;
    return 0;
  }
  virtual int get_encrypt_filter(std::unique_ptr<rgw::putobj::DataProcessor> *filter,
                                 rgw::putobj::DataProcessor *cb) {
    return 0;
  }

  int get_data_cb(bufferlist& bl, off_t bl_ofs, off_t bl_len);
  int get_data(const off_t fst, const off_t lst, bufferlist& bl);

  virtual int get_params() = 0;
  virtual int get_data(bufferlist& bl) = 0;
  void send_response() override = 0;
  const char* name() const override { return "put_obj"; }
  RGWOpType get_type() override { return RGW_OP_PUT_OBJ; }
  uint32_t op_mask() override { return 0x02; }
  dmc::client_id dmclock_client() override { return dmc::client_id::data; }
};

class RGWPostObj : public RGWOp {
protected:
  off_t min_len;
  off_t max_len;
  int len;
  off_t ofs;
  const char *supplied_md5_b64;
  const char *supplied_etag;
  string etag;
  RGWAccessControlPolicy policy;
  map<string, bufferlist> attrs;
  boost::optional<ceph::real_time> delete_at;


  virtual std::string get_current_filename() const = 0;
  virtual std::string get_current_content_type() const = 0;
  virtual bool is_next_file_to_upload() {
     return false;
  }
public:
  RGWPostObj() : min_len(0),
                 max_len(0x7fffffffffffffffLL),
                 len(0),
                 ofs(0),
                 supplied_md5_b64(nullptr),
                 supplied_etag(nullptr) {
  }

  void emplace_attr(std::string&& key, buffer::list&& bl) {
    attrs.emplace(std::move(key), std::move(bl));
  }

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy.set_ctx(s->cct);
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_encrypt_filter(std::unique_ptr<rgw::putobj::DataProcessor> *filter,
                                 rgw::putobj::DataProcessor *cb) {
    return 0;
  }
  virtual int get_params() = 0;
  virtual int get_data(ceph::bufferlist& bl, bool& again) = 0;
  void send_response() override = 0;
  const char* name() const override { return "post_obj"; }
  RGWOpType get_type() override { return RGW_OP_POST_OBJ; }
  uint32_t op_mask() override { return 0x02; }
  dmc::client_id dmclock_client() override { return dmc::client_id::data; }
};

class RGWPutMetadataAccount : public RGWOp {
protected:
  std::set<std::string> rmattr_names;
  std::map<std::string, bufferlist> attrs, orig_attrs;
  std::map<int, std::string> temp_url_keys;
  RGWQuotaInfo new_quota;
  bool new_quota_extracted;

  RGWObjVersionTracker acct_op_tracker;

  RGWAccessControlPolicy policy;
  bool has_policy;

public:
  RGWPutMetadataAccount()
    : new_quota_extracted(false),
      has_policy(false) {
  }

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy.set_ctx(s->cct);
  }
  int init_processing() override;
  int verify_permission() override;
  void pre_exec() override { }
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  virtual void filter_out_temp_url(map<string, bufferlist>& add_attrs,
                                   const set<string>& rmattr_names,
                                   map<int, string>& temp_url_keys);
  const char* name() const override { return "put_account_metadata"; }
  RGWOpType get_type() override { return RGW_OP_PUT_METADATA_ACCOUNT; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWPutMetadataBucket : public RGWOp {
protected:
  map<string, buffer::list> attrs;
  set<string> rmattr_names;
  bool has_policy, has_cors;
  uint32_t policy_rw_mask;
  RGWAccessControlPolicy policy;
  RGWCORSConfiguration cors_config;
  rgw_placement_rule placement_rule;
  boost::optional<std::string> swift_ver_location;

public:
  RGWPutMetadataBucket()
    : has_policy(false), has_cors(false), policy_rw_mask(0)
  {}

  void emplace_attr(std::string&& key, buffer::list&& bl) {
    attrs.emplace(std::move(key), std::move(bl));
  }

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy.set_ctx(s->cct);
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "put_bucket_metadata"; }
  RGWOpType get_type() override { return RGW_OP_PUT_METADATA_BUCKET; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWPutMetadataObject : public RGWOp {
protected:
  RGWAccessControlPolicy policy;
  boost::optional<ceph::real_time> delete_at;
  const char *dlo_manifest;

public:
  RGWPutMetadataObject()
    : dlo_manifest(
# 1271 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                  __null
# 1271 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                      )
  {}

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy.set_ctx(s->cct);
  }
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "put_obj_metadata"; }
  RGWOpType get_type() override { return RGW_OP_PUT_METADATA_OBJECT; }
  uint32_t op_mask() override { return 0x02; }
  virtual bool need_object_expiration() { return false; }
};

class RGWDeleteObj : public RGWOp {
protected:
  bool delete_marker;
  bool multipart_delete;
  string version_id;
  ceph::real_time unmod_since;
  bool no_precondition_error;
  std::unique_ptr<RGWBulkDelete::Deleter> deleter;
  bool bypass_perm;
  bool bypass_governance_mode;

public:
  RGWDeleteObj()
    : delete_marker(false),
      multipart_delete(false),
      no_precondition_error(false),
      deleter(nullptr),
      bypass_perm(true),
      bypass_governance_mode(false) {
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  int handle_slo_manifest(bufferlist& bl);

  virtual int get_params() { return 0; }
  void send_response() override = 0;
  const char* name() const override { return "delete_obj"; }
  RGWOpType get_type() override { return RGW_OP_DELETE_OBJ; }
  uint32_t op_mask() override { return 0x04; }
  virtual bool need_object_expiration() { return false; }
  dmc::client_id dmclock_client() override { return dmc::client_id::data; }
};

class RGWCopyObj : public RGWOp {
protected:
  RGWAccessControlPolicy dest_policy;
  const char *if_mod;
  const char *if_unmod;
  const char *if_match;
  const char *if_nomatch;

  std::string_view copy_source;

  std::optional<std::string_view> md_directive;

  off_t ofs;
  off_t len;
  off_t end;
  ceph::real_time mod_time;
  ceph::real_time unmod_time;
  ceph::real_time *mod_ptr;
  ceph::real_time *unmod_ptr;
  map<string, buffer::list> attrs;
  string src_tenant_name, src_bucket_name;
  rgw_bucket src_bucket;
  rgw_obj_key src_object;
  string dest_tenant_name, dest_bucket_name;
  rgw_bucket dest_bucket;
  string dest_object;
  ceph::real_time src_mtime;
  ceph::real_time mtime;
  RGWRados::AttrsMod attrs_mod;
  RGWBucketInfo src_bucket_info;
  RGWBucketInfo dest_bucket_info;
  string source_zone;
  string etag;

  off_t last_ofs;

  string version_id;
  uint64_t olh_epoch;

  boost::optional<ceph::real_time> delete_at;
  bool copy_if_newer;

  bool need_to_check_storage_class = false;

  int init_common();

public:
  RGWCopyObj() {
    if_mod = 
# 1373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
            __null
# 1373 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                ;
    if_unmod = 
# 1374 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
              __null
# 1374 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                  ;
    if_match = 
# 1375 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
              __null
# 1375 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                  ;
    if_nomatch = 
# 1376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                __null
# 1376 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                    ;
    ofs = 0;
    len = 0;
    end = -1;
    mod_ptr = 
# 1380 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
             __null
# 1380 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                 ;
    unmod_ptr = 
# 1381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               __null
# 1381 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                   ;
    attrs_mod = RGWRados::ATTRSMOD_NONE;
    last_ofs = 0;
    olh_epoch = 0;
    copy_if_newer = false;
  }

  static bool parse_copy_location(const boost::string_view& src,
                                  string& bucket_name,
                                  rgw_obj_key& object);

  void emplace_attr(std::string&& key, buffer::list&& bl) {
    attrs.emplace(std::move(key), std::move(bl));
  }

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    dest_policy.set_ctx(s->cct);
  }
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  void progress_cb(off_t ofs);

  virtual int check_storage_class(const rgw_placement_rule& src_placement) {
    return 0;
  }

  virtual int init_dest_policy() { return 0; }
  virtual int get_params() = 0;
  virtual void send_partial_response(off_t ofs) {}
  void send_response() override = 0;
  const char* name() const override { return "copy_obj"; }
  RGWOpType get_type() override { return RGW_OP_COPY_OBJ; }
  uint32_t op_mask() override { return 0x02; }
  dmc::client_id dmclock_client() override { return dmc::client_id::data; }
};

class RGWGetACLs : public RGWOp {
protected:
  string acls;

public:
  RGWGetACLs() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "get_acls"; }
  RGWOpType get_type() override { return RGW_OP_GET_ACLS; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWPutACLs : public RGWOp {
protected:
  bufferlist data;
  ACLOwner owner;

public:
  RGWPutACLs() {}
  ~RGWPutACLs() override {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_policy_from_state(RGWRados *store, struct req_state *s, stringstream& ss) { return 0; }
  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "put_acls"; }
  RGWOpType get_type() override { return RGW_OP_PUT_ACLS; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWGetLC : public RGWOp {
protected:

public:
  RGWGetLC() { }
  ~RGWGetLC() override { }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override = 0;

  void send_response() override = 0;
  const char* name() const override { return "get_lifecycle"; }
  RGWOpType get_type() override { return RGW_OP_GET_LC; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWPutLC : public RGWOp {
protected:
  bufferlist data;
  const char *content_md5;
  string cookie;

public:
  RGWPutLC() {
    content_md5 = nullptr;
  }
  ~RGWPutLC() override {}

  void init(RGWRados *store, struct req_state *s, RGWHandler *dialect_handler) override {

    char buf[16 + 1];

    RGWOp::init(store, s, dialect_handler);
    gen_rand_alphanumeric(s->cct, buf, sizeof(buf) - 1);
    cookie = buf;
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;


  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "put_lifecycle"; }
  RGWOpType get_type() override { return RGW_OP_PUT_LC; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWDeleteLC : public RGWOp {
protected:
  size_t len;
  char *data;

public:
  RGWDeleteLC() {
    len = 0;
    data = 
# 1515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
          __null
# 1515 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
              ;
  }
  ~RGWDeleteLC() override {
    free(data);
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "delete_lifecycle"; }
  RGWOpType get_type() override { return RGW_OP_DELETE_LC; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWGetCORS : public RGWOp {
protected:

public:
  RGWGetCORS() {}

  int verify_permission() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "get_cors"; }
  RGWOpType get_type() override { return RGW_OP_GET_CORS; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWPutCORS : public RGWOp {
protected:
  bufferlist cors_bl;
  bufferlist in_data;

public:
  RGWPutCORS() {}
  ~RGWPutCORS() override {}

  int verify_permission() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "put_cors"; }
  RGWOpType get_type() override { return RGW_OP_PUT_CORS; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWDeleteCORS : public RGWOp {
protected:

public:
  RGWDeleteCORS() {}

  int verify_permission() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "delete_cors"; }
  RGWOpType get_type() override { return RGW_OP_DELETE_CORS; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWOptionsCORS : public RGWOp {
protected:
  RGWCORSRule *rule;
  const char *origin, *req_hdrs, *req_meth;

public:
  RGWOptionsCORS() : rule(
# 1586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                         __null
# 1586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                             ), origin(
# 1586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                                       __null
# 1586 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                           ),
                     req_hdrs(
# 1587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                             __null
# 1587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                 ), req_meth(
# 1587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                                             __null
# 1587 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                                 ) {
  }

  int verify_permission() override {return 0;}
  int validate_cors_request(RGWCORSConfiguration *cc);
  void execute() override;
  void get_response_params(string& allowed_hdrs, string& exp_hdrs, unsigned *max_age);
  void send_response() override = 0;
  const char* name() const override { return "options_cors"; }
  RGWOpType get_type() override { return RGW_OP_OPTIONS_CORS; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWGetRequestPayment : public RGWOp {
protected:
  bool requester_pays;

public:
  RGWGetRequestPayment() : requester_pays(0) {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "get_request_payment"; }
  RGWOpType get_type() override { return RGW_OP_GET_REQUEST_PAYMENT; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWSetRequestPayment : public RGWOp {
protected:
  bool requester_pays;
  bufferlist in_data;
public:
 RGWSetRequestPayment() : requester_pays(false) {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() { return 0; }

  void send_response() override = 0;
  const char* name() const override { return "set_request_payment"; }
  RGWOpType get_type() override { return RGW_OP_SET_REQUEST_PAYMENT; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWInitMultipart : public RGWOp {
protected:
  string upload_id;
  RGWAccessControlPolicy policy;

public:
  RGWInitMultipart() {}

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy.set_ctx(s->cct);
  }
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "init_multipart"; }
  RGWOpType get_type() override { return RGW_OP_INIT_MULTIPART; }
  uint32_t op_mask() override { return 0x02; }
  virtual int prepare_encryption(map<string, bufferlist>& attrs) { return 0; }
};

class RGWCompleteMultipart : public RGWOp {
protected:
  string upload_id;
  string etag;
  string version_id;
  bufferlist data;

  struct MPSerializer {
    librados::IoCtx ioctx;
    rados::cls::lock::Lock lock;
    librados::ObjectWriteOperation op;
    std::string oid;
    bool locked;

    MPSerializer() : lock("RGWCompleteMultipart"), locked(false)
      {}

    int try_lock(const std::string& oid, utime_t dur);

    int unlock() {
      return lock.unlock(&ioctx, oid);
    }

    void clear_locked() {
      locked = false;
    }
  } serializer;

public:
  RGWCompleteMultipart() {}
  ~RGWCompleteMultipart() override {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  void complete() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "complete_multipart"; }
  RGWOpType get_type() override { return RGW_OP_COMPLETE_MULTIPART; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWAbortMultipart : public RGWOp {
public:
  RGWAbortMultipart() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  void send_response() override = 0;
  const char* name() const override { return "abort_multipart"; }
  RGWOpType get_type() override { return RGW_OP_ABORT_MULTIPART; }
  uint32_t op_mask() override { return 0x04; }
};

class RGWListMultipart : public RGWOp {
protected:
  string upload_id;
  map<uint32_t, RGWUploadPartInfo> parts;
  int max_parts;
  int marker;
  RGWAccessControlPolicy policy;
  bool truncated;

public:
  RGWListMultipart() {
    max_parts = 1000;
    marker = 0;
    truncated = false;
  }

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    policy = RGWAccessControlPolicy(s->cct);
  }
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "list_multipart"; }
  RGWOpType get_type() override { return RGW_OP_LIST_MULTIPART; }
  uint32_t op_mask() override { return 0x01; }
};

struct RGWMultipartUploadEntry {
  rgw_bucket_dir_entry obj;
  RGWMPObj mp;
};

class RGWListBucketMultiparts : public RGWOp {
protected:
  string prefix;
  RGWMPObj marker;
  RGWMultipartUploadEntry next_marker;
  int max_uploads;
  string delimiter;
  vector<RGWMultipartUploadEntry> uploads;
  map<string, bool> common_prefixes;
  bool is_truncated;
  int default_max;

public:
  RGWListBucketMultiparts() {
    max_uploads = 0;
    is_truncated = false;
    default_max = 0;
  }

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
    max_uploads = default_max;
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "list_bucket_multiparts"; }
  RGWOpType get_type() override { return RGW_OP_LIST_BUCKET_MULTIPARTS; }
  uint32_t op_mask() override { return 0x01; }
};


class RGWGetCrossDomainPolicy : public RGWOp {
public:
  RGWGetCrossDomainPolicy() = default;
  ~RGWGetCrossDomainPolicy() override = default;

  int verify_permission() override {
    return 0;
  }

  void execute() override {
    op_ret = 0;
  }

  const char* name() const override { return "get_crossdomain_policy"; }

  RGWOpType get_type() override {
    return RGW_OP_GET_CROSS_DOMAIN_POLICY;
  }

  uint32_t op_mask() override {
    return 0x01;
  }
};


class RGWGetHealthCheck : public RGWOp {
public:
  RGWGetHealthCheck() = default;
  ~RGWGetHealthCheck() override = default;

  int verify_permission() override {
    return 0;
  }

  void execute() override;

  const char* name() const override { return "get_health_check"; }

  RGWOpType get_type() override {
    return RGW_OP_GET_HEALTH_CHECK;
  }

  uint32_t op_mask() override {
    return 0x01;
  }
};


class RGWDeleteMultiObj : public RGWOp {
protected:
  bufferlist data;
  rgw_bucket bucket;
  bool quiet;
  bool status_dumped;
  bool acl_allowed = false;

public:
  RGWDeleteMultiObj() {
    quiet = false;
    status_dumped = false;
  }
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  virtual void send_status() = 0;
  virtual void begin_response() = 0;
  virtual void send_partial_response(rgw_obj_key& key, bool delete_marker,
                                     const string& marker_version_id, int ret) = 0;
  virtual void end_response() = 0;
  const char* name() const override { return "multi_object_delete"; }
  RGWOpType get_type() override { return RGW_OP_DELETE_MULTI_OBJ; }
  uint32_t op_mask() override { return 0x04; }
};

class RGWInfo: public RGWOp {
public:
  RGWInfo() = default;
  ~RGWInfo() override = default;

  int verify_permission() override { return 0; }
  const char* name() const override { return "get info"; }
  RGWOpType get_type() override { return RGW_OP_GET_INFO; }
  uint32_t op_mask() override { return 0x01; }
};

extern int rgw_build_bucket_policies(RGWRados* store, struct req_state* s);
extern int rgw_build_object_policies(RGWRados *store, struct req_state *s,
         bool prefetch_data);
extern void rgw_build_iam_environment(RGWRados* store,
                                struct req_state* s);
extern vector<rgw::IAM::Policy> get_iam_user_policy_from_attr(CephContext* cct,
                        RGWRados* store,
                        map<string, bufferlist>& attrs,
                        const string& tenant);

static inline int get_system_versioning_params(req_state *s,
           uint64_t *olh_epoch,
           string *version_id)
{
  if (!s->system_request) {
    return 0;
  }

  if (olh_epoch) {
    string epoch_str = s->info.args.get("rgwx-" "versioned-epoch");
    if (!epoch_str.empty()) {
      string err;
      *olh_epoch = strict_strtol(epoch_str.c_str(), 10, &err);
      if (!err.empty()) {
        do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(0)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 0); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 0>()); } }(s->cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(0, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*s->cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = s->cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "failed to parse versioned-epoch param"
     << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
        return -
# 1903 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               22
# 1903 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                     ;
      }
    }
  }

  if (version_id) {
    *version_id = s->info.args.get("rgwx-" "version-id");
  }

  return 0;
}

static inline void format_xattr(std::string &xattr)
{



  if ((check_utf8(xattr.c_str(), xattr.length()) != 0) ||
      (check_for_control_characters(xattr.c_str(), xattr.length()) != 0)) {
    static const char MIME_PREFIX_STR[] = "=?UTF-8?Q?";
    static const int MIME_PREFIX_LEN = sizeof(MIME_PREFIX_STR) - 1;
    static const char MIME_SUFFIX_STR[] = "?=";
    static const int MIME_SUFFIX_LEN = sizeof(MIME_SUFFIX_STR) - 1;
    int mlen = mime_encode_as_qp(xattr.c_str(), 
# 1926 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                                               __null
# 1926 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                                   , 0);
    char *mime = new char[MIME_PREFIX_LEN + mlen + MIME_SUFFIX_LEN + 1];
    strcpy(mime, MIME_PREFIX_STR);
    mime_encode_as_qp(xattr.c_str(), mime + MIME_PREFIX_LEN, mlen);
    strcpy(mime + MIME_PREFIX_LEN + (mlen - 1), MIME_SUFFIX_STR);
    xattr.assign(mime);
    delete [] mime;
  }
}
# 1945 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
static inline int rgw_get_request_metadata(CephContext* const cct,
                                           struct req_info& info,
                                           std::map<std::string, ceph::bufferlist>& attrs,
                                           const bool allow_empty_attrs = true)
{
  static const std::set<std::string> blacklisted_headers = {
      "x-amz-server-side-encryption-customer-algorithm",
      "x-amz-server-side-encryption-customer-key",
      "x-amz-server-side-encryption-customer-key-md5",
      "x-amz-storage-class"
  };

  size_t valid_meta_count = 0;
  for (auto& kv : info.x_meta_map) {
    const std::string& name = kv.first;
    std::string& xattr = kv.second;

    if (blacklisted_headers.count(name) == 1) {
      do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "skipping x>> " << name << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
      continue;
    } else if (allow_empty_attrs || !xattr.empty()) {
      do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 10); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 10>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "x>> " << name << ":" << xattr << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
      format_xattr(xattr);

      std::string attr_name("user.rgw.");
      attr_name.append(name);





      const auto max_attr_name_len = cct->_conf->rgw_max_attr_name_len;
      if (max_attr_name_len && attr_name.length() > max_attr_name_len) {
        return -
# 1978 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               36
# 1978 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                           ;
      }



      const auto max_attr_size = cct->_conf->rgw_max_attr_size;
      if (max_attr_size && xattr.length() > max_attr_size) {
        return -
# 1985 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               27
# 1985 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                    ;
      }



      const auto max_attrs_num_in_req = cct->_conf->rgw_max_attrs_num_in_req;
      if (max_attrs_num_in_req &&
          ++valid_meta_count > max_attrs_num_in_req) {
        return -
# 1993 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               7
# 1993 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                    ;
      }

      auto rval = attrs.emplace(std::move(attr_name), ceph::bufferlist());



      ceph::bufferlist& bl = rval.first->second;
      bl.append(xattr.c_str(), xattr.size() + 1);
    }
  }

  return 0;
}

static inline void encode_delete_at_attr(boost::optional<ceph::real_time> delete_at,
     map<string, bufferlist>& attrs)
{
  if (delete_at == boost::none) {
    return;
  }

  bufferlist delatbl;
  encode(*delete_at, delatbl);
  attrs["user.rgw." "delete_at"] = delatbl;
}

static inline void encode_obj_tags_attr(RGWObjTags* obj_tags, map<string, bufferlist>& attrs)
{
  if (obj_tags == nullptr){



    return;
  }

  bufferlist tagsbl;
  obj_tags->encode(tagsbl);
  attrs["user.rgw." "x-amz-" "tagging"] = tagsbl;
}

static inline int encode_dlo_manifest_attr(const char * const dlo_manifest,
       map<string, bufferlist>& attrs)
{
  string dm = dlo_manifest;

  if (dm.find('/') == string::npos) {
    return -
# 2040 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
           22
# 2040 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                 ;
  }

  bufferlist manifest_bl;
  manifest_bl.append(dlo_manifest, strlen(dlo_manifest) + 1);
  attrs["user.rgw." "user_manifest"] = manifest_bl;

  return 0;
}

static inline void complete_etag(MD5& hash, string *etag)
{
  char etag_buf[16];
  char etag_buf_str[16 * 2 + 16];

  hash.Final((unsigned char *)etag_buf);
  buf_to_hex((const unsigned char *)etag_buf, 16,
     etag_buf_str);

  *etag = etag_buf_str;
}

class RGWSetAttrs : public RGWOp {
protected:
  map<string, buffer::list> attrs;

public:
  RGWSetAttrs() {}
  ~RGWSetAttrs() override {}

  void emplace_attr(std::string&& key, buffer::list&& bl) {
    attrs.emplace(std::move(key), std::move(bl));
  }

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  void send_response() override = 0;
  const char* name() const override { return "set_attrs"; }
  RGWOpType get_type() override { return RGW_OP_SET_ATTRS; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWGetObjLayout : public RGWOp {
protected:
  RGWObjManifest *manifest{nullptr};
  rgw_raw_obj head_obj;

public:
  RGWGetObjLayout() {
  }

  int check_caps(RGWUserCaps& caps) {
    return caps.check_cap("admin", 0x1);
  }
  int verify_permission() override {
    return check_caps(s->user->caps);
  }
  void pre_exec() override;
  void execute() override;

  const char* name() const override { return "get_obj_layout"; }
  virtual RGWOpType get_type() override { return RGW_OP_GET_OBJ_LAYOUT; }
  virtual uint32_t op_mask() override { return 0x01; }
};

class RGWPutBucketPolicy : public RGWOp {
  bufferlist data;
public:
  RGWPutBucketPolicy() = default;
  ~RGWPutBucketPolicy() {
  }
  void send_response() override;
  int verify_permission() override;
  uint32_t op_mask() override {
    return 0x02;
  }
  void execute() override;
  int get_params();
  const char* name() const override { return "put_bucket_policy"; }
  RGWOpType get_type() override {
    return RGW_OP_PUT_BUCKET_POLICY;
  }
};

class RGWGetBucketPolicy : public RGWOp {
  buffer::list policy;
public:
  RGWGetBucketPolicy() = default;
  void send_response() override;
  int verify_permission() override;
  uint32_t op_mask() override {
    return 0x01;
  }
  void execute() override;
  const char* name() const override { return "get_bucket_policy"; }
  RGWOpType get_type() override {
    return RGW_OP_GET_BUCKET_POLICY;
  }
};

class RGWDeleteBucketPolicy : public RGWOp {
public:
  RGWDeleteBucketPolicy() = default;
  void send_response() override;
  int verify_permission() override;
  uint32_t op_mask() override {
    return 0x02;
  }
  void execute() override;
  int get_params();
  const char* name() const override { return "delete_bucket_policy"; }
  RGWOpType get_type() override {
    return RGW_OP_DELETE_BUCKET_POLICY;
  }
};

class RGWPutBucketObjectLock : public RGWOp {
protected:
  bufferlist data;
  bufferlist obj_lock_bl;
  RGWObjectLock obj_lock;
public:
  RGWPutBucketObjectLock() = default;
  ~RGWPutBucketObjectLock() {}
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  virtual void send_response() = 0;
  virtual int get_params() = 0;
  const char* name() const override { return "put_bucket_object_lock"; }
  RGWOpType get_type() override { return RGW_OP_PUT_BUCKET_OBJ_LOCK; }
  uint32_t op_mask() override { return 0x02; }
};

class RGWGetBucketObjectLock : public RGWOp {
public:
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  virtual void send_response() = 0;
  const char* name() const override {return "get_bucket_object_lock"; }
  RGWOpType get_type() override { return RGW_OP_GET_BUCKET_OBJ_LOCK; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWPutObjRetention : public RGWOp {
protected:
  bufferlist data;
  RGWObjectRetention obj_retention;
  bool bypass_perm;
  bool bypass_governance_mode;
public:
  RGWPutObjRetention():bypass_perm(true), bypass_governance_mode(false) {}
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  virtual void send_response() override = 0;
  virtual int get_params() = 0;
  const char* name() const override { return "put_obj_retention"; }
  uint32_t op_mask() override { return 0x02; }
  RGWOpType get_type() override { return RGW_OP_PUT_OBJ_RETENTION; }
};

class RGWGetObjRetention : public RGWOp {
protected:
  RGWObjectRetention obj_retention;
public:
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  virtual void send_response() = 0;
  const char* name() const override {return "get_obj_retention"; }
  RGWOpType get_type() override { return RGW_OP_GET_OBJ_RETENTION; }
  uint32_t op_mask() override { return 0x01; }
};

class RGWPutObjLegalHold : public RGWOp {
protected:
  bufferlist data;
  RGWObjectLegalHold obj_legal_hold;
public:
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  virtual void send_response() override = 0;
  virtual int get_params() = 0;
  const char* name() const override { return "put_obj_legal_hold"; }
  uint32_t op_mask() override { return 0x02; }
  RGWOpType get_type() override { return RGW_OP_PUT_OBJ_LEGAL_HOLD; }
};

class RGWGetObjLegalHold : public RGWOp {
protected:
  RGWObjectLegalHold obj_legal_hold;
public:
  int verify_permission() override;
  void pre_exec() override;
  void execute() override;
  virtual void send_response() = 0;
  const char* name() const override {return "get_obj_legal_hold"; }
  RGWOpType get_type() override { return RGW_OP_GET_OBJ_LEGAL_HOLD; }
  uint32_t op_mask() override { return 0x01; }
};


class RGWConfigBucketMetaSearch : public RGWOp {
protected:
  std::map<std::string, uint32_t> mdsearch_config;
public:
  RGWConfigBucketMetaSearch() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  virtual int get_params() = 0;
  const char* name() const override { return "config_bucket_meta_search"; }
  virtual RGWOpType get_type() override { return RGW_OP_CONFIG_BUCKET_META_SEARCH; }
  virtual uint32_t op_mask() override { return 0x02; }
};

class RGWGetBucketMetaSearch : public RGWOp {
public:
  RGWGetBucketMetaSearch() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override {}

  const char* name() const override { return "get_bucket_meta_search"; }
  virtual RGWOpType get_type() override { return RGW_OP_GET_BUCKET_META_SEARCH; }
  virtual uint32_t op_mask() override { return 0x01; }
};

class RGWDelBucketMetaSearch : public RGWOp {
public:
  RGWDelBucketMetaSearch() {}

  int verify_permission() override;
  void pre_exec() override;
  void execute() override;

  const char* name() const override { return "delete_bucket_meta_search"; }
  virtual RGWOpType delete_type() { return RGW_OP_DEL_BUCKET_META_SEARCH; }
  virtual uint32_t op_mask() override { return 0x02; }
};

class RGWGetClusterStat : public RGWOp {
protected:
  struct rados_cluster_stat_t stats_op;
public:
  RGWGetClusterStat() {}

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWOp::init(store, s, h);
  }
  int verify_permission() override {return 0;}
  virtual void send_response() override = 0;
  virtual int get_params() = 0;
  void execute() override;
  const char* name() const override { return "get_cluster_stat"; }
  dmc::client_id dmclock_client() override { return dmc::client_id::admin; }
};

static inline int parse_value_and_bound(
    const string &input,
    int &output,
    const long lower_bound,
    const long upper_bound,
    const long default_val)
{
  if (!input.empty()) {
    char *endptr;
    output = strtol(input.c_str(), &endptr, 10);
    if (endptr) {
      if (endptr == input.c_str()) return -
# 2318 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
                                          22
# 2318 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                                                ;
      while (*endptr && isspace(*endptr))
        endptr++;
      if (*endptr) {
        return -
# 2322 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h" 3 4
               22
# 2322 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_op.h"
                     ;
      }
    }
    if(output > upper_bound) {
      output = upper_bound;
    }
    if(output < lower_bound) {
      output = lower_bound;
    }
  } else {
    output = default_val;
  }

  return 0;
}
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/sstring.hh" 1
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/common/sstring.hh"
template <typename char_type, typename Size, Size max_size>
class basic_sstring;

using sstring = basic_sstring<char, uint32_t, 15>;

template <typename string_type = sstring, typename T>
inline string_type to_sstring(T value);

template <typename char_type, typename Size, Size max_size>
class basic_sstring {
    static_assert(
            (std::is_same<char_type, char>::value
             || std::is_same<char_type, signed char>::value
             || std::is_same<char_type, unsigned char>::value),
            "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 {
        return is_internal() ? u.internal.str : u.external.str;
    }
    char_type* str() {
        return is_internal() ? u.internal.str : u.external.str;
    }

    template <typename string_type, typename T>
    static inline string_type to_sstring_sprintf(T value, const char* fmt) {
        char tmp[sizeof(value) * 3 + 2];
        auto len = std::sprintf(tmp, fmt, value);
        using ch_type = typename string_type::value_type;
        return string_type(reinterpret_cast<ch_type*>(tmp), len);
    }

    template <typename string_type>
    static inline string_type to_sstring(int value) {
        return to_sstring_sprintf<string_type>(value, "%d");
    }

    template <typename string_type>
    static inline string_type to_sstring(unsigned value) {
        return to_sstring_sprintf<string_type>(value, "%u");
    }

    template <typename string_type>
    static inline string_type to_sstring(long value) {
        return to_sstring_sprintf<string_type>(value, "%ld");
    }

    template <typename string_type>
    static inline string_type to_sstring(unsigned long value) {
        return to_sstring_sprintf<string_type>(value, "%lu");
    }

    template <typename string_type>
    static inline string_type to_sstring(long long value) {
        return to_sstring_sprintf<string_type>(value, "%lld");
    }

    template <typename string_type>
    static inline string_type to_sstring(unsigned long long value) {
        return to_sstring_sprintf<string_type>(value, "%llu");
    }

    template <typename string_type>
    static inline string_type to_sstring(float value) {
        return to_sstring_sprintf<string_type>(value, "%g");
    }

    template <typename string_type>
    static inline string_type to_sstring(double value) {
        return to_sstring_sprintf<string_type>(value, "%g");
    }

    template <typename string_type>
    static inline string_type to_sstring(long double value) {
        return to_sstring_sprintf<string_type>(value, "%Lg");
    }

    template <typename string_type>
    static inline string_type to_sstring(const char* value) {
        return string_type(value);
    }

    template <typename string_type>
    static inline string_type to_sstring(sstring value) {
        return value;
    }

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);
public:
    struct initialized_later {};

    basic_sstring() noexcept {
        u.internal.size = 0;
        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 + 1));
            if (!u.external.str) {
                throw std::bad_alloc();
            }
            std::copy(x.u.external.str, x.u.external.str + x.u.external.size + 1, u.external.str);
            u.external.size = x.u.external.size;
        }
    }
    basic_sstring(basic_sstring&& x) noexcept {
        u = x.u;
        x.u.internal.size = 0;
        x.u.internal.str[0] = '\0';
    }
    basic_sstring(initialized_later, size_t size) {
        if (size_type(size) != size) {
            throw std::overflow_error("sstring overflow");
        }
        if (size + 1 <= sizeof(u.internal.str)) {
            u.internal.str[size] = '\0';
            u.internal.size = size;
        } else {
            u.internal.size = -1;
            u.external.str = reinterpret_cast<char_type*>(std::malloc(size + 1));
            if (!u.external.str) {
                throw std::bad_alloc();
            }
            u.external.size = size;
            u.external.str[size] = '\0';
        }
    }
    basic_sstring(const char_type* x, size_t size) {
        if (size_type(size) != size) {
            throw std::overflow_error("sstring overflow");
        }
        if (size + 1 <= sizeof(u.internal.str)) {
            std::copy(x, x + size, u.internal.str);
            u.internal.str[size] = '\0';
            u.internal.size = size;
        } else {
            u.internal.size = -1;
            u.external.str = reinterpret_cast<char_type*>(std::malloc(size + 1));
            if (!u.external.str) {
                throw std::bad_alloc();
            }
            u.external.size = size;
            std::copy(x, x + size, u.external.str);
            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());
    }
    ~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) {
            swap(x);
            x.reset();
        }
        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 basic_sstring& s, size_t pos = 0) const noexcept {
        const char_type* it = str() + pos;
        const char_type* end = str() + size();
        const char_type* c_str = s.str();
        const char_type* c_str_end = s.str() + s.size();

        while (it < end) {
            auto i = it;
            auto j = c_str;
            while ( i < end && j < c_str_end && *i == *j) {
                i++;
                j++;
            }
            if (j == c_str_end) {
                return it - str();
            }
            it++;
        }
        return npos;
    }







    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;
    }





    basic_sstring& replace(size_type pos, size_type n1, const char_type* s,
             size_type n2) {
        if (pos > size()) {
            throw std::out_of_range("sstring::replace 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()) {
            throw std::out_of_range("sstring::replace 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
    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()) {
            throw std::out_of_range("sstring::substr 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()) {
            throw std::out_of_range("sstring::at out of range");
        }
        return *(str() + pos);
    }

    char_type& at(size_t pos) {
        if (pos >= size()) {
            throw std::out_of_range("sstring::at out of range");
        }
        return *(str() + pos);
    }

    bool empty() const noexcept {
        return u.internal.size == 0;
    }
    void reset() noexcept {
        if (is_external()) {
            std::free(u.external.str);
        }
        u.internal.size = 0;
        u.internal.str[0] = '\0';
    }

    int compare(const basic_sstring& 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, const basic_sstring& x) const {
        if (pos > size()) {
            throw std::out_of_range("pos larger than string size");
        }

        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;
        }
    }

    void swap(basic_sstring& x) noexcept {
        contents tmp;
        tmp = x.u;
        x.u = u;
        u = tmp;
    }
    const char_type* c_str() const {
        return str();
    }
    const char_type* begin() const { return str(); }
    const char_type* end() const { return str() + size(); }
    const char_type* cbegin() const { return str(); }
    const char_type* cend() const { return str() + size(); }
    char_type* begin() { return str(); }
    char_type* end() { return str() + size(); }
    bool operator==(const basic_sstring& x) const {
        return size() == x.size() && std::equal(begin(), end(), x.begin());
    }
    bool operator!=(const basic_sstring& x) const {
        return !operator==(x);
    }
    bool operator<(const basic_sstring& x) const {
        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) {
        return str()[pos];
    }
    const char_type& operator[](size_type pos) const {
        return str()[pos];
    }
    operator boost::basic_string_view<char_type, traits_type>() const {
  return boost::basic_string_view<char_type, traits_type>(str(), size());
    }
    template <typename string_type, typename T>
    friend inline string_type to_sstring(T value);
};
template <typename char_type, typename Size, Size max_size>
constexpr Size basic_sstring<char_type, Size, max_size>::npos;

template <typename char_type, typename size_type, size_type Max, size_type N>
inline
basic_sstring<char_type, size_type, Max>
operator+(const char(&s)[N], const basic_sstring<char_type, size_type, Max>& t) {
    using sstring = basic_sstring<char_type, size_type, Max>;

    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 <size_t N>
static inline
size_t str_len(const char(&s)[N]) { return N - 1; }

template <size_t N>
static inline
const char* str_begin(const char(&s)[N]) { return s; }

template <size_t N>
static inline
const char* str_end(const char(&s)[N]) { return str_begin(s) + str_len(s); }

template <typename char_type, typename size_type, size_type max_size>
static inline
const char_type* str_begin(const basic_sstring<char_type, size_type, max_size>& s) { return s.begin(); }

template <typename char_type, typename size_type, size_type max_size>
static inline
const char_type* str_end(const basic_sstring<char_type, size_type, max_size>& s) { return s.end(); }

template <typename char_type, typename size_type, size_type max_size>
static inline
size_type str_len(const basic_sstring<char_type, size_type, max_size>& s) { return s.size(); }

template <typename First, typename Second, typename... Tail>
static inline
size_t str_len(const First& first, const Second& second, const Tail&... tail) {
    return str_len(first) + str_len(second, tail...);
}

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, 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>& s) {
    return os.write(s.begin(), s.size());
}

template <typename char_type, typename size_type, size_type max_size, 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>& s) {
    std::string tmp;
    is >> tmp;
    s = tmp;
    return is;
}

namespace std {

template <typename char_type, typename size_type, size_type max_size>
struct hash<basic_sstring<char_type, size_type, max_size>> {
    size_t operator()(const basic_sstring<char_type, size_type, max_size>& s) const {
  using traits_type = std::char_traits<char_type>;
  return std::hash<boost::basic_string_view<char_type,traits_type>>()(s);
    }
};

}

static inline
char* copy_str_to(char* dst) {
    return dst;
}

template <typename Head, typename... Tail>
static inline
char* copy_str_to(char* dst, const Head& head, const Tail&... tail) {
    return copy_str_to(std::copy(str_begin(head), str_end(head), dst), tail...);
}

template <typename String = sstring, typename... Args>
static String make_sstring(Args&&... args)
{
    String ret(sstring::initialized_later(), str_len(args...));
    copy_str_to(ret.begin(), args...);
    return ret;
}

template <typename string_type, typename T>
inline string_type to_sstring(T value) {
    return sstring::to_sstring<string_type>(value);
}



template <typename Char, typename Size, Size Max>
struct denc_traits<basic_sstring<Char, Size, Max>> {
private:
  using value_type = basic_sstring<Char, Size, Max>;
public:
  static constexpr bool supported = true;
  static constexpr bool featured = false;
  static constexpr bool bounded = false;

  static void bound_encode(const value_type& s, size_t& p, uint64_t f=0) {
    p += sizeof(Size) + s.size();
  }

  static void encode_nohead(const value_type& s,
                            buffer::list::contiguous_appender& p)
  {
    auto len = s.size();
    if (len) {
      p.append(reinterpret_cast<const char*>(s.c_str()), len);
    }
  }

  static void decode_nohead(size_t len, value_type& s,
                            buffer::ptr::const_iterator& p)
  {
    s.reset();
    if (len) {
      s.append(reinterpret_cast<const Char*>(p.get_pos_add(len)), len);
    }
  }

  static void encode(const value_type& s,
                     buffer::list::contiguous_appender& p,
                     uint64_t f=0)
  {
    Size len = (Size)(s.size());
    ::denc(len, p);
    if (len) {
      p.append(reinterpret_cast<const char*>(s.c_str()), len);
    }
  }

  static void decode(value_type& s,
                     buffer::ptr::const_iterator& p,
                     uint64_t f=0)
  {
    Size len;
    ::denc(len, p);
    decode_nohead(len, s, p);
  }
};
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 2




# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h"
# 1 "/usr/include/c++/10/stdlib.h" 1 3
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h" 2
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h"
class RGWRestfulIO;

namespace rgw {
namespace io {

using Exception = std::system_error;



class BasicClient {
protected:
  virtual int init_env(CephContext *cct) = 0;

public:
  virtual ~BasicClient() = default;


  int init(CephContext *cct);



  virtual RGWEnv& get_env() noexcept = 0;




  virtual size_t complete_request() = 0;
};


class Accounter {
public:
  virtual ~Accounter() = default;



  virtual void set_account(bool enabled) = 0;




  virtual uint64_t get_bytes_sent() const = 0;




  virtual uint64_t get_bytes_received() const = 0;
};
# 88 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h"
class RestfulClient : public BasicClient {
  template<typename T> friend class DecoratedRestfulClient;

public:



  virtual size_t send_100_continue() = 0;





  virtual size_t send_status(int status, const char *status_name) = 0;





  virtual size_t send_header(const boost::string_ref& name,
                             const boost::string_ref& value) = 0;
# 117 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h"
  virtual size_t send_content_length(uint64_t len) = 0;
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h"
  virtual size_t send_chunked_transfer_encoding() {



    return 0;
  }





  virtual size_t complete_header() = 0;





  virtual size_t recv_body(char* buf, size_t max) = 0;




  virtual size_t send_body(const char* buf, size_t len) = 0;



  virtual void flush() = 0;
} ;




template <typename DecorateeT>
class DecoratedRestfulClient : public RestfulClient {
  template<typename T> friend class DecoratedRestfulClient;
  friend RGWRestfulIO;

  typedef typename std::remove_pointer<DecorateeT>::type DerefedDecorateeT;

  static_assert(std::is_base_of<RestfulClient, DerefedDecorateeT>::value,
                "DecorateeT must be a subclass of rgw::io::RestfulClient");

  DecorateeT decoratee;





  template <typename T = void,
            typename std::enable_if<
    ! std::is_pointer<DecorateeT>::value, T>::type* = nullptr>
  DerefedDecorateeT& get_decoratee() {
    return decoratee;
  }

protected:
  template <typename T = void,
            typename std::enable_if<
    std::is_pointer<DecorateeT>::value, T>::type* = nullptr>
  DerefedDecorateeT& get_decoratee() {
    return *decoratee;
  }





  template <typename T = void,
            typename std::enable_if<
    std::is_pointer<DecorateeT>::value, T>::type* = nullptr>
  void set_decoratee(DerefedDecorateeT& new_dec) {
    decoratee = &new_dec;
  }

  int init_env(CephContext *cct) override {
    return get_decoratee().init_env(cct);
  }

public:
  explicit DecoratedRestfulClient(DecorateeT&& decoratee)
    : decoratee(std::forward<DecorateeT>(decoratee)) {
  }

  size_t send_status(const int status,
                     const char* const status_name) override {
    return get_decoratee().send_status(status, status_name);
  }

  size_t send_100_continue() override {
    return get_decoratee().send_100_continue();
  }

  size_t send_header(const boost::string_ref& name,
                     const boost::string_ref& value) override {
    return get_decoratee().send_header(name, value);
  }

  size_t send_content_length(const uint64_t len) override {
    return get_decoratee().send_content_length(len);
  }

  size_t send_chunked_transfer_encoding() override {
    return get_decoratee().send_chunked_transfer_encoding();
  }

  size_t complete_header() override {
    return get_decoratee().complete_header();
  }

  size_t recv_body(char* const buf, const size_t max) override {
    return get_decoratee().recv_body(buf, max);
  }

  size_t send_body(const char* const buf,
                   const size_t len) override {
    return get_decoratee().send_body(buf, len);
  }

  void flush() override {
    return get_decoratee().flush();
  }

  RGWEnv& get_env() noexcept override {
    return get_decoratee().get_env();
  }

  size_t complete_request() override {
    return get_decoratee().complete_request();
  }
} ;




class BuffererSink {
public:
  virtual ~BuffererSink() = default;



  virtual size_t write_data(const char *buf, size_t len) = 0;
};
# 278 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h"
template <size_t BufferSizeV = 4096>
class StaticOutputBufferer : public std::streambuf {
  static_assert(BufferSizeV >= sizeof(std::streambuf::char_type),
                "Buffer size must be bigger than a single char_type.");

  using std::streambuf::int_type;

  int_type overflow(const int_type c) override {
    *pptr() = c;
    pbump(sizeof(std::streambuf::char_type));

    if (! sync()) {

      return c;
    } else {
      return std::streambuf::traits_type::eof();
    }
  }

  int sync() override {
    const auto len = static_cast<size_t>(std::streambuf::pptr() -
                                         std::streambuf::pbase());
    std::streambuf::pbump(-len);
    sink.write_data(std::streambuf::pbase(), len);


    return 0;
  }

  BuffererSink& sink;
  std::streambuf::char_type buffer[BufferSizeV];

public:
  explicit StaticOutputBufferer(BuffererSink& sink)
    : sink(sink) {
    constexpr size_t len = sizeof(buffer) - sizeof(std::streambuf::char_type);
    std::streambuf::setp(buffer, buffer + len);
  }
};

}
}







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h" 2

namespace rgw {
namespace io {

template <typename T>
class AccountingFilter : public DecoratedRestfulClient<T>,
                         public Accounter {
  bool enabled;
  uint64_t total_sent;
  uint64_t total_received;
  CephContext *cct;

public:
  template <typename U>
  AccountingFilter(CephContext *cct, U&& decoratee)
    : DecoratedRestfulClient<T>(std::forward<U>(decoratee)),
      enabled(false),
      total_sent(0),
      total_received(0), cct(cct) {
  }

  size_t send_status(const int status,
                     const char* const status_name) override {
    const auto sent = DecoratedRestfulClient<T>::send_status(status,
                                                             status_name);
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::send_status: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  size_t send_100_continue() override {
    const auto sent = DecoratedRestfulClient<T>::send_100_continue();
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::send_100_continue: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  size_t send_header(const boost::string_ref& name,
                     const boost::string_ref& value) override {
    const auto sent = DecoratedRestfulClient<T>::send_header(name, value);
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::send_header: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  size_t send_content_length(const uint64_t len) override {
    const auto sent = DecoratedRestfulClient<T>::send_content_length(len);
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::send_content_length: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  size_t send_chunked_transfer_encoding() override {
    const auto sent = DecoratedRestfulClient<T>::send_chunked_transfer_encoding();
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::send_chunked_transfer_encoding: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  size_t complete_header() override {
    const auto sent = DecoratedRestfulClient<T>::complete_header();
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::complete_header: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  size_t recv_body(char* buf, size_t max) override {
    const auto received = DecoratedRestfulClient<T>::recv_body(buf, max);
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::recv_body: e="
        << (enabled ? "1" : "0") << ", received=" << received << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_received += received;
    }
    return received;
  }

  size_t send_body(const char* const buf,
                   const size_t len) override {
    const auto sent = DecoratedRestfulClient<T>::send_body(buf, len);
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::send_body: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  size_t complete_request() override {
    const auto sent = DecoratedRestfulClient<T>::complete_request();
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::complete_request: e="
        << (enabled ? "1" : "0") << ", sent=" << sent << ", total="
        << total_sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    if (enabled) {
      total_sent += sent;
    }
    return sent;
  }

  uint64_t get_bytes_sent() const override {
    return total_sent;
  }

  uint64_t get_bytes_received() const override {
    return total_received;
  }

  void set_account(bool enabled) override {
    this->enabled = enabled;
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "AccountingFilter::set_account: e="
        << (enabled ? "1" : "0") << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
  }
};




template <typename T>
class BufferingFilter : public DecoratedRestfulClient<T> {
  template<typename Td> friend class DecoratedRestfulClient;
protected:
  ceph::bufferlist data;

  bool has_content_length;
  bool buffer_data;
  CephContext *cct;

public:
  template <typename U>
  BufferingFilter(CephContext *cct, U&& decoratee)
    : DecoratedRestfulClient<T>(std::forward<U>(decoratee)),
      has_content_length(false),
      buffer_data(false), cct(cct) {
  }

  size_t send_content_length(const uint64_t len) override;
  size_t send_chunked_transfer_encoding() override;
  size_t complete_header() override;
  size_t send_body(const char* buf, size_t len) override;
  size_t complete_request() override;
};

template <typename T>
size_t BufferingFilter<T>::send_body(const char* const buf,
                                     const size_t len)
{
  if (buffer_data) {
    data.append(buf, len);

    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "BufferingFilter<T>::send_body: defer count = "
        << len << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return 0;
  }

  return DecoratedRestfulClient<T>::send_body(buf, len);
}

template <typename T>
size_t BufferingFilter<T>::send_content_length(const uint64_t len)
{
  has_content_length = true;
  return DecoratedRestfulClient<T>::send_content_length(len);
}

template <typename T>
size_t BufferingFilter<T>::send_chunked_transfer_encoding()
{
  has_content_length = true;
  return DecoratedRestfulClient<T>::send_chunked_transfer_encoding();
}

template <typename T>
size_t BufferingFilter<T>::complete_header()
{
  if (! has_content_length) {

    buffer_data = true;
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "BufferingFilter<T>::complete_header: has_content_length="
        << (has_content_length ? "1" : "0") << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return 0;
  }

  return DecoratedRestfulClient<T>::complete_header();
}

template <typename T>
size_t BufferingFilter<T>::complete_request()
{
  size_t sent = 0;

  if (! has_content_length) {




    sent += DecoratedRestfulClient<T>::send_content_length(data.length());
    sent += DecoratedRestfulClient<T>::complete_header();
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout <<
        "BufferingFilter::complete_request: !has_content_length: IGNORE: sent="
        << sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    sent = 0;
  }

  if (buffer_data) {


    for (const auto& ptr : data.buffers()) {
      sent += DecoratedRestfulClient<T>::send_body(ptr.c_str(),
                                                   ptr.length());
    }
    data.clear();
    buffer_data = false;
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(30)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 30); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 30>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(30, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "BufferingFilter::complete_request: buffer_data: sent="
        << sent << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
  }

  return sent + DecoratedRestfulClient<T>::complete_request();
}

template <typename T> static inline
BufferingFilter<T> add_buffering(
CephContext *cct,
T&& t) {
  return BufferingFilter<T>(cct, std::forward<T>(t));
}


template <typename T>
class ChunkingFilter : public DecoratedRestfulClient<T> {
  template<typename Td> friend class DecoratedRestfulClient;
protected:
  bool chunking_enabled;

public:
  template <typename U>
  explicit ChunkingFilter(U&& decoratee)
    : DecoratedRestfulClient<T>(std::forward<U>(decoratee)),
      chunking_enabled(false) {
  }

  size_t send_chunked_transfer_encoding() override {
    chunking_enabled = true;
    return DecoratedRestfulClient<T>::send_header("Transfer-Encoding",
                                                  "chunked");
  }

  size_t send_body(const char* buf,
                   const size_t len) override {
    if (! chunking_enabled) {
      return DecoratedRestfulClient<T>::send_body(buf, len);
    } else {
      static constexpr char HEADER_END[] = "\r\n";



      char chunk_size[32];
      const auto chunk_size_len = snprintf(chunk_size, sizeof(chunk_size),
                                           "%" 
# 294 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h" 3 4
                                              "l" "x" 
# 294 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h"
                                                     "\r\n", len);
      size_t sent = 0;

      sent += DecoratedRestfulClient<T>::send_body(chunk_size, chunk_size_len);
      sent += DecoratedRestfulClient<T>::send_body(buf, len);
      sent += DecoratedRestfulClient<T>::send_body(HEADER_END,
                                                   sizeof(HEADER_END) - 1);
      return sent;
    }
  }

  size_t complete_request() override {
    size_t sent = 0;

    if (chunking_enabled) {
      static constexpr char CHUNKED_RESP_END[] = "0\r\n\r\n";
      sent += DecoratedRestfulClient<T>::send_body(CHUNKED_RESP_END,
                                                   sizeof(CHUNKED_RESP_END) - 1);
    }

    return sent + DecoratedRestfulClient<T>::complete_request();
  }
};

template <typename T> static inline
ChunkingFilter<T> add_chunking(T&& t) {
  return ChunkingFilter<T>(std::forward<T>(t));
}





template <typename T>
class ConLenControllingFilter : public DecoratedRestfulClient<T> {
protected:
  enum class ContentLengthAction {
    FORWARD,
    INHIBIT,
    UNKNOWN
  } action;

public:
  template <typename U>
  explicit ConLenControllingFilter(U&& decoratee)
    : DecoratedRestfulClient<T>(std::forward<U>(decoratee)),
      action(ContentLengthAction::UNKNOWN) {
  }

  size_t send_status(const int status,
                     const char* const status_name) override {
    if ((204 == status || 304 == status) &&
        ! g_conf()->rgw_print_prohibited_content_length) {
      action = ContentLengthAction::INHIBIT;
    } else {
      action = ContentLengthAction::FORWARD;
    }

    return DecoratedRestfulClient<T>::send_status(status, status_name);
  }

  size_t send_content_length(const uint64_t len) override {
    switch(action) {
    case ContentLengthAction::FORWARD:
      return DecoratedRestfulClient<T>::send_content_length(len);
    case ContentLengthAction::INHIBIT:
      return 0;
    case ContentLengthAction::UNKNOWN:
    default:
      return -
# 363 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h" 3 4
             22
# 363 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h"
                   ;
    }
  }
};

template <typename T> static inline
ConLenControllingFilter<T> add_conlen_controlling(T&& t) {
  return ConLenControllingFilter<T>(std::forward<T>(t));
}




template <typename T>
class ReorderingFilter : public DecoratedRestfulClient<T> {
protected:
  enum class ReorderState {
    RGW_EARLY_HEADERS,
    RGW_STATUS_SEEN,
    RGW_DATA
  } phase;

  boost::optional<uint64_t> content_length;

  std::vector<std::pair<std::string, std::string>> headers;

  size_t send_header(const boost::string_ref& name,
                     const boost::string_ref& value) override {
    switch (phase) {
    case ReorderState::RGW_EARLY_HEADERS:
    case ReorderState::RGW_STATUS_SEEN:
      headers.emplace_back(std::make_pair(std::string(name.data(), name.size()),
                                          std::string(value.data(), value.size())));
      return 0;
    case ReorderState::RGW_DATA:
      return DecoratedRestfulClient<T>::send_header(name, value);
    }

    return -
# 401 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h" 3 4
           5
# 401 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io_filters.h"
              ;
  }

public:
  template <typename U>
  explicit ReorderingFilter(U&& decoratee)
    : DecoratedRestfulClient<T>(std::forward<U>(decoratee)),
      phase(ReorderState::RGW_EARLY_HEADERS) {
  }

  size_t send_status(const int status,
                     const char* const status_name) override {
    phase = ReorderState::RGW_STATUS_SEEN;

    return DecoratedRestfulClient<T>::send_status(status, status_name);
  }

  size_t send_content_length(const uint64_t len) override {
    if (ReorderState::RGW_EARLY_HEADERS == phase) {

      content_length = len;
      return 0;
    } else {
      return DecoratedRestfulClient<T>::send_content_length(len);
    }
  }

  size_t complete_header() override {
    size_t sent = 0;


    phase = ReorderState::RGW_DATA;


    if (content_length) {
      sent += DecoratedRestfulClient<T>::send_content_length(*content_length);
    }


    for (const auto& kv : headers) {
      sent += DecoratedRestfulClient<T>::send_header(kv.first, kv.second);
    }
    headers.clear();

    return sent + DecoratedRestfulClient<T>::complete_header();
  }
};

template <typename T> static inline
ReorderingFilter<T> add_reordering(T&& t) {
  return ReorderingFilter<T>(std::forward<T>(t));
}

}
}
# 328 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h" 2
# 336 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h"
class RGWRestfulIO : public rgw::io::AccountingFilter<rgw::io::RestfulClient*> {
  std::vector<std::shared_ptr<DecoratedRestfulClient>> filters;

public:
  ~RGWRestfulIO() override = default;

  RGWRestfulIO(CephContext *_cx, rgw::io::RestfulClient* engine)
    : AccountingFilter<rgw::io::RestfulClient*>(_cx, std::move(engine)) {
  }

  void add_filter(std::shared_ptr<DecoratedRestfulClient> new_filter) {
    new_filter->set_decoratee(this->get_decoratee());
    this->set_decoratee(*new_filter);
    filters.emplace_back(std::move(new_filter));
  }
};




static inline rgw::io::RestfulClient* RESTFUL_IO(struct req_state* s) {
  do { static const ceph::assert_data assert_data_ctx = {"dynamic_cast<rgw::io::RestfulClient*>(s->cio) != nullptr", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h", 357, __PRETTY_FUNCTION__}; ((dynamic_cast<rgw::io::RestfulClient*>(s->cio) != nullptr) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

  return static_cast<rgw::io::RestfulClient*>(s->cio);
}

static inline rgw::io::Accounter* ACCOUNTING_IO(struct req_state* s) {
  auto ptr = dynamic_cast<rgw::io::Accounter*>(s->cio);
  do { static const ceph::assert_data assert_data_ctx = {"ptr != nullptr", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h", 364, __PRETTY_FUNCTION__}; ((ptr != nullptr) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

  return ptr;
}

static inline RGWRestfulIO* AWS_AUTHv4_IO(const req_state* const s) {
  do { static const ceph::assert_data assert_data_ctx = {"dynamic_cast<RGWRestfulIO*>(s->cio) != nullptr", "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_client_io.h", 370, __PRETTY_FUNCTION__}; ((dynamic_cast<RGWRestfulIO*>(s->cio) != nullptr) ? static_cast<void> (0) : __ceph_assert_fail(assert_data_ctx)); } while(false);

  return static_cast<RGWRestfulIO*>(s->cio);
}


class RGWClientIOStreamBuf : public std::streambuf {
protected:
  RGWRestfulIO &rio;
  size_t const window_size;
  size_t const putback_size;
  std::vector<char> buffer;

public:
  RGWClientIOStreamBuf(RGWRestfulIO &rio, size_t ws, size_t ps = 1)
    : rio(rio),
      window_size(ws),
      putback_size(ps),
      buffer(ws + ps)
  {
    setg(nullptr, nullptr, nullptr);
  }

  std::streambuf::int_type underflow() override {
    if (gptr() < egptr()) {
      return traits_type::to_int_type(*gptr());
    }

    char * const base = buffer.data();
    char * start;

    if (nullptr != eback()) {



      std::memmove(base, egptr() - putback_size, putback_size);
      start = base + putback_size;
    } else {
      start = base;
    }

    size_t read_len = 0;
    try {
      read_len = rio.recv_body(base, window_size);
    } catch (rgw::io::Exception&) {
      return traits_type::eof();
    }
    if (0 == read_len) {
      return traits_type::eof();
    }

    setg(base, start, start + read_len);

    return traits_type::to_int_type(*gptr());
  }
};

class RGWClientIOStream : private RGWClientIOStreamBuf, public std::istream {




public:
  explicit RGWClientIOStream(RGWRestfulIO &s)
    : RGWClientIOStreamBuf(s, 1, 2),
      istream(static_cast<RGWClientIOStreamBuf *>(this)) {
  }
};
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 2

extern std::map<std::string, std::string> rgw_to_http_attrs;

extern void rgw_rest_init(CephContext *cct, RGWRados *store, const RGWZoneGroup& zone_group);

extern void rgw_flush_formatter_and_reset(struct req_state *s,
      ceph::Formatter *formatter);

extern void rgw_flush_formatter(struct req_state *s,
    ceph::Formatter *formatter);

std::tuple<int, bufferlist > rgw_rest_read_all_input(struct req_state *s,
                                        const uint64_t max_len,
                                        const bool allow_chunked=true);

static inline boost::string_ref rgw_sanitized_hdrval(ceph::buffer::list& raw)
{





  const char* const data = raw.c_str();
  size_t len = raw.length();

  if (len && data[len - 1] == '\0') {



    len--;
  }

  return boost::string_ref(data, len);
}

template <class T>
int rgw_rest_get_json_input(CephContext *cct, req_state *s, T& out,
       uint64_t max_len, bool *empty)
{
  if (empty)
    *empty = false;

  int rv = 0;
  bufferlist data;
  std::tie(rv, data) = rgw_rest_read_all_input(s, max_len);
  if (rv < 0) {
    return rv;
  }

  if (!data.length()) {
    if (empty) {
      *empty = true;
    }

    return -
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
           22
# 71 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                 ;
  }

  JSONParser parser;

  if (!parser.parse(data.c_str(), data.length())) {
    return -
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
           22
# 77 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                 ;
  }

  try {
      decode_json_obj(out, &parser);
  } catch (JSONDecoder::err& e) {
      return -
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
             22
# 83 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                   ;
  }

  return 0;
}

template <class T>
std::tuple<int, bufferlist > rgw_rest_get_json_input_keep_data(CephContext *cct, req_state *s, T& out, uint64_t max_len)
{
  int rv = 0;
  bufferlist data;
  std::tie(rv, data) = rgw_rest_read_all_input(s, max_len);
  if (rv < 0) {
    return std::make_tuple(rv, std::move(data));
  }

  if (!data.length()) {
    return std::make_tuple(-
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                           22
# 100 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                 , std::move(data));
  }

  JSONParser parser;

  if (!parser.parse(data.c_str(), data.length())) {
    return std::make_tuple(-
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                           22
# 106 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                 , std::move(data));
  }

  try {
    decode_json_obj(out, &parser);
  } catch (JSONDecoder::err& e) {
    return std::make_tuple(-
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                           22
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                 , std::move(data));
  }

  return std::make_tuple(0, std::move(data));
}

class RESTArgs {
public:
  static int get_string(struct req_state *s, const string& name,
   const string& def_val, string *val,
   bool *existed = 
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                  __null
# 122 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                      );
  static int get_uint64(struct req_state *s, const string& name,
   uint64_t def_val, uint64_t *val, bool *existed = 
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                                   __null
# 124 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                                       );
  static int get_int64(struct req_state *s, const string& name,
         int64_t def_val, int64_t *val, bool *existed = 
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                                       __null
# 126 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                                           );
  static int get_uint32(struct req_state *s, const string& name,
   uint32_t def_val, uint32_t *val, bool *existed = 
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                                   __null
# 128 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                                       );
  static int get_int32(struct req_state *s, const string& name,
         int32_t def_val, int32_t *val, bool *existed = 
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                                       __null
# 130 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                                           );
  static int get_time(struct req_state *s, const string& name,
        const utime_t& def_val, utime_t *val,
        bool *existed = 
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                       __null
# 133 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                           );
  static int get_epoch(struct req_state *s, const string& name,
         uint64_t def_val, uint64_t *epoch,
         bool *existed = 
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                        __null
# 136 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                            );
  static int get_bool(struct req_state *s, const string& name, bool def_val,
        bool *val, bool *existed = 
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                  __null
# 138 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                      );
};

class RGWRESTFlusher : public RGWFormatterFlusher {
  struct req_state *s;
  RGWOp *op;
protected:
  void do_flush() override;
  void do_start(int ret) override;
public:
  RGWRESTFlusher(struct req_state *_s, RGWOp *_op) :
    RGWFormatterFlusher(_s->formatter), s(_s), op(_op) {}
  RGWRESTFlusher() : RGWFormatterFlusher(
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                        __null
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                            ), s(
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                                 __null
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                                     ), op(
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                                           __null
# 150 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                                               ) {}

  void init(struct req_state *_s, RGWOp *_op) {
    s = _s;
    op = _op;
    set_formatter(s->formatter);
  }
};

class RGWGetObj_ObjStore : public RGWGetObj
{
protected:
  bool sent_header;
public:
  RGWGetObj_ObjStore() : sent_header(false) {}

  void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
    RGWGetObj::init(store, s, h);
    sent_header = false;
  }

  int get_params() override;
};

class RGWGetObjTags_ObjStore : public RGWGetObjTags {
public:
  RGWGetObjTags_ObjStore() {};
  ~RGWGetObjTags_ObjStore() {};
};

class RGWPutObjTags_ObjStore: public RGWPutObjTags {
public:
  RGWPutObjTags_ObjStore() {};
  ~RGWPutObjTags_ObjStore() {};
};

class RGWListBuckets_ObjStore : public RGWListBuckets {
public:
  RGWListBuckets_ObjStore() {}
  ~RGWListBuckets_ObjStore() override {}
};

class RGWGetUsage_ObjStore : public RGWGetUsage {
public:
  RGWGetUsage_ObjStore() {}
  ~RGWGetUsage_ObjStore() override {}
};

class RGWListBucket_ObjStore : public RGWListBucket {
public:
  RGWListBucket_ObjStore() {}
  ~RGWListBucket_ObjStore() override {}
};

class RGWStatAccount_ObjStore : public RGWStatAccount {
public:
  RGWStatAccount_ObjStore() {}
  ~RGWStatAccount_ObjStore() override {}
};

class RGWStatBucket_ObjStore : public RGWStatBucket {
public:
  RGWStatBucket_ObjStore() {}
  ~RGWStatBucket_ObjStore() override {}
};

class RGWCreateBucket_ObjStore : public RGWCreateBucket {
public:
  RGWCreateBucket_ObjStore() {}
  ~RGWCreateBucket_ObjStore() override {}
};

class RGWDeleteBucket_ObjStore : public RGWDeleteBucket {
public:
  RGWDeleteBucket_ObjStore() {}
  ~RGWDeleteBucket_ObjStore() override {}
};

class RGWPutObj_ObjStore : public RGWPutObj
{
public:
  RGWPutObj_ObjStore() {}
  ~RGWPutObj_ObjStore() override {}

  int verify_params() override;
  int get_params() override;
  int get_data(bufferlist& bl) override;
};

class RGWPostObj_ObjStore : public RGWPostObj
{
  std::string boundary;

public:
  struct post_part_field {
    std::string val;
    std::map<std::string, std::string> params;
  };

  struct post_form_part {
    std::string name;
    std::map<std::string, post_part_field, ltstr_nocase> fields;
    ceph::bufferlist data;
  };

protected:
  using parts_collection_t =
    std::map<std::string, post_form_part, const ltstr_nocase>;

  std::string err_msg;
  ceph::bufferlist in_data;

  int read_with_boundary(ceph::bufferlist& bl,
                         uint64_t max,
                         bool check_eol,
                         bool& reached_boundary,
                         bool& done);

  int read_line(ceph::bufferlist& bl,
                uint64_t max,
                bool& reached_boundary,
                bool& done);

  int read_data(ceph::bufferlist& bl,
                uint64_t max,
                bool& reached_boundary,
                bool& done);

  int read_form_part_header(struct post_form_part *part, bool& done);

  int get_params() override;

  static int parse_part_field(const std::string& line,
                              std::string& field_name,
                              post_part_field& field);

  static void parse_boundary_params(const std::string& params_str,
                                    std::string& first,
                                    std::map<std::string, std::string>& params);

  static bool part_str(parts_collection_t& parts,
                       const std::string& name,
                       std::string *val);

  static std::string get_part_str(parts_collection_t& parts,
                                  const std::string& name,
                                  const std::string& def_val = std::string());

  static bool part_bl(parts_collection_t& parts,
                      const std::string& name,
                      ceph::bufferlist *pbl);

public:
  RGWPostObj_ObjStore() {}
  ~RGWPostObj_ObjStore() override {}

  int verify_params() override;
};


class RGWPutMetadataAccount_ObjStore : public RGWPutMetadataAccount
{
public:
  RGWPutMetadataAccount_ObjStore() {}
  ~RGWPutMetadataAccount_ObjStore() override {}
};

class RGWPutMetadataBucket_ObjStore : public RGWPutMetadataBucket
{
public:
  RGWPutMetadataBucket_ObjStore() {}
  ~RGWPutMetadataBucket_ObjStore() override {}
};

class RGWPutMetadataObject_ObjStore : public RGWPutMetadataObject
{
public:
  RGWPutMetadataObject_ObjStore() {}
  ~RGWPutMetadataObject_ObjStore() override {}
};

class RGWDeleteObj_ObjStore : public RGWDeleteObj {
public:
  RGWDeleteObj_ObjStore() {}
  ~RGWDeleteObj_ObjStore() override {}
};

class RGWGetCrossDomainPolicy_ObjStore : public RGWGetCrossDomainPolicy {
public:
  RGWGetCrossDomainPolicy_ObjStore() = default;
  ~RGWGetCrossDomainPolicy_ObjStore() override = default;
};

class RGWGetHealthCheck_ObjStore : public RGWGetHealthCheck {
public:
  RGWGetHealthCheck_ObjStore() = default;
  ~RGWGetHealthCheck_ObjStore() override = default;
};

class RGWCopyObj_ObjStore : public RGWCopyObj {
public:
  RGWCopyObj_ObjStore() {}
  ~RGWCopyObj_ObjStore() override {}
};

class RGWGetACLs_ObjStore : public RGWGetACLs {
public:
  RGWGetACLs_ObjStore() {}
  ~RGWGetACLs_ObjStore() override {}
};

class RGWPutACLs_ObjStore : public RGWPutACLs {
public:
  RGWPutACLs_ObjStore() {}
  ~RGWPutACLs_ObjStore() override {}

  int get_params() override;
};

class RGWGetLC_ObjStore : public RGWGetLC {
public:
  RGWGetLC_ObjStore() {}
  ~RGWGetLC_ObjStore() override {}
};

class RGWPutLC_ObjStore : public RGWPutLC {
public:
  RGWPutLC_ObjStore() {}
  ~RGWPutLC_ObjStore() override {}

  int get_params() override;
};

class RGWDeleteLC_ObjStore : public RGWDeleteLC {
public:
  RGWDeleteLC_ObjStore() {}
  ~RGWDeleteLC_ObjStore() override {}

};

class RGWGetCORS_ObjStore : public RGWGetCORS {
public:
  RGWGetCORS_ObjStore() {}
  ~RGWGetCORS_ObjStore() override {}
};

class RGWPutCORS_ObjStore : public RGWPutCORS {
public:
  RGWPutCORS_ObjStore() {}
  ~RGWPutCORS_ObjStore() override {}
};

class RGWDeleteCORS_ObjStore : public RGWDeleteCORS {
public:
  RGWDeleteCORS_ObjStore() {}
  ~RGWDeleteCORS_ObjStore() override {}
};

class RGWOptionsCORS_ObjStore : public RGWOptionsCORS {
public:
  RGWOptionsCORS_ObjStore() {}
  ~RGWOptionsCORS_ObjStore() override {}
};

class RGWInitMultipart_ObjStore : public RGWInitMultipart {
public:
  RGWInitMultipart_ObjStore() {}
  ~RGWInitMultipart_ObjStore() override {}
};

class RGWCompleteMultipart_ObjStore : public RGWCompleteMultipart {
public:
  RGWCompleteMultipart_ObjStore() {}
  ~RGWCompleteMultipart_ObjStore() override {}

  int get_params() override;
};

class RGWAbortMultipart_ObjStore : public RGWAbortMultipart {
public:
  RGWAbortMultipart_ObjStore() {}
  ~RGWAbortMultipart_ObjStore() override {}
};

class RGWListMultipart_ObjStore : public RGWListMultipart {
public:
  RGWListMultipart_ObjStore() {}
  ~RGWListMultipart_ObjStore() override {}

  int get_params() override;
};

class RGWListBucketMultiparts_ObjStore : public RGWListBucketMultiparts {
public:
  RGWListBucketMultiparts_ObjStore() {}
  ~RGWListBucketMultiparts_ObjStore() override {}

  int get_params() override;
};

class RGWBulkDelete_ObjStore : public RGWBulkDelete {
public:
  RGWBulkDelete_ObjStore() {}
  ~RGWBulkDelete_ObjStore() override {}
};

class RGWBulkUploadOp_ObjStore : public RGWBulkUploadOp {
public:
  RGWBulkUploadOp_ObjStore() = default;
  ~RGWBulkUploadOp_ObjStore() = default;
};

class RGWDeleteMultiObj_ObjStore : public RGWDeleteMultiObj {
public:
  RGWDeleteMultiObj_ObjStore() {}
  ~RGWDeleteMultiObj_ObjStore() override {}

  int get_params() override;
};

class RGWInfo_ObjStore : public RGWInfo {
public:
    RGWInfo_ObjStore() = default;
    ~RGWInfo_ObjStore() override = default;
};

class RGWPutBucketObjectLock_ObjStore : public RGWPutBucketObjectLock {
public:
  RGWPutBucketObjectLock_ObjStore() = default;
  ~RGWPutBucketObjectLock_ObjStore() = default;
  int get_params() override;
};

class RGWGetBucketObjectLock_ObjStore : public RGWGetBucketObjectLock {
public:
  RGWGetBucketObjectLock_ObjStore() = default;
  ~RGWGetBucketObjectLock_ObjStore() override = default;
};

class RGWPutObjRetention_ObjStore : public RGWPutObjRetention {
public:
  RGWPutObjRetention_ObjStore() = default;
  ~RGWPutObjRetention_ObjStore() override = default;
};

class RGWGetObjRetention_ObjStore : public RGWGetObjRetention {
public:
  RGWGetObjRetention_ObjStore() = default;
  ~RGWGetObjRetention_ObjStore() = default;
};

class RGWPutObjLegalHold_ObjStore : public RGWPutObjLegalHold {
public:
  RGWPutObjLegalHold_ObjStore() = default;
  ~RGWPutObjLegalHold_ObjStore() override = default;
  int get_params() override;
};

class RGWGetObjLegalHold_ObjStore : public RGWGetObjLegalHold {
public:
  RGWGetObjLegalHold_ObjStore() = default;
  ~RGWGetObjLegalHold_ObjStore() = default;
};

class RGWRESTOp : public RGWOp {
protected:
  int http_ret;
  RGWRESTFlusher flusher;
public:
  RGWRESTOp() : http_ret(0) {}
  void init(RGWRados *store, struct req_state *s,
            RGWHandler *dialect_handler) override {
    RGWOp::init(store, s, dialect_handler);
    flusher.init(s, this);
  }
  void send_response() override;
  virtual int check_caps(RGWUserCaps& caps)
    { return -
# 527 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
             1
# 527 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                  ; }
  int verify_permission() override;
  dmc::client_id dmclock_client() override { return dmc::client_id::admin; }
};

class RGWHandler_REST : public RGWHandler {
protected:

  virtual bool is_obj_update_op() { return false; }
  virtual RGWOp *op_get() { return 
# 536 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                  __null
# 536 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                      ; }
  virtual RGWOp *op_put() { return 
# 537 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                  __null
# 537 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                      ; }
  virtual RGWOp *op_delete() { return 
# 538 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                     __null
# 538 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                         ; }
  virtual RGWOp *op_head() { return 
# 539 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                   __null
# 539 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                       ; }
  virtual RGWOp *op_post() { return 
# 540 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                   __null
# 540 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                       ; }
  virtual RGWOp *op_copy() { return 
# 541 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                   __null
# 541 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                       ; }
  virtual RGWOp *op_options() { return 
# 542 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                                      __null
# 542 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                          ; }

public:
  static int allocate_formatter(struct req_state *s, int default_formatter,
    bool configurable);

  static constexpr int MAX_BUCKET_NAME_LEN = 255;
  static constexpr int MAX_OBJ_NAME_LEN = 1024;

  RGWHandler_REST() {}
  ~RGWHandler_REST() override {}

  static int validate_bucket_name(const string& bucket);
  static int validate_object_name(const string& object);
  static int reallocate_formatter(struct req_state *s, int type);

  int init_permissions(RGWOp* op) override;
  int read_permissions(RGWOp* op) override;

  virtual RGWOp* get_op(RGWRados* store);
  virtual void put_op(RGWOp* op);
};

class RGWHandler_REST_SWIFT;
class RGWHandler_SWIFT_Auth;
class RGWHandler_REST_S3;

namespace rgw {
namespace auth {

class StrategyRegistry;

}
}

class RGWRESTMgr {
  bool should_log;

protected:
  std::map<std::string, RGWRESTMgr*> resource_mgrs;
  std::multimap<size_t, std::string> resources_by_size;
  RGWRESTMgr* default_mgr;

  virtual RGWRESTMgr* get_resource_mgr(struct req_state* s,
                                       const std::string& uri,
                                       std::string* out_uri);

  virtual RGWRESTMgr* get_resource_mgr_as_default(struct req_state* const s,
                                                  const std::string& uri,
                                                  std::string* our_uri) {
    return this;
  }

public:
  RGWRESTMgr()
    : should_log(false),
      default_mgr(nullptr) {
  }
  virtual ~RGWRESTMgr();

  void register_resource(std::string resource, RGWRESTMgr* mgr);
  void register_default_mgr(RGWRESTMgr* mgr);

  virtual RGWRESTMgr* get_manager(struct req_state* const s,


                                  const std::string& frontend_prefix,
                                  const std::string& uri,
                                  std::string* out_uri) final {
    return get_resource_mgr(s, frontend_prefix + uri, out_uri);
  }

  virtual RGWHandler_REST* get_handler(
    struct req_state* const s,
    const rgw::auth::StrategyRegistry& auth_registry,
    const std::string& frontend_prefix
  ) {
    return nullptr;
  }

  virtual void put_handler(RGWHandler_REST* const handler) {
    delete handler;
  }

  void set_logging(bool _should_log) {
    should_log = _should_log;
  }

  bool get_logging() const {
    return should_log;
  }
};

class RGWLibIO;
class RGWRestfulIO;

class RGWREST {
  using x_header = basic_sstring<char, uint16_t, 32>;
  boost::container::flat_set<x_header> x_headers;
  RGWRESTMgr mgr;

  static int preprocess(struct req_state *s, rgw::io::BasicClient* rio);
public:
  RGWREST() {}
  RGWHandler_REST *get_handler(RGWRados *store,
                               struct req_state *s,
                               const rgw::auth::StrategyRegistry& auth_registry,
                               const std::string& frontend_prefix,
                               RGWRestfulIO *rio,
                               RGWRESTMgr **pmgr,
                               int *init_error);






  void put_handler(RGWHandler_REST *handler) {
    mgr.put_handler(handler);
  }

  void register_resource(string resource, RGWRESTMgr *m,
    bool register_empty = false) {
    if (!register_empty && resource.empty())
      return;

    mgr.register_resource(resource, m);
  }

  void register_default_mgr(RGWRESTMgr *m) {
    mgr.register_default_mgr(m);
  }

  void register_x_headers(const std::string& headers);

  bool log_x_headers(void) {
    return (x_headers.size() > 0);
  }

  bool log_x_header(const std::string& header) {
    return (x_headers.find(header) != x_headers.end());
  }
};

static constexpr int64_t NO_CONTENT_LENGTH = -1;
static constexpr int64_t CHUNKED_TRANSFER_ENCODING = -2;

extern void dump_errno(int http_ret, string& out);
extern void dump_errno(const struct rgw_err &err, string& out);
extern void dump_errno(struct req_state *s);
extern void dump_errno(struct req_state *s, int http_ret);
extern void end_header(struct req_state *s,
                       RGWOp* op = nullptr,
                       const char *content_type = nullptr,
                       const int64_t proposed_content_length =
         NO_CONTENT_LENGTH,
         bool force_content_type = false,
         bool force_no_error = false);
extern void dump_start(struct req_state *s);
extern void list_all_buckets_start(struct req_state *s);
extern void dump_owner(struct req_state *s, const rgw_user& id, string& name,
         const char *section = 
# 703 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h" 3 4
                              __null
# 703 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest.h"
                                  );
extern void dump_header(struct req_state* s,
                        const boost::string_ref& name,
                        const boost::string_ref& val);
extern void dump_header(struct req_state* s,
                        const boost::string_ref& name,
                        ceph::buffer::list& bl);
extern void dump_header(struct req_state* s,
                        const boost::string_ref& name,
                        long long val);
extern void dump_header(struct req_state* s,
                        const boost::string_ref& name,
                        const utime_t& val);

template <class... Args>
static inline void dump_header_prefixed(struct req_state* s,
                                        const boost::string_ref& name_prefix,
                                        const boost::string_ref& name,
                                        Args&&... args) {
  char full_name_buf[name_prefix.size() + name.size() + 1];
  const auto len = snprintf(full_name_buf, sizeof(full_name_buf), "%.*s%.*s",
                            static_cast<int>(name_prefix.length()),
                            name_prefix.data(),
                            static_cast<int>(name.length()),
                            name.data());
  boost::string_ref full_name(full_name_buf, len);
  return dump_header(s, std::move(full_name), std::forward<Args>(args)...);
}

template <class... Args>
static inline void dump_header_infixed(struct req_state* s,
                                       const boost::string_ref& prefix,
                                       const boost::string_ref& infix,
                                       const boost::string_ref& sufix,
                                       Args&&... args) {
  char full_name_buf[prefix.size() + infix.size() + sufix.size() + 1];
  const auto len = snprintf(full_name_buf, sizeof(full_name_buf), "%.*s%.*s%.*s",
                            static_cast<int>(prefix.length()),
                            prefix.data(),
                            static_cast<int>(infix.length()),
                            infix.data(),
                            static_cast<int>(sufix.length()),
                            sufix.data());
  boost::string_ref full_name(full_name_buf, len);
  return dump_header(s, std::move(full_name), std::forward<Args>(args)...);
}

template <class... Args>
static inline void dump_header_quoted(struct req_state* s,
                                      const boost::string_ref& name,
                                      const boost::string_ref& val) {

  char qvalbuf[val.size() + 2 + 1];
  const auto len = snprintf(qvalbuf, sizeof(qvalbuf), "\"%.*s\"",
                            static_cast<int>(val.length()), val.data());
  return dump_header(s, name, boost::string_ref(qvalbuf, len));
}

template <class ValueT>
static inline void dump_header_if_nonempty(struct req_state* s,
                                           const boost::string_ref& name,
                                           const ValueT& value) {
  if (name.length() > 0 && value.length() > 0) {
    return dump_header(s, name, value);
  }
}

static inline std::string compute_domain_uri(const struct req_state *s) {
  std::string uri = (!s->info.domain.empty()) ? s->info.domain :
    [&s]() -> std::string {
    RGWEnv const &env(*(s->info.env));
    std::string uri =
    env.get("SERVER_PORT_SECURE") ? "https://" : "http://";
    if (env.exists("SERVER_NAME")) {
      uri.append(env.get("SERVER_NAME", "<SERVER_NAME>"));
    } else {
      uri.append(env.get("HTTP_HOST", "<HTTP_HOST>"));
    }
    return uri;
  }();
  return uri;
}

extern void dump_content_length(struct req_state *s, uint64_t len);
extern int64_t parse_content_length(const char *content_length);
extern void dump_etag(struct req_state *s,
                      const boost::string_ref& etag,
                      bool quoted = false);
extern void dump_epoch_header(struct req_state *s, const char *name, real_time t);
extern void dump_time_header(struct req_state *s, const char *name, real_time t);
extern void dump_last_modified(struct req_state *s, real_time t);
extern void abort_early(struct req_state* s, RGWOp* op, int err,
   RGWHandler* handler);
extern void dump_range(struct req_state* s, uint64_t ofs, uint64_t end,
         uint64_t total_size);
extern void dump_continue(struct req_state *s);
extern void list_all_buckets_end(struct req_state *s);
extern void dump_time(struct req_state *s, const char *name, real_time *t);
extern std::string dump_time_to_str(const real_time& t);
extern void dump_bucket_from_state(struct req_state *s);
extern void dump_redirect(struct req_state *s, const string& redirect);
extern bool is_valid_url(const char *url);
extern void dump_access_control(struct req_state *s, const char *origin,
    const char *meth,
    const char *hdr, const char *exp_hdr,
    uint32_t max_age);
extern void dump_access_control(req_state *s, RGWOp *op);

extern int dump_body(struct req_state* s, const char* buf, size_t len);
extern int dump_body(struct req_state* s, ceph::buffer::list& bl);
extern int dump_body(struct req_state* s, const std::string& str);
extern int recv_body(struct req_state* s, char* buf, size_t max);
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_keystone.h" 1
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_keystone.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 1
# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
typedef const std::map<int,const std::pair<int, const char*>> rgw_http_errors;

extern rgw_http_errors rgw_http_s3_errors;

extern rgw_http_errors rgw_http_swift_errors;

extern rgw_http_errors rgw_http_sts_errors;

static inline int rgw_http_error_to_errno(int http_err)
{
  if (http_err >= 200 && http_err <= 299)
    return 0;
  switch (http_err) {
    case 304:
      return -2016;
    case 400:
      return -
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 3 4
             22
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
                   ;
    case 401:
      return -
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 3 4
             1
# 27 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
                  ;
    case 403:
        return -
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 3 4
               13
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
                     ;
    case 404:
        return -
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 3 4
               2
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
                     ;
    case 409:
        return -
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 3 4
               39
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
                        ;
    case 503:
        return -
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 3 4
               16
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
                    ;
    default:
        return -
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h" 3 4
               5
# 37 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_http_errors.h"
                  ;
  }

  return 0;
}
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl_s3.h" 1
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_acl_s3.h"
class RGWRados;

class ACLPermission_S3 : public ACLPermission, public XMLObj
{
public:
  ACLPermission_S3() {}
  ~ACLPermission_S3() override {}

  bool xml_end(const char *el) override;
  void to_xml(ostream& out);
};

class ACLGrantee_S3 : public ACLGrantee, public XMLObj
{
public:
  ACLGrantee_S3() {}
  ~ACLGrantee_S3() override {}

  bool xml_start(const char *el, const char **attr);
};


class ACLGrant_S3 : public ACLGrant, public XMLObj
{
public:
  ACLGrant_S3() {}
  ~ACLGrant_S3() override {}

  void to_xml(CephContext *cct, ostream& out);
  bool xml_end(const char *el) override;
  bool xml_start(const char *el, const char **attr);

  static ACLGroupTypeEnum uri_to_group(string& uri);
  static bool group_to_uri(ACLGroupTypeEnum group, string& uri);
};

class RGWAccessControlList_S3 : public RGWAccessControlList, public XMLObj
{
public:
  explicit RGWAccessControlList_S3(CephContext *_cct) : RGWAccessControlList(_cct) {}
  ~RGWAccessControlList_S3() override {}

  bool xml_end(const char *el) override;
  void to_xml(ostream& out);

  int create_canned(ACLOwner& owner, ACLOwner& bucket_owner, const string& canned_acl);
  int create_from_grants(std::list<ACLGrant>& grants);
};

class ACLOwner_S3 : public ACLOwner, public XMLObj
{
public:
  ACLOwner_S3() {}
  ~ACLOwner_S3() override {}

  bool xml_end(const char *el) override;
  void to_xml(ostream& out);
};

class RGWEnv;

class RGWAccessControlPolicy_S3 : public RGWAccessControlPolicy, public XMLObj
{
public:
  explicit RGWAccessControlPolicy_S3(CephContext *_cct) : RGWAccessControlPolicy(_cct) {}
  ~RGWAccessControlPolicy_S3() override {}

  bool xml_end(const char *el) override;

  void to_xml(ostream& out);
  int rebuild(RGWRados *store, ACLOwner *owner, RGWAccessControlPolicy& dest);
  bool compare_group_name(string& id, ACLGroupTypeEnum group) override;

  virtual int create_canned(ACLOwner& _owner, ACLOwner& bucket_owner, const string& canned_acl) {
    RGWAccessControlList_S3& _acl = static_cast<RGWAccessControlList_S3 &>(acl);
    int ret = _acl.create_canned(_owner, bucket_owner, canned_acl);
    owner = _owner;
    return ret;
  }
  int create_from_headers(RGWRados *store, const RGWEnv *env, ACLOwner& _owner);
};





class RGWACLXMLParser_S3 : public RGWXMLParser
{
  CephContext *cct;

  XMLObj *alloc_obj(const char *el) override;
public:
  explicit RGWACLXMLParser_S3(CephContext *_cct) : cct(_cct) {}
};
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_policy_s3.h" 1






# 1 "/usr/lib/gcc/x86_64-redhat-linux/10/include/limits.h" 1 3 4
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_policy_s3.h" 2
# 18 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_policy_s3.h"
class RGWPolicyEnv {
  std::map<std::string, std::string, ltstr_nocase> vars;

public:
  void add_var(const string& name, const string& value);
  bool get_var(const string& name, string& val);
  bool get_value(const string& s, string& val, std::map<std::string, bool, ltstr_nocase>& checked_vars);
  bool match_policy_vars(map<string, bool, ltstr_nocase>& policy_vars, string& err_msg);
};

class RGWPolicyCondition;


class RGWPolicy {
  uint64_t expires;
  string expiration_str;
  std::list<RGWPolicyCondition *> conditions;
  std::list<pair<std::string, std::string> > var_checks;
  std::map<std::string, bool, ltstr_nocase> checked_vars;

public:
  off_t min_length;
  off_t max_length;

  RGWPolicy() : expires(0), min_length(0), max_length(0x7fffffffffffffffLL) {}
  ~RGWPolicy();

  int set_expires(const string& e);

  void set_var_checked(const std::string& var) {
    checked_vars[var] = true;
  }

  int add_condition(const std::string& op, const std::string& first, const std::string& second, string& err_msg);
  void add_simple_check(const std::string& var, const std::string& value) {
    var_checks.push_back(pair<string, string>(var, value));
  }

  int check(RGWPolicyEnv *env, string& err_msg);
  int from_json(bufferlist& bl, string& err_msg);
};
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc_s3.h" 1
# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc_s3.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tag_s3.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tag_s3.h"
# 1 "/usr/include/expat.h" 1 3 4
# 36 "/usr/include/expat.h" 3 4
# 1 "/usr/include/c++/10/stdlib.h" 1 3 4
# 37 "/usr/include/expat.h" 2 3 4
# 1 "/usr/include/expat_external.h" 1 3 4
# 121 "/usr/include/expat_external.h" 3 4

# 121 "/usr/include/expat_external.h" 3 4
extern "C" {
# 142 "/usr/include/expat_external.h" 3 4
typedef char XML_Char;
typedef char XML_LChar;






typedef long XML_Index;
typedef unsigned long XML_Size;



}
# 38 "/usr/include/expat.h" 2 3 4


extern "C" {


struct XML_ParserStruct;
typedef struct XML_ParserStruct *XML_Parser;

typedef unsigned char XML_Bool;
# 63 "/usr/include/expat.h" 3 4
enum XML_Status {
  XML_STATUS_ERROR = 0,

  XML_STATUS_OK = 1,

  XML_STATUS_SUSPENDED = 2

};

enum XML_Error {
  XML_ERROR_NONE,
  XML_ERROR_NO_MEMORY,
  XML_ERROR_SYNTAX,
  XML_ERROR_NO_ELEMENTS,
  XML_ERROR_INVALID_TOKEN,
  XML_ERROR_UNCLOSED_TOKEN,
  XML_ERROR_PARTIAL_CHAR,
  XML_ERROR_TAG_MISMATCH,
  XML_ERROR_DUPLICATE_ATTRIBUTE,
  XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
  XML_ERROR_PARAM_ENTITY_REF,
  XML_ERROR_UNDEFINED_ENTITY,
  XML_ERROR_RECURSIVE_ENTITY_REF,
  XML_ERROR_ASYNC_ENTITY,
  XML_ERROR_BAD_CHAR_REF,
  XML_ERROR_BINARY_ENTITY_REF,
  XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
  XML_ERROR_MISPLACED_XML_PI,
  XML_ERROR_UNKNOWN_ENCODING,
  XML_ERROR_INCORRECT_ENCODING,
  XML_ERROR_UNCLOSED_CDATA_SECTION,
  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
  XML_ERROR_NOT_STANDALONE,
  XML_ERROR_UNEXPECTED_STATE,
  XML_ERROR_ENTITY_DECLARED_IN_PE,
  XML_ERROR_FEATURE_REQUIRES_XML_DTD,
  XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,

  XML_ERROR_UNBOUND_PREFIX,

  XML_ERROR_UNDECLARING_PREFIX,
  XML_ERROR_INCOMPLETE_PE,
  XML_ERROR_XML_DECL,
  XML_ERROR_TEXT_DECL,
  XML_ERROR_PUBLICID,
  XML_ERROR_SUSPENDED,
  XML_ERROR_NOT_SUSPENDED,
  XML_ERROR_ABORTED,
  XML_ERROR_FINISHED,
  XML_ERROR_SUSPEND_PE,

  XML_ERROR_RESERVED_PREFIX_XML,
  XML_ERROR_RESERVED_PREFIX_XMLNS,
  XML_ERROR_RESERVED_NAMESPACE_URI,

  XML_ERROR_INVALID_ARGUMENT
};

enum XML_Content_Type {
  XML_CTYPE_EMPTY = 1,
  XML_CTYPE_ANY,
  XML_CTYPE_MIXED,
  XML_CTYPE_NAME,
  XML_CTYPE_CHOICE,
  XML_CTYPE_SEQ
};

enum XML_Content_Quant {
  XML_CQUANT_NONE,
  XML_CQUANT_OPT,
  XML_CQUANT_REP,
  XML_CQUANT_PLUS
};
# 155 "/usr/include/expat.h" 3 4
typedef struct XML_cp XML_Content;

struct XML_cp {
  enum XML_Content_Type type;
  enum XML_Content_Quant quant;
  XML_Char *name;
  unsigned int numchildren;
  XML_Content *children;
};





typedef void( *XML_ElementDeclHandler)(void *userData,
                                              const XML_Char *name,
                                              XML_Content *model);

 void
XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl);
# 184 "/usr/include/expat.h" 3 4
typedef void( *XML_AttlistDeclHandler)(
    void *userData, const XML_Char *elname, const XML_Char *attname,
    const XML_Char *att_type, const XML_Char *dflt, int isrequired);

 void
XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl);
# 199 "/usr/include/expat.h" 3 4
typedef void( *XML_XmlDeclHandler)(void *userData,
                                          const XML_Char *version,
                                          const XML_Char *encoding,
                                          int standalone);

 void
XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl);

typedef struct {
  void *(*malloc_fcn)(size_t size);
  void *(*realloc_fcn)(void *ptr, size_t size);
  void (*free_fcn)(void *ptr);
} XML_Memory_Handling_Suite;




 XML_Parser
XML_ParserCreate(const XML_Char *encoding);
# 230 "/usr/include/expat.h" 3 4
 XML_Parser
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
# 242 "/usr/include/expat.h" 3 4
 XML_Parser
XML_ParserCreate_MM(const XML_Char *encoding,
                    const XML_Memory_Handling_Suite *memsuite,
                    const XML_Char *namespaceSeparator);
# 256 "/usr/include/expat.h" 3 4
 XML_Bool
XML_ParserReset(XML_Parser parser, const XML_Char *encoding);




typedef void( *XML_StartElementHandler)(void *userData,
                                               const XML_Char *name,
                                               const XML_Char **atts);

typedef void( *XML_EndElementHandler)(void *userData,
                                             const XML_Char *name);


typedef void( *XML_CharacterDataHandler)(void *userData,
                                                const XML_Char *s, int len);


typedef void( *XML_ProcessingInstructionHandler)(void *userData,
                                                        const XML_Char *target,
                                                        const XML_Char *data);


typedef void( *XML_CommentHandler)(void *userData, const XML_Char *data);

typedef void( *XML_StartCdataSectionHandler)(void *userData);
typedef void( *XML_EndCdataSectionHandler)(void *userData);
# 297 "/usr/include/expat.h" 3 4
typedef void( *XML_DefaultHandler)(void *userData, const XML_Char *s,
                                          int len);




typedef void( *XML_StartDoctypeDeclHandler)(void *userData,
                                                   const XML_Char *doctypeName,
                                                   const XML_Char *sysid,
                                                   const XML_Char *pubid,
                                                   int has_internal_subset);





typedef void( *XML_EndDoctypeDeclHandler)(void *userData);
# 333 "/usr/include/expat.h" 3 4
typedef void( *XML_EntityDeclHandler)(
    void *userData, const XML_Char *entityName, int is_parameter_entity,
    const XML_Char *value, int value_length, const XML_Char *base,
    const XML_Char *systemId, const XML_Char *publicId,
    const XML_Char *notationName);

 void
XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
# 351 "/usr/include/expat.h" 3 4
typedef void( *XML_UnparsedEntityDeclHandler)(
    void *userData, const XML_Char *entityName, const XML_Char *base,
    const XML_Char *systemId, const XML_Char *publicId,
    const XML_Char *notationName);





typedef void( *XML_NotationDeclHandler)(void *userData,
                                               const XML_Char *notationName,
                                               const XML_Char *base,
                                               const XML_Char *systemId,
                                               const XML_Char *publicId);







typedef void( *XML_StartNamespaceDeclHandler)(void *userData,
                                                     const XML_Char *prefix,
                                                     const XML_Char *uri);

typedef void( *XML_EndNamespaceDeclHandler)(void *userData,
                                                   const XML_Char *prefix);
# 388 "/usr/include/expat.h" 3 4
typedef int( *XML_NotStandaloneHandler)(void *userData);
# 424 "/usr/include/expat.h" 3 4
typedef int( *XML_ExternalEntityRefHandler)(XML_Parser parser,
                                                   const XML_Char *context,
                                                   const XML_Char *base,
                                                   const XML_Char *systemId,
                                                   const XML_Char *publicId);
# 440 "/usr/include/expat.h" 3 4
typedef void( *XML_SkippedEntityHandler)(void *userData,
                                                const XML_Char *entityName,
                                                int is_parameter_entity);
# 496 "/usr/include/expat.h" 3 4
typedef struct {
  int map[256];
  void *data;
  int( *convert)(void *data, const char *s);
  void( *release)(void *data);
} XML_Encoding;
# 518 "/usr/include/expat.h" 3 4
typedef int( *XML_UnknownEncodingHandler)(void *encodingHandlerData,
                                                 const XML_Char *name,
                                                 XML_Encoding *info);

 void
XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
                      XML_EndElementHandler end);

 void
XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler handler);

 void
XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler handler);

 void
XML_SetCharacterDataHandler(XML_Parser parser,
                            XML_CharacterDataHandler handler);

 void
XML_SetProcessingInstructionHandler(XML_Parser parser,
                                    XML_ProcessingInstructionHandler handler);
 void
XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler);

 void
XML_SetCdataSectionHandler(XML_Parser parser,
                           XML_StartCdataSectionHandler start,
                           XML_EndCdataSectionHandler end);

 void
XML_SetStartCdataSectionHandler(XML_Parser parser,
                                XML_StartCdataSectionHandler start);

 void
XML_SetEndCdataSectionHandler(XML_Parser parser,
                              XML_EndCdataSectionHandler end);





 void
XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler);





 void
XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler);

 void
XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
                          XML_EndDoctypeDeclHandler end);

 void
XML_SetStartDoctypeDeclHandler(XML_Parser parser,
                               XML_StartDoctypeDeclHandler start);

 void
XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end);

 void
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
                                 XML_UnparsedEntityDeclHandler handler);

 void
XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler);

 void
XML_SetNamespaceDeclHandler(XML_Parser parser,
                            XML_StartNamespaceDeclHandler start,
                            XML_EndNamespaceDeclHandler end);

 void
XML_SetStartNamespaceDeclHandler(XML_Parser parser,
                                 XML_StartNamespaceDeclHandler start);

 void
XML_SetEndNamespaceDeclHandler(XML_Parser parser,
                               XML_EndNamespaceDeclHandler end);

 void
XML_SetNotStandaloneHandler(XML_Parser parser,
                            XML_NotStandaloneHandler handler);

 void
XML_SetExternalEntityRefHandler(XML_Parser parser,
                                XML_ExternalEntityRefHandler handler);





 void
XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg);

 void
XML_SetSkippedEntityHandler(XML_Parser parser,
                            XML_SkippedEntityHandler handler);

 void
XML_SetUnknownEncodingHandler(XML_Parser parser,
                              XML_UnknownEncodingHandler handler,
                              void *encodingHandlerData);





 void
XML_DefaultCurrent(XML_Parser parser);
# 645 "/usr/include/expat.h" 3 4
 void
XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);


 void
XML_SetUserData(XML_Parser parser, void *userData);
# 661 "/usr/include/expat.h" 3 4
 enum XML_Status
XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);





 void
XML_UseParserAsHandlerArg(XML_Parser parser);
# 690 "/usr/include/expat.h" 3 4
 enum XML_Error
XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
# 701 "/usr/include/expat.h" 3 4
 enum XML_Status
XML_SetBase(XML_Parser parser, const XML_Char *base);

 const XML_Char *
XML_GetBase(XML_Parser parser);







 int
XML_GetSpecifiedAttributeCount(XML_Parser parser);







 int
XML_GetIdAttributeIndex(XML_Parser parser);
# 757 "/usr/include/expat.h" 3 4
 enum XML_Status
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);

 void *
XML_GetBuffer(XML_Parser parser, int len);

 enum XML_Status
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
# 797 "/usr/include/expat.h" 3 4
 enum XML_Status
XML_StopParser(XML_Parser parser, XML_Bool resumable);
# 812 "/usr/include/expat.h" 3 4
 enum XML_Status
XML_ResumeParser(XML_Parser parser);

enum XML_Parsing { XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };

typedef struct {
  enum XML_Parsing parsing;
  XML_Bool finalBuffer;
} XML_ParsingStatus;






 void
XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
# 846 "/usr/include/expat.h" 3 4
 XML_Parser
XML_ExternalEntityParserCreate(XML_Parser parser, const XML_Char *context,
                               const XML_Char *encoding);

enum XML_ParamEntityParsing {
  XML_PARAM_ENTITY_PARSING_NEVER,
  XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
  XML_PARAM_ENTITY_PARSING_ALWAYS
};
# 880 "/usr/include/expat.h" 3 4
 int
XML_SetParamEntityParsing(XML_Parser parser,
                          enum XML_ParamEntityParsing parsing);







 int
XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt);




 enum XML_Error
XML_GetErrorCode(XML_Parser parser);
# 919 "/usr/include/expat.h" 3 4
 XML_Size XML_GetCurrentLineNumber(XML_Parser parser);
 XML_Size XML_GetCurrentColumnNumber(XML_Parser parser);
 XML_Index XML_GetCurrentByteIndex(XML_Parser parser);




 int
XML_GetCurrentByteCount(XML_Parser parser);
# 939 "/usr/include/expat.h" 3 4
 const char *
XML_GetInputContext(XML_Parser parser, int *offset, int *size);







 void
XML_FreeContentModel(XML_Parser parser, XML_Content *model);


 void *
__attribute__((__malloc__))
__attribute__((__alloc_size__(2)))
XML_MemMalloc(XML_Parser parser, size_t size);

 void *
__attribute__((__alloc_size__(3)))
XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);

 void
XML_MemFree(XML_Parser parser, void *ptr);


 void
XML_ParserFree(XML_Parser parser);


 const XML_LChar *
XML_ErrorString(enum XML_Error code);


 const XML_LChar *
XML_ExpatVersion(void);

typedef struct {
  int major;
  int minor;
  int micro;
} XML_Expat_Version;




 XML_Expat_Version
XML_ExpatVersionInfo(void);


enum XML_FeatureEnum {
  XML_FEATURE_END = 0,
  XML_FEATURE_UNICODE,
  XML_FEATURE_UNICODE_WCHAR_T,
  XML_FEATURE_DTD,
  XML_FEATURE_CONTEXT_BYTES,
  XML_FEATURE_MIN_SIZE,
  XML_FEATURE_SIZEOF_XML_CHAR,
  XML_FEATURE_SIZEOF_XML_LCHAR,
  XML_FEATURE_NS,
  XML_FEATURE_LARGE_SIZE,
  XML_FEATURE_ATTR_INFO

};

typedef struct {
  enum XML_FeatureEnum feature;
  const XML_LChar *name;
  long int value;
} XML_Feature;

 const XML_Feature *
XML_GetFeatureList(void);
# 1021 "/usr/include/expat.h" 3 4
}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tag_s3.h" 2





# 17 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_tag_s3.h"
class RGWObjTagEntry_S3
{
  std::string key;
  std::string val;
public:
  RGWObjTagEntry_S3() {}
  RGWObjTagEntry_S3(const std::string &k, const std::string &v):key(k),val(v) {};
  ~RGWObjTagEntry_S3() {}

  const std::string& get_key () const { return key; }
  const std::string& get_val () const { return val; }

  void dump_xml(Formatter *f) const;
  void decode_xml(XMLObj *obj);
};

class RGWObjTagSet_S3: public RGWObjTags
{
public:
  int rebuild(RGWObjTags& dest);

  void dump_xml(Formatter *f) const;
  void decode_xml(XMLObj *obj);
};

class RGWObjTagging_S3
{
  RGWObjTagSet_S3 tagset;
public:
  void decode_xml(XMLObj *obj);
  int rebuild(RGWObjTags& dest) {
    return tagset.rebuild(dest);
  }
};
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_lc_s3.h" 2

class LCFilter_S3 : public LCFilter
{
public:
  void dump_xml(Formatter *f) const;
  void decode_xml(XMLObj *obj);
};

class LCExpiration_S3 : public LCExpiration
{
private:
  bool dm_expiration{false};
public:
  LCExpiration_S3() {}
  LCExpiration_S3(string _days, string _date, bool _dm_expiration) : LCExpiration(_days, _date), dm_expiration(_dm_expiration) {}

  void dump_xml(Formatter *f) const;
  void decode_xml(XMLObj *obj);

  void set_dm_expiration(bool _dm_expiration) {
    dm_expiration = _dm_expiration;
  }

  bool get_dm_expiration() {
    return dm_expiration;
  }
};

class LCNoncurExpiration_S3 : public LCExpiration
{
public:
  LCNoncurExpiration_S3() {}

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
};

class LCMPExpiration_S3 : public LCExpiration
{
public:
  LCMPExpiration_S3() {}

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
};

class LCTransition_S3 : public LCTransition
{
public:
  LCTransition_S3() {}

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
};

class LCNoncurTransition_S3 : public LCTransition
{
public:
  LCNoncurTransition_S3() {}
  ~LCNoncurTransition_S3() {}

  void decode_xml(XMLObj *obj);
  void dump_xml(Formatter *f) const;
};


class LCRule_S3 : public LCRule
{
public:
  LCRule_S3() {}

  void dump_xml(Formatter *f) const;
  void decode_xml(XMLObj *obj);
};

class RGWLifecycleConfiguration_S3 : public RGWLifecycleConfiguration
{
public:
  explicit RGWLifecycleConfiguration_S3(CephContext *_cct) : RGWLifecycleConfiguration(_cct) {}
  RGWLifecycleConfiguration_S3() : RGWLifecycleConfiguration(nullptr) {}

  void decode_xml(XMLObj *obj);
  int rebuild(RGWRados *store, RGWLifecycleConfiguration& dest);
  void dump_xml(Formatter *f) const;
};
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_conn.h" 1







# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_client.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_client.h"
class RGWGetDataCB;

class RGWHTTPSimpleRequest : public RGWHTTPClient {
protected:
  int http_status;
  int status;

  using unique_lock = std::unique_lock<std::mutex>;

  std::mutex out_headers_lock;
  map<string, string> out_headers;
  param_vec_t params;

  bufferlist::iterator *send_iter;

  size_t max_response;
  bufferlist response;

  virtual int handle_header(const string& name, const string& val);
  void get_params_str(map<string, string>& extra_args, string& dest);

public:
  RGWHTTPSimpleRequest(CephContext *_cct, const string& _method, const string& _url,
                       param_vec_t *_headers, param_vec_t *_params) : RGWHTTPClient(_cct, _method, _url),
                http_status(0), status(0),
                send_iter(
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_client.h" 3 4
                         __null
# 34 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_client.h"
                             ),
                max_response(0) {
    set_headers(_headers);
    set_params(_params);
  }

  void set_headers(param_vec_t *_headers) {
    if (_headers)
      headers = *_headers;
  }

  void set_params(param_vec_t *_params) {
    if (_params)
      params = *_params;
  }

  int receive_header(void *ptr, size_t len) override;
  int receive_data(void *ptr, size_t len, bool *pause) override;
  int send_data(void *ptr, size_t len, bool* pause=nullptr) override;

  bufferlist& get_response() { return response; }

  void get_out_headers(map<string, string> *pheaders);

  int get_http_status() { return http_status; }
  int get_status();
};

class RGWRESTSimpleRequest : public RGWHTTPSimpleRequest {
public:
  RGWRESTSimpleRequest(CephContext *_cct, const string& _method, const string& _url,
                       param_vec_t *_headers, param_vec_t *_params) : RGWHTTPSimpleRequest(_cct, _method, _url, _headers, _params) {}

  int execute(RGWAccessKey& key, const char *method, const char *resource);
  int forward_request(RGWAccessKey& key, req_info& info, size_t max_response, bufferlist *inbl, bufferlist *outbl);
};

class RGWWriteDrainCB {
public:
  RGWWriteDrainCB() = default;
  virtual ~RGWWriteDrainCB() = default;
  virtual void notify(uint64_t pending_size) = 0;
};

class RGWRESTGenerateHTTPHeaders {
  CephContext *cct;
  RGWEnv *new_env;
  req_info *new_info;
  string method;
  string url;
  string resource;

public:
  RGWRESTGenerateHTTPHeaders(CephContext *_cct, RGWEnv *_env, req_info *_info) : cct(_cct), new_env(_env), new_info(_info) {}
  void init(const string& method, const string& url, const string& resource, const param_vec_t& params);
  void set_extra_headers(const map<string, string>& extra_headers);
  int set_obj_attrs(map<string, bufferlist>& rgw_attrs);
  void set_http_attrs(const map<string, string>& http_attrs);
  void set_policy(RGWAccessControlPolicy& policy);
  int sign(RGWAccessKey& key);

  const string& get_url() { return url; }
};

class RGWHTTPStreamRWRequest : public RGWHTTPSimpleRequest {
public:
    class ReceiveCB;

private:
  Mutex lock;
  Mutex write_lock;
  ReceiveCB *cb{nullptr};
  RGWWriteDrainCB *write_drain_cb{nullptr};
  bufferlist outbl;
  bufferlist in_data;
  size_t chunk_ofs{0};
  size_t ofs{0};
  uint64_t write_ofs{0};
  bool read_paused{false};
  bool send_paused{false};
  bool stream_writes{false};
  bool write_stream_complete{false};
protected:
  int handle_header(const string& name, const string& val) override;
public:
  int send_data(void *ptr, size_t len, bool *pause) override;
  int receive_data(void *ptr, size_t len, bool *pause) override;

  class ReceiveCB {
    protected:
      uint64_t extra_data_len{0};
    public:
      ReceiveCB() = default;
      virtual ~ReceiveCB() = default;
      virtual int handle_data(bufferlist& bl, bool *pause = nullptr) = 0;
      virtual void set_extra_data_len(uint64_t len) {
        extra_data_len = len;
      }
  };

  RGWHTTPStreamRWRequest(CephContext *_cct, const string& _method, const string& _url,
                         param_vec_t *_headers, param_vec_t *_params) : RGWHTTPSimpleRequest(_cct, _method, _url, _headers, _params),
                                                                        lock("RGWHTTPStreamRWRequest"), write_lock("RGWHTTPStreamRWRequest::write_lock") {
  }
  RGWHTTPStreamRWRequest(CephContext *_cct, const string& _method, const string& _url, ReceiveCB *_cb,
                         param_vec_t *_headers, param_vec_t *_params) : RGWHTTPSimpleRequest(_cct, _method, _url, _headers, _params),
                                                                        lock("RGWHTTPStreamRWRequest"), write_lock("RGWHTTPStreamRWRequest::write_lock"), cb(_cb) {
  }
  virtual ~RGWHTTPStreamRWRequest() override {}

  void set_outbl(bufferlist& _outbl) {
    outbl.swap(_outbl);
  }

  void set_in_cb(ReceiveCB *_cb) { cb = _cb; }
  void set_write_drain_cb(RGWWriteDrainCB *_cb) { write_drain_cb = _cb; }

  void unpause_receive();

  void add_send_data(bufferlist& bl);

  void set_stream_write(bool s);

  uint64_t get_pending_send_size();


  void finish_write();
};

class RGWRESTStreamRWRequest : public RGWHTTPStreamRWRequest {
protected:
  HostStyle host_style;
public:
  RGWRESTStreamRWRequest(CephContext *_cct, const string& _method, const string& _url, RGWHTTPStreamRWRequest::ReceiveCB *_cb,
  param_vec_t *_headers, param_vec_t *_params, HostStyle _host_style = PathStyle) : RGWHTTPStreamRWRequest(_cct, _method, _url, _cb, _headers, _params), host_style(_host_style) {
  }
  virtual ~RGWRESTStreamRWRequest() override {}

  int send_prepare(RGWAccessKey *key, map<string, string>& extra_headers, const string& resource, bufferlist *send_data = nullptr );
  int send_prepare(RGWAccessKey& key, map<string, string>& extra_headers, const rgw_obj& obj);
  int send(RGWHTTPManager *mgr);

  int send_request(RGWAccessKey& key, map<string, string>& extra_headers, const rgw_obj& obj, RGWHTTPManager *mgr);
  int send_request(RGWAccessKey *key, map<string, string>& extra_headers, const string& resource, RGWHTTPManager *mgr, bufferlist *send_data = nullptr );

  int complete_request(string *etag = nullptr,
                       real_time *mtime = nullptr,
                       uint64_t *psize = nullptr,
                       map<string, string> *pattrs = nullptr,
                       map<string, string> *pheaders = nullptr);

  void add_params(param_vec_t *params);

private:
  int do_send_prepare(RGWAccessKey *key, map<string, string>& extra_headers, const string& resource, bufferlist *send_data = nullptr );
};

class RGWRESTStreamReadRequest : public RGWRESTStreamRWRequest {
public:
  RGWRESTStreamReadRequest(CephContext *_cct, const string& _url, ReceiveCB *_cb, param_vec_t *_headers,
  param_vec_t *_params, HostStyle _host_style = PathStyle) : RGWRESTStreamRWRequest(_cct, "GET", _url, _cb, _headers, _params, _host_style) {}
};

class RGWRESTStreamHeadRequest : public RGWRESTStreamRWRequest {
public:
  RGWRESTStreamHeadRequest(CephContext *_cct, const string& _url, ReceiveCB *_cb, param_vec_t *_headers,
  param_vec_t *_params) : RGWRESTStreamRWRequest(_cct, "HEAD", _url, _cb, _headers, _params) {}
};

class RGWRESTStreamS3PutObj : public RGWRESTStreamRWRequest {
  RGWGetDataCB *out_cb;
  RGWEnv new_env;
  req_info new_info;
  RGWRESTGenerateHTTPHeaders headers_gen;
public:
  RGWRESTStreamS3PutObj(CephContext *_cct, const string& _method, const string& _url, param_vec_t *_headers,
  param_vec_t *_params, HostStyle _host_style) : RGWRESTStreamRWRequest(_cct, _method, _url, nullptr, _headers, _params, _host_style),
                out_cb(
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_client.h" 3 4
                      __null
# 211 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_client.h"
                          ), new_info(cct, &new_env), headers_gen(_cct, &new_env, &new_info) {}
  ~RGWRESTStreamS3PutObj() override;

  void send_init(rgw_obj& obj);
  int send_ready(RGWAccessKey& key, map<string, bufferlist>& rgw_attrs, bool send);
  int send_ready(RGWAccessKey& key, const map<string, string>& http_attrs,
                 RGWAccessControlPolicy& policy, bool send);
  int send_ready(RGWAccessKey& key, bool send);

  int put_obj_init(RGWAccessKey& key, rgw_obj& obj, uint64_t obj_size, map<string, bufferlist>& attrs, bool send);

  RGWGetDataCB *get_out_cb() { return out_cb; }
};
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_conn.h" 2





class CephContext;
class RGWSI_Zone;

template <class T>
static int parse_decode_json(T& t, bufferlist& bl)
{
  JSONParser p;
  if (!p.parse(bl.c_str(), bl.length())) {
    return -
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_conn.h" 3 4
           22
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_conn.h"
                 ;
  }

  try {
    decode_json_obj(t, &p);
  } catch (JSONDecoder::err& e) {
    return -
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_conn.h" 3 4
           22
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_conn.h"
                 ;
  }
  return 0;
}

struct rgw_http_param_pair {
  const char *key;
  const char *val;
};


inline void append_param_list(param_vec_t& params, const rgw_http_param_pair* pp)
{
  while (pp && pp->key) {
    string k = pp->key;
    string v = (pp->val ? pp->val : "");
    params.emplace_back(make_pair(std::move(k), std::move(v)));
    ++pp;
  }
}


inline param_vec_t make_param_list(const rgw_http_param_pair* pp)
{
  param_vec_t params;
  append_param_list(params, pp);
  return params;
}

inline param_vec_t make_param_list(const map<string, string> *pp)
{
  param_vec_t params;
  if (!pp) {
    return params;
  }
  for (auto iter : *pp) {
    params.emplace_back(make_pair(iter.first, iter.second));
  }
  return params;
}

class RGWRESTConn
{
  CephContext *cct;
  vector<string> endpoints;
  RGWAccessKey key;
  string self_zone_group;
  string remote_id;
  HostStyle host_style;
  std::atomic<int64_t> counter = { 0 };

public:

  RGWRESTConn(CephContext *_cct, RGWSI_Zone *zone_svc, const string& _remote_id, const list<string>& endpoints, HostStyle _host_style = PathStyle);
  RGWRESTConn(CephContext *_cct, RGWSI_Zone *zone_svc, const string& _remote_id, const list<string>& endpoints, RGWAccessKey _cred, HostStyle _host_style = PathStyle);


  RGWRESTConn(RGWRESTConn&& other);
  RGWRESTConn& operator=(RGWRESTConn&& other);
  virtual ~RGWRESTConn() = default;

  int get_url(string& endpoint);
  string get_url();
  const string& get_self_zonegroup() {
    return self_zone_group;
  }
  const string& get_remote_id() {
    return remote_id;
  }
  RGWAccessKey& get_key() {
    return key;
  }

  HostStyle get_host_style() {
    return host_style;
  }

  CephContext *get_ctx() {
    return cct;
  }
  size_t get_endpoint_count() const { return endpoints.size(); }

  virtual void populate_params(param_vec_t& params, const rgw_user *uid, const string& zonegroup);


  int forward(const rgw_user& uid, req_info& info, obj_version *objv, size_t max_response, bufferlist *inbl, bufferlist *outbl);



  int put_obj_send_init(rgw_obj& obj, const rgw_http_param_pair *extra_params, RGWRESTStreamS3PutObj **req);
  int put_obj_async(const rgw_user& uid, rgw_obj& obj, uint64_t obj_size,
                    map<string, bufferlist>& attrs, bool send, RGWRESTStreamS3PutObj **req);
  int complete_request(RGWRESTStreamS3PutObj *req, string& etag, ceph::real_time *mtime);

  struct get_obj_params {
    rgw_user uid;
    req_info *info{nullptr};
    const ceph::real_time *mod_ptr{nullptr};
    const ceph::real_time *unmod_ptr{nullptr};
    bool high_precision_time{true};

    string etag;

    uint32_t mod_zone_id{0};
    uint64_t mod_pg_ver{0};

    bool prepend_metadata{false};
    bool get_op{false};
    bool rgwx_stat{false};
    bool sync_manifest{false};

    bool skip_decrypt{true};
    RGWHTTPStreamRWRequest::ReceiveCB *cb{nullptr};

    bool range_is_set{false};
    uint64_t range_start{0};
    uint64_t range_end{0};
  };

  int get_obj(const rgw_obj& obj, const get_obj_params& params, bool send, RGWRESTStreamRWRequest **req);

  int get_obj(const rgw_user& uid, req_info *info , const rgw_obj& obj,
              const ceph::real_time *mod_ptr, const ceph::real_time *unmod_ptr,
              uint32_t mod_zone_id, uint64_t mod_pg_ver,
              bool prepend_metadata, bool get_op, bool rgwx_stat, bool sync_manifest,
              bool skip_decrypt, bool send, RGWHTTPStreamRWRequest::ReceiveCB *cb, RGWRESTStreamRWRequest **req);
  int complete_request(RGWRESTStreamRWRequest *req,
                       string *etag,
                       ceph::real_time *mtime,
                       uint64_t *psize,
                       map<string, string> *pattrs,
                       map<string, string> *pheaders);

  int get_resource(const string& resource,
     param_vec_t *extra_params,
                   map<string, string>* extra_headers,
                   bufferlist& bl,
                   bufferlist *send_data = nullptr,
                   RGWHTTPManager *mgr = nullptr);

  template <class T>
  int get_json_resource(const string& resource, param_vec_t *params, bufferlist *in_data, T& t);
  template <class T>
  int get_json_resource(const string& resource, param_vec_t *params, T& t);
  template <class T>
  int get_json_resource(const string& resource, const rgw_http_param_pair *pp, T& t);

private:
  void populate_zonegroup(param_vec_t& params, const string& zonegroup) {
    if (!zonegroup.empty()) {
      params.push_back(param_pair_t("rgwx-" "zonegroup", zonegroup));
    }
  }
  void populate_uid(param_vec_t& params, const rgw_user *uid) {
    if (uid) {
      string uid_str = uid->to_str();
      if (!uid->empty()){
        params.push_back(param_pair_t("rgwx-" "uid", uid_str));
      }
    }
  }
};

class S3RESTConn : public RGWRESTConn {

public:

  S3RESTConn(CephContext *_cct, RGWSI_Zone *svc_zone, const string& _remote_id, const list<string>& endpoints, HostStyle _host_style = PathStyle) :
    RGWRESTConn(_cct, svc_zone, _remote_id, endpoints, _host_style) {}

  S3RESTConn(CephContext *_cct, RGWSI_Zone *svc_zone, const string& _remote_id, const list<string>& endpoints, RGWAccessKey _cred, HostStyle _host_style = PathStyle):
    RGWRESTConn(_cct, svc_zone, _remote_id, endpoints, _cred, _host_style) {}
  ~S3RESTConn() override = default;

  void populate_params(param_vec_t& params, const rgw_user *uid, const string& zonegroup) override {

    return;
  }
};


template<class T>
int RGWRESTConn::get_json_resource(const string& resource, param_vec_t *params, bufferlist *in_data, T& t)
{
  bufferlist bl;
  int ret = get_resource(resource, params, nullptr, bl, in_data);
  if (ret < 0) {
    return ret;
  }

  ret = parse_decode_json(t, bl);
  if (ret < 0) {
    return ret;
  }

  return 0;
}

template<class T>
int RGWRESTConn::get_json_resource(const string& resource, param_vec_t *params, T& t)
{
  return get_json_resource(resource, params, nullptr, t);
}

template<class T>
int RGWRESTConn::get_json_resource(const string& resource, const rgw_http_param_pair *pp, T& t)
{
  param_vec_t params = make_param_list(pp);
  return get_json_resource(resource, &params, t);
}

class RGWStreamIntoBufferlist : public RGWHTTPStreamRWRequest::ReceiveCB {
  bufferlist& bl;
public:
  explicit RGWStreamIntoBufferlist(bufferlist& _bl) : bl(_bl) {}
  int handle_data(bufferlist& inbl, bool *pause) override {
    bl.claim_append(inbl);
    return inbl.length();
  }
};

class RGWRESTReadResource : public RefCountedObject, public RGWIOProvider {
  CephContext *cct;
  RGWRESTConn *conn;
  string resource;
  param_vec_t params;
  map<string, string> headers;
  bufferlist bl;
  RGWStreamIntoBufferlist cb;

  RGWHTTPManager *mgr;
  RGWRESTStreamReadRequest req;

  void init_common(param_vec_t *extra_headers);

public:
  RGWRESTReadResource(RGWRESTConn *_conn,
        const string& _resource,
        const rgw_http_param_pair *pp,
        param_vec_t *extra_headers,
        RGWHTTPManager *_mgr);

  RGWRESTReadResource(RGWRESTConn *_conn,
        const string& _resource,
        param_vec_t& _params,
        param_vec_t *extra_headers,
        RGWHTTPManager *_mgr);
  ~RGWRESTReadResource() = default;

  rgw_io_id get_io_id(int io_type) {
    return req.get_io_id(io_type);
  }

  void set_io_user_info(void *user_info) override {
    req.set_io_user_info(user_info);
  }

  void *get_io_user_info() override {
    return req.get_io_user_info();
  }

  template <class T>
  int decode_resource(T *dest);

  int read();

  int aio_read();

  string to_str() {
    return req.to_str();
  }

  int get_http_status() {
    return req.get_http_status();
  }

  int wait(bufferlist *pbl) {
    int ret = req.wait();
    if (ret < 0) {
      return ret;
    }

    if (req.get_status() < 0) {
      return req.get_status();
    }
    *pbl = bl;
    return 0;
  }

  template <class T>
  int wait(T *dest);

  template <class T>
  int fetch(T *dest);
};


template <class T>
int RGWRESTReadResource::decode_resource(T *dest)
{
  int ret = req.get_status();
  if (ret < 0) {
    return ret;
  }
  ret = parse_decode_json(*dest, bl);
  if (ret < 0) {
    return ret;
  }
  return 0;
}

template <class T>
int RGWRESTReadResource::fetch(T *dest)
{
  int ret = read();
  if (ret < 0) {
    return ret;
  }

  ret = decode_resource(dest);
  if (ret < 0) {
    return ret;
  }
  return 0;
}

template <class T>
int RGWRESTReadResource::wait(T *dest)
{
  int ret = req.wait();
  if (ret < 0) {
    return ret;
  }

  ret = decode_resource(dest);
  if (ret < 0) {
    return ret;
  }
  return 0;
}

class RGWRESTSendResource : public RefCountedObject, public RGWIOProvider {
  CephContext *cct;
  RGWRESTConn *conn;
  string method;
  string resource;
  param_vec_t params;
  map<string, string> headers;
  bufferlist bl;
  RGWStreamIntoBufferlist cb;

  RGWHTTPManager *mgr;
  RGWRESTStreamRWRequest req;

  void init_common(param_vec_t *extra_headers);

public:
  RGWRESTSendResource(RGWRESTConn *_conn,
                      const string& _method,
        const string& _resource,
        const rgw_http_param_pair *pp,
        param_vec_t *extra_headers,
        RGWHTTPManager *_mgr);

  RGWRESTSendResource(RGWRESTConn *_conn,
                      const string& _method,
        const string& _resource,
        param_vec_t& params,
        param_vec_t *extra_headers,
        RGWHTTPManager *_mgr);

  ~RGWRESTSendResource() = default;

  rgw_io_id get_io_id(int io_type) {
    return req.get_io_id(io_type);
  }

  void set_io_user_info(void *user_info) override {
    req.set_io_user_info(user_info);
  }

  void *get_io_user_info() override {
    return req.get_io_user_info();
  }

  int send(bufferlist& bl);

  int aio_send(bufferlist& bl);

  string to_str() {
    return req.to_str();
  }

  int get_http_status() {
    return req.get_http_status();
  }

  template <class E = int>
  int wait(bufferlist *pbl, E *err_result = nullptr) {
    int ret = req.wait();
    *pbl = bl;

    if (ret < 0 && err_result ) {
      ret = parse_decode_json(*err_result, bl);
    }

    return req.get_status();
  }

  template <class T, class E = int>
  int wait(T *dest, E *err_result = nullptr);
};

template <class T, class E=int>
int RGWRESTSendResource::wait(T *dest, E *err_result)
{
  int ret = req.wait();
  if (ret >= 0) {
    ret = req.get_status();
  }

  if (ret < 0 && err_result) {
    ret = parse_decode_json(*err_result, bl);
  }

  if (ret < 0) {
    return ret;
  }

  ret = parse_decode_json(*dest, bl);
  if (ret < 0) {
    return ret;
  }
  return 0;

}

class RGWRESTPostResource : public RGWRESTSendResource {
public:
  RGWRESTPostResource(RGWRESTConn *_conn,
        const string& _resource,
        const rgw_http_param_pair *pp,
        param_vec_t *extra_headers,
        RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "POST", _resource,
                                                                  pp, extra_headers, _mgr) {}

  RGWRESTPostResource(RGWRESTConn *_conn,
        const string& _resource,
        param_vec_t& params,
        param_vec_t *extra_headers,
        RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "POST", _resource,
                                                                  params, extra_headers, _mgr) {}

};

class RGWRESTPutResource : public RGWRESTSendResource {
public:
  RGWRESTPutResource(RGWRESTConn *_conn,
       const string& _resource,
       const rgw_http_param_pair *pp,
       param_vec_t *extra_headers,
       RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "PUT", _resource,
                                                                  pp, extra_headers, _mgr) {}

  RGWRESTPutResource(RGWRESTConn *_conn,
       const string& _resource,
       param_vec_t& params,
       param_vec_t *extra_headers,
       RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "PUT", _resource,
                                                                  params, extra_headers, _mgr) {}

};

class RGWRESTDeleteResource : public RGWRESTSendResource {
public:
  RGWRESTDeleteResource(RGWRESTConn *_conn,
       const string& _resource,
       const rgw_http_param_pair *pp,
       param_vec_t *extra_headers,
       RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "DELETE", _resource,
                                                                  pp, extra_headers, _mgr) {}

  RGWRESTDeleteResource(RGWRESTConn *_conn,
       const string& _resource,
       param_vec_t& params,
       param_vec_t *extra_headers,
       RGWHTTPManager *_mgr) : RGWRESTSendResource(_conn, "DELETE", _resource,
                                                                  params, extra_headers, _mgr) {}

};
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
# 1 "/usr/include/ldap.h" 1 3 4
# 30 "/usr/include/ldap.h" 3 4
# 1 "/usr/include/lber.h" 1 3 4
# 29 "/usr/include/lber.h" 3 4
# 1 "/usr/include/lber_types.h" 1 3 4
# 24 "/usr/include/lber_types.h" 3 4
# 1 "/usr/include/ldap_cdefs.h" 1 3 4
# 25 "/usr/include/lber_types.h" 2 3 4


# 26 "/usr/include/lber_types.h" 3 4
extern "C" {
# 43 "/usr/include/lber_types.h" 3 4
typedef int ber_int_t;


typedef signed int ber_sint_t;
typedef unsigned int ber_uint_t;


typedef unsigned long ber_tag_t;


typedef int ber_socket_t;


typedef unsigned long ber_len_t;


typedef signed long ber_slen_t;

}
# 30 "/usr/include/lber.h" 2 3 4


extern "C" {
# 117 "/usr/include/lber.h" 3 4
typedef int* (*BER_ERRNO_FN) ( void );

typedef void (*BER_LOG_PRINT_FN) ( const char *buf );

typedef void* (BER_MEMALLOC_FN) ( ber_len_t size, void *ctx );
typedef void* (BER_MEMCALLOC_FN) ( ber_len_t n, ber_len_t size, void *ctx );
typedef void* (BER_MEMREALLOC_FN) ( void *p, ber_len_t size, void *ctx );
typedef void (BER_MEMFREE_FN) ( void *p, void *ctx );

typedef struct lber_memory_fns {
 BER_MEMALLOC_FN *bmf_malloc;
 BER_MEMCALLOC_FN *bmf_calloc;
 BER_MEMREALLOC_FN *bmf_realloc;
 BER_MEMFREE_FN *bmf_free;
} BerMemoryFunctions;
# 164 "/usr/include/lber.h" 3 4
extern char ber_pvt_opt_on;






typedef struct berelement BerElement;
typedef struct sockbuf Sockbuf;

typedef struct sockbuf_io Sockbuf_IO;


typedef struct sockbuf_io_desc {
 int sbiod_level;
 Sockbuf *sbiod_sb;
 Sockbuf_IO *sbiod_io;
 void *sbiod_pvt;
 struct sockbuf_io_desc *sbiod_next;
} Sockbuf_IO_Desc;


struct sockbuf_io {
 int (*sbi_setup)( Sockbuf_IO_Desc *sbiod, void *arg );
 int (*sbi_remove)( Sockbuf_IO_Desc *sbiod );
 int (*sbi_ctrl)( Sockbuf_IO_Desc *sbiod, int opt, void *arg);

 ber_slen_t (*sbi_read)( Sockbuf_IO_Desc *sbiod, void *buf,
  ber_len_t len );
 ber_slen_t (*sbi_write)( Sockbuf_IO_Desc *sbiod, void *buf,
  ber_len_t len );

 int (*sbi_close)( Sockbuf_IO_Desc *sbiod );
};
# 212 "/usr/include/lber.h" 3 4
typedef struct berval {
 ber_len_t bv_len;
 char *bv_val;
} BerValue;

typedef BerValue *BerVarray;






extern void
ber_error_print ( const char *data )
                         ;

extern void
ber_bprint ( const char *data, ber_len_t len )
                                        ;

extern void
ber_dump ( BerElement *ber, int inout )
                              ;




typedef int (*BERDecodeCallback) ( BerElement *ber, void *data, int mode )


            ;

extern ber_tag_t
ber_get_tag ( BerElement *ber )
                   ;

extern ber_tag_t
ber_skip_tag ( BerElement *ber, ber_len_t *len )

                  ;

extern ber_tag_t
ber_peek_tag ( BerElement *ber, ber_len_t *len )

                  ;

extern ber_tag_t
ber_skip_element ( BerElement *ber, struct berval *bv )

                     ;

extern ber_tag_t
ber_peek_element ( const BerElement *ber, struct berval *bv )

                     ;

extern ber_tag_t
ber_get_int ( BerElement *ber, ber_int_t *num )

                  ;

extern ber_tag_t
ber_get_enum ( BerElement *ber, ber_int_t *num )

                  ;

extern ber_tag_t
ber_get_stringb ( BerElement *ber, char *buf, ber_len_t *len )


                  ;
# 291 "/usr/include/lber.h" 3 4
extern ber_tag_t
ber_get_stringbv ( BerElement *ber, struct berval *bv, int options )


               ;

extern ber_tag_t
ber_get_stringa ( BerElement *ber, char **buf )

              ;

extern ber_tag_t
ber_get_stringal ( BerElement *ber, struct berval **bv )

                      ;

extern ber_tag_t
ber_get_bitstringa ( BerElement *ber, char **buf, ber_len_t *len )


                  ;

extern ber_tag_t
ber_get_null ( BerElement *ber )
                   ;

extern ber_tag_t
ber_get_boolean ( BerElement *ber, ber_int_t *boolval )

                      ;

extern ber_tag_t
ber_first_element ( BerElement *ber, ber_len_t *len, char **last )


               ;

extern ber_tag_t
ber_next_element ( BerElement *ber, ber_len_t *len, const char *last )


                         ;

extern ber_tag_t
ber_scanf ( BerElement *ber, const char *fmt, ... )


       ;

extern int
ber_decode_oid ( struct berval *in, struct berval *out )

                      ;




extern int
ber_encode_oid ( struct berval *in, struct berval *out )

                      ;

typedef int (*BEREncodeCallback) ( BerElement *ber, void *data )

              ;

extern int
ber_put_enum ( BerElement *ber, ber_int_t num, ber_tag_t tag )


                 ;

extern int
ber_put_int ( BerElement *ber, ber_int_t num, ber_tag_t tag )


                 ;

extern int
ber_put_ostring ( BerElement *ber, const char *str, ber_len_t len, ber_tag_t tag )



                 ;

extern int
ber_put_berval ( BerElement *ber, struct berval *bv, ber_tag_t tag )


                 ;

extern int
ber_put_string ( BerElement *ber, const char *str, ber_tag_t tag )


                 ;

extern int
ber_put_bitstring ( BerElement *ber, const char *str, ber_len_t bitlen, ber_tag_t tag )



                 ;

extern int
ber_put_null ( BerElement *ber, ber_tag_t tag )

                 ;

extern int
ber_put_boolean ( BerElement *ber, ber_int_t boolval, ber_tag_t tag )


                 ;

extern int
ber_start_seq ( BerElement *ber, ber_tag_t tag )

                 ;

extern int
ber_start_set ( BerElement *ber, ber_tag_t tag )

                 ;

extern int
ber_put_seq ( BerElement *ber )
                   ;

extern int
ber_put_set ( BerElement *ber )
                   ;

extern int
ber_printf ( BerElement *ber, const char *fmt, ... )


       ;






extern ber_slen_t
ber_skip_data ( BerElement *ber, ber_len_t len )

                 ;

extern ber_slen_t
ber_read ( BerElement *ber, char *buf, ber_len_t len )


                 ;

extern ber_slen_t
ber_write ( BerElement *ber, const char *buf, ber_len_t len, int zero )



            ;

extern void
ber_free ( BerElement *ber, int freebuf )

               ;

extern void
ber_free_buf ( BerElement *ber );

extern int
ber_flush2 ( Sockbuf *sb, BerElement *ber, int freeit )


              ;





extern int
ber_flush ( Sockbuf *sb, BerElement *ber, int freeit )


              ;

extern BerElement *
ber_alloc ( void );

extern BerElement *
der_alloc ( void );

extern BerElement *
ber_alloc_t ( int beroptions )
                  ;

extern BerElement *
ber_dup ( BerElement *ber )
                   ;

extern ber_tag_t
ber_get_next ( Sockbuf *sb, ber_len_t *len, BerElement *ber )


                   ;

extern void
ber_init2 ( BerElement *ber, struct berval *bv, int options )


               ;

extern void
ber_init_w_nullc ( BerElement *ber, int options )

               ;

extern void
ber_reset ( BerElement *ber, int was_writing )

                   ;

extern BerElement *
ber_init ( struct berval *bv )
                     ;

extern int
ber_flatten ( BerElement *ber, struct berval **bvPtr )

                         ;

extern int
ber_flatten2 ( BerElement *ber, struct berval *bv, int alloc )


             ;

extern int
ber_remaining ( BerElement *ber )
                   ;





extern int
ber_get_option ( void *item, int option, void *outvalue)


                 ;

extern int
ber_set_option ( void *item, int option, const void *invalue)


                           ;





extern Sockbuf *
ber_sockbuf_alloc ( void )
        ;

extern void
ber_sockbuf_free ( Sockbuf *sb )
               ;

extern int
ber_sockbuf_add_io ( Sockbuf *sb, Sockbuf_IO *sbio, int layer, void *arg )



             ;

extern int
ber_sockbuf_remove_io ( Sockbuf *sb, Sockbuf_IO *sbio, int layer )


             ;

extern int
ber_sockbuf_ctrl ( Sockbuf *sb, int opt, void *arg )


             ;

extern Sockbuf_IO ber_sockbuf_io_tcp;
extern Sockbuf_IO ber_sockbuf_io_readahead;
extern Sockbuf_IO ber_sockbuf_io_fd;
extern Sockbuf_IO ber_sockbuf_io_debug;
extern Sockbuf_IO ber_sockbuf_io_udp;




extern void *
ber_memalloc ( ber_len_t s )
               ;

extern void *
ber_memrealloc ( void* p, ber_len_t s )

               ;

extern void *
ber_memcalloc ( ber_len_t n, ber_len_t s )

               ;

extern void
ber_memfree ( void* p )
           ;

extern void
ber_memvfree ( void** vector )
                 ;

extern void
ber_bvfree ( struct berval *bv )
                     ;

extern void
ber_bvecfree ( struct berval **bv )
                      ;

extern int
ber_bvecadd ( struct berval ***bvec, struct berval *bv )

                     ;

extern struct berval *
ber_dupbv ( struct berval *dst, struct berval *src )
                                          ;

extern struct berval *
ber_bvdup ( struct berval *src )
                      ;

extern struct berval *
ber_mem2bv ( const char *, ber_len_t len, int duplicate, struct berval *bv)
                                                                     ;

extern struct berval *
ber_str2bv ( const char *, ber_len_t len, int duplicate, struct berval *bv)
                                                                     ;




extern char *
ber_strdup ( const char * )
                     ;

extern ber_len_t
ber_strnlen ( const char *s, ber_len_t len )
                                     ;

extern char *
ber_strndup ( const char *s, ber_len_t l )
                                   ;

extern struct berval *
ber_bvreplace ( struct berval *dst, const struct berval *src )
                                                     ;

extern void
ber_bvarray_free ( BerVarray p );

extern int
ber_bvarray_add ( BerVarray *p, BerValue *bv );
# 672 "/usr/include/lber.h" 3 4
extern int * ber_errno_addr (void);






}
# 31 "/usr/include/ldap.h" 2 3 4


# 1 "/usr/include/ldap_features.h" 1 3 4
# 34 "/usr/include/ldap.h" 2 3 4

extern "C" {
# 225 "/usr/include/ldap.h" 3 4
typedef struct ldapapiinfo {
 int ldapai_info_version;

 int ldapai_api_version;
 int ldapai_protocol_version;
 char **ldapai_extensions;
 char *ldapai_vendor_name;
 int ldapai_vendor_version;
} LDAPAPIInfo;

typedef struct ldap_apifeature_info {
 int ldapaif_info_version;

 char* ldapaif_name;
 int ldapaif_version;
} LDAPAPIFeatureInfo;




typedef struct ldapcontrol {
 char * ldctl_oid;
 struct berval ldctl_value;
 char ldctl_iscritical;
} LDAPControl;
# 722 "/usr/include/ldap.h" 3 4
typedef struct ldapmsg LDAPMessage;


typedef struct ldapmod {
 int mod_op;
# 739 "/usr/include/ldap.h" 3 4
 char *mod_type;
 union mod_vals_u {
  char **modv_strvals;
  struct berval **modv_bvals;
 } mod_vals;


} LDAPMod;






typedef struct ldap LDAP;
# 770 "/usr/include/ldap.h" 3 4
typedef struct ldap_url_desc {
 struct ldap_url_desc *lud_next;
 char *lud_scheme;
 char *lud_host;
 int lud_port;
 char *lud_dn;
 char **lud_attrs;
 int lud_scope;
 char *lud_filter;
 char **lud_exts;
 int lud_crit_exts;
} LDAPURLDesc;
# 800 "/usr/include/ldap.h" 3 4
typedef struct ldap_sync_t ldap_sync_t;

typedef enum {

 LDAP_SYNC_CAPI_NONE = -1,

 LDAP_SYNC_CAPI_PHASE_FLAG = 0x10U,
 LDAP_SYNC_CAPI_IDSET_FLAG = 0x20U,
 LDAP_SYNC_CAPI_DONE_FLAG = 0x40U,


 LDAP_SYNC_CAPI_PRESENT = 0,
 LDAP_SYNC_CAPI_ADD = 1,
 LDAP_SYNC_CAPI_MODIFY = 2,
 LDAP_SYNC_CAPI_DELETE = 3,


 LDAP_SYNC_CAPI_PRESENTS = ( LDAP_SYNC_CAPI_PHASE_FLAG | LDAP_SYNC_CAPI_PRESENT ),
 LDAP_SYNC_CAPI_DELETES = ( LDAP_SYNC_CAPI_PHASE_FLAG | LDAP_SYNC_CAPI_DELETE ),

 LDAP_SYNC_CAPI_PRESENTS_IDSET = ( LDAP_SYNC_CAPI_PRESENTS | LDAP_SYNC_CAPI_IDSET_FLAG ),
 LDAP_SYNC_CAPI_DELETES_IDSET = ( LDAP_SYNC_CAPI_DELETES | LDAP_SYNC_CAPI_IDSET_FLAG ),

 LDAP_SYNC_CAPI_DONE = ( LDAP_SYNC_CAPI_DONE_FLAG | LDAP_SYNC_CAPI_PRESENTS )
} ldap_sync_refresh_t;
# 834 "/usr/include/ldap.h" 3 4
typedef int (*ldap_sync_search_entry_f) ( ldap_sync_t *ls, LDAPMessage *msg, struct berval *entryUUID, ldap_sync_refresh_t phase )



                              ;





typedef int (*ldap_sync_search_reference_f) ( ldap_sync_t *ls, LDAPMessage *msg )

                      ;
# 861 "/usr/include/ldap.h" 3 4
typedef int (*ldap_sync_intermediate_f) ( ldap_sync_t *ls, LDAPMessage *msg, BerVarray syncUUIDs, ldap_sync_refresh_t phase )



                              ;






typedef int (*ldap_sync_search_result_f) ( ldap_sync_t *ls, LDAPMessage *msg, int refreshDeletes )


                         ;





struct ldap_sync_t {

 char *ls_base;
 int ls_scope;
 char *ls_filter;
 char **ls_attrs;
 int ls_timelimit;
 int ls_sizelimit;


 int ls_timeout;


 ldap_sync_search_entry_f ls_search_entry;
 ldap_sync_search_reference_f ls_search_reference;
 ldap_sync_intermediate_f ls_intermediate;
 ldap_sync_search_result_f ls_search_result;


 void *ls_private;


 LDAP *ls_ld;







 int ls_msgid;



 int ls_reloadHint;


 struct berval ls_cookie;


 ldap_sync_refresh_t ls_refreshPhase;
};
# 931 "/usr/include/ldap.h" 3 4
struct ldap_conncb;
struct sockaddr;


typedef int (ldap_conn_add_f) ( LDAP *ld, Sockbuf *sb, LDAPURLDesc *srv, struct sockaddr *addr, struct ldap_conncb *ctx )
                           ;

typedef void (ldap_conn_del_f) ( LDAP *ld, Sockbuf *sb, struct ldap_conncb *ctx );




typedef struct ldap_conncb {
 ldap_conn_add_f *lc_add;
 ldap_conn_del_f *lc_del;
 void *lc_arg;
} ldap_conncb;





struct timeval;




extern int
ldap_get_option ( LDAP *ld, int option, void *outvalue)


                 ;

extern int
ldap_set_option ( LDAP *ld, int option, const void *invalue)


                           ;


typedef int (LDAP_REBIND_PROC) ( LDAP *ld, const char *url, ber_tag_t request, ber_int_t msgid, void *params )


                ;

extern int
ldap_set_rebind_proc ( LDAP *ld, LDAP_REBIND_PROC *rebind_proc, void *params )


                ;


typedef int (LDAP_NEXTREF_PROC) ( LDAP *ld, char ***refsp, int *cntp, void *params )

                ;

extern int
ldap_set_nextref_proc ( LDAP *ld, LDAP_NEXTREF_PROC *nextref_proc, void *params )


                ;


typedef int (LDAP_URLLIST_PROC) ( LDAP *ld, LDAPURLDesc **urllist, LDAPURLDesc **url, void *params )



                ;

extern int
ldap_set_urllist_proc ( LDAP *ld, LDAP_URLLIST_PROC *urllist_proc, void *params )


                ;





extern int
ldap_create_control ( const char *requestOID, BerElement *ber, int iscritical, LDAPControl **ctrlp )



                       ;

extern LDAPControl *
ldap_find_control ( const char *oid, LDAPControl **ctrls )

                       ;


extern int
ldap_control_create ( const char *requestOID, int iscritical, struct berval *value, int dupval, LDAPControl **ctrlp )




                       ;

extern LDAPControl *
ldap_control_find ( const char *oid, LDAPControl **ctrls, LDAPControl ***nextctrlp )


                            ;

extern void
ldap_control_free ( LDAPControl *ctrl )
                     ;

extern void
ldap_controls_free ( LDAPControl **ctrls )
                       ;

extern LDAPControl **
ldap_controls_dup ( LDAPControl *const *controls )
                                     ;

extern LDAPControl *
ldap_control_dup ( const LDAPControl *c )
                             ;




extern int
ldap_domain2dn ( const char* domain, char** dn )

             ;

extern int
ldap_dn2domain ( const char* dn, char** domain )

                 ;

extern int
ldap_domain2hostlist ( const char *domain, char** hostlist )

                   ;




extern int
ldap_extended_operation ( LDAP *ld, const char *reqoid, struct berval *reqdata, LDAPControl **serverctrls, LDAPControl **clientctrls, int *msgidp )





                  ;

extern int
ldap_extended_operation_s ( LDAP *ld, const char *reqoid, struct berval *reqdata, LDAPControl **serverctrls, LDAPControl **clientctrls, char **retoidp, struct berval **retdatap )






                            ;

extern int
ldap_parse_extended_result ( LDAP *ld, LDAPMessage *res, char **retoidp, struct berval **retdatap, int freeit )




                 ;

extern int
ldap_parse_intermediate ( LDAP *ld, LDAPMessage *res, char **retoidp, struct berval **retdatap, LDAPControl ***serverctrls, int freeit )





                 ;





extern int
ldap_abandon_ext ( LDAP *ld, int msgid, LDAPControl **serverctrls, LDAPControl **clientctrls )



                              ;


extern int
ldap_abandon ( LDAP *ld, int msgid )

             ;





extern int
ldap_add_ext ( LDAP *ld, const char *dn, LDAPMod **attrs, LDAPControl **serverctrls, LDAPControl **clientctrls, int *msgidp )





                  ;

extern int
ldap_add_ext_s ( LDAP *ld, const char *dn, LDAPMod **attrs, LDAPControl **serverctrls, LDAPControl **clientctrls )




                              ;


extern int
ldap_add ( LDAP *ld, const char *dn, LDAPMod **attrs )


                   ;

extern int
ldap_add_s ( LDAP *ld, const char *dn, LDAPMod **attrs )


                   ;






extern int
ldap_sasl_bind ( LDAP *ld, const char *dn, const char *mechanism, struct berval *cred, LDAPControl **serverctrls, LDAPControl **clientctrls, int *msgidp )






                  ;
# 1190 "/usr/include/ldap.h" 3 4
typedef int (LDAP_SASL_INTERACT_PROC) ( LDAP *ld, unsigned flags, void* defaults, void *interact )
                                                            ;

extern int
ldap_sasl_interactive_bind ( LDAP *ld, const char *dn, const char *saslMechanism, LDAPControl **serverControls, LDAPControl **clientControls, unsigned flags, LDAP_SASL_INTERACT_PROC *proc, void *defaults, LDAPMessage *result, const char **rmech, int *msgid )
# 1211 "/usr/include/ldap.h" 3 4
              ;

extern int
ldap_sasl_interactive_bind_s ( LDAP *ld, const char *dn, const char *saslMechanism, LDAPControl **serverControls, LDAPControl **clientControls, unsigned flags, LDAP_SASL_INTERACT_PROC *proc, void *defaults )
# 1224 "/usr/include/ldap.h" 3 4
                  ;

extern int
ldap_sasl_bind_s ( LDAP *ld, const char *dn, const char *mechanism, struct berval *cred, LDAPControl **serverctrls, LDAPControl **clientctrls, struct berval **servercredp )






                               ;

extern int
ldap_parse_sasl_bind_result ( LDAP *ld, LDAPMessage *res, struct berval **servercredp, int freeit )



                 ;






extern int
ldap_bind ( LDAP *ld, const char *who, const char *passwd, int authmethod )



                  ;

extern int
ldap_bind_s ( LDAP *ld, const char *who, const char *cred, int authmethod )



                  ;




extern int
ldap_simple_bind ( LDAP *ld, const char *who, const char *passwd )


                           ;

extern int
ldap_simple_bind_s ( LDAP *ld, const char *who, const char *passwd )


                           ;







extern int
ldap_compare_ext ( LDAP *ld, const char *dn, const char *attr, struct berval *bvalue, LDAPControl **serverctrls, LDAPControl **clientctrls, int *msgidp )






                  ;

extern int
ldap_compare_ext_s ( LDAP *ld, const char *dn, const char *attr, struct berval *bvalue, LDAPControl **serverctrls, LDAPControl **clientctrls )





                              ;


extern int
ldap_compare ( LDAP *ld, const char *dn, const char *attr, const char *value )



                          ;

extern int
ldap_compare_s ( LDAP *ld, const char *dn, const char *attr, const char *value )



                          ;






extern int
ldap_delete_ext ( LDAP *ld, const char *dn, LDAPControl **serverctrls, LDAPControl **clientctrls, int *msgidp )




                  ;

extern int
ldap_delete_ext_s ( LDAP *ld, const char *dn, LDAPControl **serverctrls, LDAPControl **clientctrls )



                              ;


extern int
ldap_delete ( LDAP *ld, const char *dn )

                       ;

extern int
ldap_delete_s ( LDAP *ld, const char *dn )

                       ;






extern int
ldap_parse_result ( LDAP *ld, LDAPMessage *res, int *errcodep, char **matcheddnp, char **errmsgp, char ***referralsp, LDAPControl ***serverctrls, int freeit )







                 ;

extern char *
ldap_err2string ( int err )
           ;


extern int
ldap_result2error ( LDAP *ld, LDAPMessage *r, int freeit )


              ;

extern void
ldap_perror ( LDAP *ld, const char *s )

                      ;






extern int
ldap_gssapi_bind ( LDAP *ld, const char *dn, const char *creds )


                          ;

extern int
ldap_gssapi_bind_s ( LDAP *ld, const char *dn, const char *creds )


                          ;





extern int
ldap_modify_ext ( LDAP *ld, const char *dn, LDAPMod **mods, LDAPControl **serverctrls, LDAPControl **clientctrls, int *msgidp )





                  ;

extern int
ldap_modify_ext_s ( LDAP *ld, const char *dn, LDAPMod **mods, LDAPControl **serverctrls, LDAPControl **clientctrls )




                              ;


extern int
ldap_modify ( LDAP *ld, const char *dn, LDAPMod **mods )


                  ;

extern int
ldap_modify_s ( LDAP *ld, const char *dn, LDAPMod **mods )


                  ;






extern int
ldap_rename ( LDAP *ld, const char *dn, const char *newrdn, const char *newSuperior, int deleteoldrdn, LDAPControl **sctrls, LDAPControl **cctrls, int *msgidp )







               ;

extern int
ldap_rename_s ( LDAP *ld, const char *dn, const char *newrdn, const char *newSuperior, int deleteoldrdn, LDAPControl **sctrls, LDAPControl **cctrls )






                        ;


extern int
ldap_rename2 ( LDAP *ld, const char *dn, const char *newrdn, const char *newSuperior, int deleteoldrdn )




                    ;

extern int
ldap_rename2_s ( LDAP *ld, const char *dn, const char *newrdn, const char *newSuperior, int deleteoldrdn )




                    ;

extern int
ldap_modrdn ( LDAP *ld, const char *dn, const char *newrdn )


                           ;

extern int
ldap_modrdn_s ( LDAP *ld, const char *dn, const char *newrdn )


                           ;

extern int
ldap_modrdn2 ( LDAP *ld, const char *dn, const char *newrdn, int deleteoldrdn )



                    ;

extern int
ldap_modrdn2_s ( LDAP *ld, const char *dn, const char *newrdn, int deleteoldrdn)



                   ;







extern LDAP *
ldap_init ( const char *host, int port )

            ;

extern LDAP *
ldap_open ( const char *host, int port )

            ;


extern int
ldap_create ( LDAP **ldp )
              ;

extern int
ldap_initialize ( LDAP **ldp, const char *url )

                        ;

extern LDAP *
ldap_dup ( LDAP *old )
             ;





extern int
ldap_tls_inplace ( LDAP *ld )
            ;

extern int
ldap_start_tls ( LDAP *ld, LDAPControl **serverctrls, LDAPControl **clientctrls, int *msgidp )



               ;

extern int
ldap_install_tls ( LDAP *ld )
            ;

extern int
ldap_start_tls_s ( LDAP *ld, LDAPControl **serverctrls, LDAPControl **clientctrls )


                             ;




extern LDAPMessage *
ldap_first_message ( LDAP *ld, LDAPMessage *chain )

                      ;

extern LDAPMessage *
ldap_next_message ( LDAP *ld, LDAPMessage *msg )

                    ;

extern int
ldap_count_messages ( LDAP *ld, LDAPMessage *chain )

                      ;




extern LDAPMessage *
ldap_first_reference ( LDAP *ld, LDAPMessage *chain )

                      ;

extern LDAPMessage *
ldap_next_reference ( LDAP *ld, LDAPMessage *ref )

                    ;

extern int
ldap_count_references ( LDAP *ld, LDAPMessage *chain )

                      ;

extern int
ldap_parse_reference ( LDAP *ld, LDAPMessage *ref, char ***referralsp, LDAPControl ***serverctrls, int freeit)




                ;





extern LDAPMessage *
ldap_first_entry ( LDAP *ld, LDAPMessage *chain )

                      ;

extern LDAPMessage *
ldap_next_entry ( LDAP *ld, LDAPMessage *entry )

                      ;

extern int
ldap_count_entries ( LDAP *ld, LDAPMessage *chain )

                      ;

extern int
ldap_get_entry_controls ( LDAP *ld, LDAPMessage *entry, LDAPControl ***serverctrls)


                              ;





extern LDAPMessage *
ldap_delete_result_entry ( LDAPMessage **list, LDAPMessage *e )

                  ;

extern void
ldap_add_result_entry ( LDAPMessage **list, LDAPMessage *e )

                  ;





extern char *
ldap_get_dn ( LDAP *ld, LDAPMessage *entry )

                      ;

typedef struct ldap_ava {
 struct berval la_attr;
 struct berval la_value;
 unsigned la_flags;







 void *la_private;
} LDAPAVA;

typedef LDAPAVA** LDAPRDN;
typedef LDAPRDN* LDAPDN;
# 1681 "/usr/include/ldap.h" 3 4
extern void ldap_rdnfree ( LDAPRDN rdn );
extern void ldap_dnfree ( LDAPDN dn );

extern int
ldap_bv2dn ( struct berval *bv, LDAPDN *dn, unsigned flags )


                  ;

extern int
ldap_str2dn ( const char *str, LDAPDN *dn, unsigned flags )


                  ;

extern int
ldap_dn2bv ( LDAPDN dn, struct berval *bv, unsigned flags )


                  ;

extern int
ldap_dn2str ( LDAPDN dn, char **str, unsigned flags )


                  ;

extern int
ldap_bv2rdn ( struct berval *bv, LDAPRDN *rdn, char **next, unsigned flags )



                  ;

extern int
ldap_str2rdn ( const char *str, LDAPRDN *rdn, char **next, unsigned flags )



                  ;

extern int
ldap_rdn2bv ( LDAPRDN rdn, struct berval *bv, unsigned flags )


                  ;

extern int
ldap_rdn2str ( LDAPRDN rdn, char **str, unsigned flags )


                  ;

extern int
ldap_dn_normalize ( const char *in, unsigned iflags, char **out, unsigned oflags )

                               ;

extern char *
ldap_dn2ufn ( const char *dn )
                       ;

extern char **
ldap_explode_dn ( const char *dn, int notypes )

               ;

extern char **
ldap_explode_rdn ( const char *rdn, int notypes )

               ;

typedef int LDAPDN_rewrite_func
 ( LDAPDN dn, unsigned flags, void *ctx );

extern int
ldap_X509dn2bv ( void *x509_name, struct berval *dn, LDAPDN_rewrite_func *func, unsigned flags )
                                             ;

extern char *
ldap_dn2dcedn ( const char *dn )
                       ;

extern char *
ldap_dcedn2dn ( const char *dce )
                        ;

extern char *
ldap_dn2ad_canonical ( const char *dn )
                       ;

extern int
ldap_get_dn_ber ( LDAP *ld, LDAPMessage *e, BerElement **berout, struct berval *dn )
                                                                    ;

extern int
ldap_get_attribute_ber ( LDAP *ld, LDAPMessage *e, BerElement *ber, struct berval *attr, struct berval **vals )

                        ;




extern char *
ldap_first_attribute ( LDAP *ld, LDAPMessage *entry, BerElement **ber )


                    ;

extern char *
ldap_next_attribute ( LDAP *ld, LDAPMessage *entry, BerElement *ber )


                   ;





extern struct berval **
ldap_get_values_len ( LDAP *ld, LDAPMessage *entry, const char *target )


                           ;

extern int
ldap_count_values_len ( struct berval **vals )
                        ;

extern void
ldap_value_free_len ( struct berval **vals )
                        ;


extern char **
ldap_get_values ( LDAP *ld, LDAPMessage *entry, const char *target )


                           ;

extern int
ldap_count_values ( char **vals )
               ;

extern void
ldap_value_free ( char **vals )
               ;





extern int
ldap_result ( LDAP *ld, int msgid, int all, struct timeval *timeout, LDAPMessage **result )




                        ;

extern int
ldap_msgtype ( LDAPMessage *lm )
                   ;

extern int
ldap_msgid ( LDAPMessage *lm )
                   ;

extern int
ldap_msgfree ( LDAPMessage *lm )
                   ;

extern int
ldap_msgdelete ( LDAP *ld, int msgid )

             ;





extern int
ldap_bv2escaped_filter_value ( struct berval *in, struct berval *out )

                      ;

extern int
ldap_search_ext ( LDAP *ld, const char *base, int scope, const char *filter, char **attrs, int attrsonly, LDAPControl **serverctrls, LDAPControl **clientctrls, struct timeval *timeout, int sizelimit, int *msgidp )
# 1879 "/usr/include/ldap.h" 3 4
                  ;

extern int
ldap_search_ext_s ( LDAP *ld, const char *base, int scope, const char *filter, char **attrs, int attrsonly, LDAPControl **serverctrls, LDAPControl **clientctrls, struct timeval *timeout, int sizelimit, LDAPMessage **res )
# 1893 "/usr/include/ldap.h" 3 4
                      ;


extern int
ldap_search ( LDAP *ld, const char *base, int scope, const char *filter, char **attrs, int attrsonly )





                 ;

extern int
ldap_search_s ( LDAP *ld, const char *base, int scope, const char *filter, char **attrs, int attrsonly, LDAPMessage **res )






                     ;

extern int
ldap_search_st ( LDAP *ld, const char *base, int scope, const char *filter, char **attrs, int attrsonly, struct timeval *timeout, LDAPMessage **res )







                     ;





extern int
ldap_unbind_ext ( LDAP *ld, LDAPControl **serverctrls, LDAPControl **clientctrls)


                             ;

extern int
ldap_unbind_ext_s ( LDAP *ld, LDAPControl **serverctrls, LDAPControl **clientctrls)


                             ;

extern int
ldap_destroy ( LDAP *ld)
             ;


extern int
ldap_unbind ( LDAP *ld )
            ;

extern int
ldap_unbind_s ( LDAP *ld )
            ;





extern int
ldap_put_vrFilter ( BerElement *ber, const char *vrf )

                   ;





extern void *
ldap_memalloc ( ber_len_t s )
               ;

extern void *
ldap_memrealloc ( void* p, ber_len_t s )

               ;

extern void *
ldap_memcalloc ( ber_len_t n, ber_len_t s )

               ;

extern void
ldap_memfree ( void* p )
           ;

extern void
ldap_memvfree ( void** v )
            ;

extern char *
ldap_strdup ( const char * )
                     ;

extern void
ldap_mods_free ( LDAPMod **mods, int freemods )

                ;






typedef int (LDAP_SORT_AD_CMP_PROC) ( const char *left, const char *right )

                          ;

typedef int (LDAP_SORT_AV_CMP_PROC) ( const void *left, const void *right )

                          ;

extern int
ldap_sort_entries ( LDAP *ld, LDAPMessage **chain, const char *attr, LDAP_SORT_AD_CMP_PROC *cmp )


                              ;

extern int
ldap_sort_values ( LDAP *ld, char **vals, LDAP_SORT_AV_CMP_PROC *cmp )


                              ;

extern int
ldap_sort_strcasecmp ( const void *a, const void *b )

                      ;





extern int
ldap_is_ldap_url ( const char *url )
                        ;

extern int
ldap_is_ldaps_url ( const char *url )
                        ;

extern int
ldap_is_ldapi_url ( const char *url )
                        ;

extern int
ldap_url_parse ( const char *url, LDAPURLDesc **ludpp )

                       ;

extern char *
ldap_url_desc2str ( LDAPURLDesc *ludp )
                     ;

extern void
ldap_free_urldesc ( LDAPURLDesc *ludp )
                     ;
# 2065 "/usr/include/ldap.h" 3 4
extern int
ldap_cancel ( LDAP *ld, int cancelid, LDAPControl **sctrls, LDAPControl **cctrls, int *msgidp )



                  ;

extern int
ldap_cancel_s ( LDAP *ld, int cancelid, LDAPControl **sctrl, LDAPControl **cctrl )


                       ;







extern int
ldap_turn ( LDAP *ld, int mutual, const char* identifier, LDAPControl **sctrls, LDAPControl **cctrls, int *msgidp )




                  ;

extern int
ldap_turn_s ( LDAP *ld, int mutual, const char* identifier, LDAPControl **sctrl, LDAPControl **cctrl )



                       ;







extern int
ldap_create_page_control_value ( LDAP *ld, ber_int_t pagesize, struct berval *cookie, struct berval *value )



                        ;

extern int
ldap_create_page_control ( LDAP *ld, ber_int_t pagesize, struct berval *cookie, int iscritical, LDAPControl **ctrlp )




                       ;


extern int
ldap_parse_page_control ( LDAP *ld, LDAPControl **ctrls, ber_int_t *count, struct berval **cookie )




                          ;


extern int
ldap_parse_pageresponse_control ( LDAP *ld, LDAPControl *ctrl, ber_int_t *count, struct berval *cookie )



                         ;
# 2144 "/usr/include/ldap.h" 3 4
typedef struct ldapsortkey {
 char *attributeType;
 char *orderingRule;
 int reverseOrder;
} LDAPSortKey;

extern int
ldap_create_sort_keylist ( LDAPSortKey ***sortKeyList, char *keyString )

                   ;

extern void
ldap_free_sort_keylist ( LDAPSortKey **sortkeylist )
                             ;

extern int
ldap_create_sort_control_value ( LDAP *ld, LDAPSortKey **keyList, struct berval *value )


                        ;

extern int
ldap_create_sort_control ( LDAP *ld, LDAPSortKey **keyList, int iscritical, LDAPControl **ctrlp )



                       ;

extern int
ldap_parse_sortresponse_control ( LDAP *ld, LDAPControl *ctrl, ber_int_t *result, char **attribute )



                    ;
# 2186 "/usr/include/ldap.h" 3 4
typedef struct ldapvlvinfo {
 ber_int_t ldvlv_version;
    ber_int_t ldvlv_before_count;
    ber_int_t ldvlv_after_count;
    ber_int_t ldvlv_offset;
    ber_int_t ldvlv_count;
    struct berval * ldvlv_attrvalue;
    struct berval * ldvlv_context;
    void * ldvlv_extradata;
} LDAPVLVInfo;

extern int
ldap_create_vlv_control_value ( LDAP *ld, LDAPVLVInfo *ldvlistp, struct berval *value)


                       ;

extern int
ldap_create_vlv_control ( LDAP *ld, LDAPVLVInfo *ldvlistp, LDAPControl **ctrlp )


                       ;

extern int
ldap_parse_vlvresponse_control ( LDAP *ld, LDAPControl *ctrls, ber_int_t *target_posp, ber_int_t *list_countp, struct berval **contextp, int *errcodep )





                           ;







extern int
ldap_parse_whoami ( LDAP *ld, LDAPMessage *res, struct berval **authzid )


                           ;

extern int
ldap_whoami ( LDAP *ld, LDAPControl **sctrls, LDAPControl **cctrls, int *msgidp )


                  ;

extern int
ldap_whoami_s ( LDAP *ld, struct berval **authzid, LDAPControl **sctrls, LDAPControl **cctrls )



                        ;







extern int
ldap_parse_passwd ( LDAP *ld, LDAPMessage *res, struct berval *newpasswd )


                            ;

extern int
ldap_passwd ( LDAP *ld, struct berval *user, struct berval *oldpw, struct berval *newpw, LDAPControl **sctrls, LDAPControl **cctrls, int *msgidp )





                  ;

extern int
ldap_passwd_s ( LDAP *ld, struct berval *user, struct berval *oldpw, struct berval *newpw, struct berval *newpasswd, LDAPControl **sctrls, LDAPControl **cctrls )






                        ;
# 2281 "/usr/include/ldap.h" 3 4
typedef enum passpolicyerror_enum {
       PP_passwordExpired = 0,
       PP_accountLocked = 1,
       PP_changeAfterReset = 2,
       PP_passwordModNotAllowed = 3,
       PP_mustSupplyOldPassword = 4,
       PP_insufficientPasswordQuality = 5,
       PP_passwordTooShort = 6,
       PP_passwordTooYoung = 7,
       PP_passwordInHistory = 8,
       PP_noError = 65535
} LDAPPasswordPolicyError;

extern int
ldap_create_passwordpolicy_control ( LDAP *ld, LDAPControl **ctrlp )

                              ;

extern int
ldap_parse_passwordpolicy_control ( LDAP *ld, LDAPControl *ctrl, ber_int_t *expirep, ber_int_t *gracep, LDAPPasswordPolicyError *errorp )




                                          ;

extern const char *
ldap_passwordpolicy_err2txt ( LDAPPasswordPolicyError );
# 2317 "/usr/include/ldap.h" 3 4
extern int
ldap_parse_refresh ( LDAP *ld, LDAPMessage *res, ber_int_t *newttl )


                     ;

extern int
ldap_refresh ( LDAP *ld, struct berval *dn, ber_int_t ttl, LDAPControl **sctrls, LDAPControl **cctrls, int *msgidp )




                  ;

extern int
ldap_refresh_s ( LDAP *ld, struct berval *dn, ber_int_t ttl, ber_int_t *newttl, LDAPControl **sctrls, LDAPControl **cctrls )





                        ;
# 2380 "/usr/include/ldap.h" 3 4
extern ldap_sync_t *
ldap_sync_initialize ( ldap_sync_t *ls )
                   ;




extern void
ldap_sync_destroy ( ldap_sync_t *ls, int freeit )

               ;




extern int
ldap_sync_init ( ldap_sync_t *ls, int mode )

             ;




extern int
ldap_sync_init_refresh_only ( ldap_sync_t *ls )
                   ;




extern int
ldap_sync_init_refresh_and_persist ( ldap_sync_t *ls )
                   ;




extern int
ldap_sync_poll ( ldap_sync_t *ls )
                   ;






extern int
ldap_create_session_tracking_value ( LDAP *ld, char *sessionSourceIp, char *sessionSourceName, char *formatOID, struct berval *sessionTrackingIdentifier, struct berval *value )





                        ;

extern int
ldap_create_session_tracking_control ( LDAP *ld, char *sessionSourceIp, char *sessionSourceName, char *formatOID, struct berval *sessionTrackingIdentifier, LDAPControl **ctrlp )





                       ;

extern int
ldap_parse_session_tracking_control ( LDAP *ld, LDAPControl *ctrl, struct berval *ip, struct berval *name, struct berval *oid, struct berval *id )





                     ;






extern int
ldap_create_assertion_control_value ( LDAP *ld, char *assertion, struct berval *value )


                        ;

extern int
ldap_create_assertion_control ( LDAP *ld, char *filter, int iscritical, LDAPControl **ctrlp )



                       ;





typedef struct LDAPDerefSpec {
 char *derefAttr;
 char **attributes;
} LDAPDerefSpec;

typedef struct LDAPDerefVal {
 char *type;
 BerVarray vals;
 struct LDAPDerefVal *next;
} LDAPDerefVal;

typedef struct LDAPDerefRes {
 char *derefAttr;
 struct berval derefVal;
 LDAPDerefVal *attrVals;
 struct LDAPDerefRes *next;
} LDAPDerefRes;

extern int
ldap_create_deref_control_value ( LDAP *ld, LDAPDerefSpec *ds, struct berval *value )


                        ;

extern int
ldap_create_deref_control ( LDAP *ld, LDAPDerefSpec *ds, int iscritical, LDAPControl **ctrlp )



                       ;

extern void
ldap_derefresponse_free ( LDAPDerefRes *dr )
                    ;

extern int
ldap_parse_derefresponse_control ( LDAP *ld, LDAPControl *ctrl, LDAPDerefRes **drp )


                      ;

extern int
ldap_parse_deref_control ( LDAP *ld, LDAPControl **ctrls, LDAPDerefRes **drp )


                      ;

}
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 2
# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"

# 21 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
namespace rgw {



  class LDAPHelper
  {
    std::string uri;
    std::string binddn;
    std::string bindpw;
    std::string searchdn;
    std::string searchfilter;
    std::string dnattr;
    LDAP *ldap;
    bool msad = false;
    std::mutex mtx;

  public:
    using lock_guard = std::lock_guard<std::mutex>;

    LDAPHelper(std::string _uri, std::string _binddn, std::string _bindpw,
        const std::string &_searchdn, const std::string &_searchfilter, const std::string &_dnattr)
      : uri(std::move(_uri)), binddn(std::move(_binddn)),
 bindpw(std::move(_bindpw)), searchdn(_searchdn), searchfilter(_searchfilter), dnattr(_dnattr),
 ldap(nullptr) {

    }

    int init() {
      int ret;
      ret = ldap_initialize(&ldap, uri.c_str());
      if (ret == 
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                0x00
# 51 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                            ) {
 unsigned long ldap_ver = 
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                         3
# 52 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                      ;
 ret = ldap_set_option(ldap, 
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                            0x0011
# 53 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                                     ,
         (void*) &ldap_ver);
      }
      if (ret == 
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                0x00
# 56 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                            ) {
 ret = ldap_set_option(ldap, 
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                            0x0008
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                              , 
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                                                ((void *) 0)
# 57 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                                            );
      }
      return (ret == 
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                    0x00
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                ) ? ret : -
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                                           22
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                                 ;
    }

    int bind() {
      int ret;
      ret = ldap_simple_bind_s(ldap, binddn.c_str(), bindpw.c_str());
      return (ret == 
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                    0x00
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                ) ? ret : -
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                                           22
# 65 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                                 ;
    }

    int rebind() {
      if (ldap) {
 (void) ldap_unbind(ldap);
 (void) init();
 return bind();
      }
      return -
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
             22
# 74 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                   ;
    }

    int simple_bind(const char *dn, const std::string& pwd) {
      LDAP* tldap;
      int ret = ldap_initialize(&tldap, uri.c_str());
      if (ret == 
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                0x00
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                            ) {
 unsigned long ldap_ver = 
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                         3
# 81 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                      ;
 ret = ldap_set_option(tldap, 
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
                             0x0011
# 82 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                                                      ,
         (void*) &ldap_ver);
 if (ret == 
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
           0x00
# 84 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                       ) {
   ret = ldap_simple_bind_s(tldap, dn, pwd.c_str());
   if (ret == 
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h" 3 4
             0x00
# 86 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
                         ) {
     (void) ldap_unbind(tldap);
   }
 }
      }
      return ret;
    }

    int auth(const std::string &uid, const std::string &pwd);

    ~LDAPHelper() {
      if (ldap)
 (void) ldap_unbind(ldap);
    }

  };
# 131 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
}
# 141 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_ldap.h"
std::string parse_rgw_ldap_bindpw(CephContext* ctx);
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_token.h" 1
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_token.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/base64_from_binary.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/base64_from_binary.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/base64_from_binary.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/base64_from_binary.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/dataflow_exception.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/dataflow_exception.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 25 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/dataflow_exception.hpp" 2 3 4


# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/dataflow_exception.hpp" 3 4
namespace boost {
namespace archive {
namespace iterators {




class dataflow_exception : public std::exception
{
public:
    typedef enum {
        invalid_6_bitcode,
        invalid_base64_character,
        invalid_xml_escape_sequence,
        comparison_not_permitted,
        invalid_conversion,
        other_exception
    } exception_code;
    exception_code code;

    dataflow_exception(exception_code c = other_exception) : code(c)
    {}

    virtual const char *what( ) const throw( )
    {
        const char *msg = "unknown exception code";
        switch(code){
        case invalid_6_bitcode:
            msg = "attempt to encode a value > 6 bits";
            break;
        case invalid_base64_character:
            msg = "attempt to decode a value not in base64 char set";
            break;
        case invalid_xml_escape_sequence:
            msg = "invalid xml escape_sequence";
            break;
        case comparison_not_permitted:
            msg = "cannot invoke iterator comparison now";
            break;
        case invalid_conversion:
            msg = "invalid multbyte/wide char conversion";
            break;
        default:
            (static_cast<void> (0));
            break;
        }
        return msg;
    }
};

}
}
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/base64_from_binary.hpp" 2 3 4

namespace boost {
namespace archive {
namespace iterators {




namespace detail {

template<class CharType>
struct from_6_bit {
    typedef CharType result_type;
    CharType operator()(CharType t) const{
        static const char * lookup_table =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            "abcdefghijklmnopqrstuvwxyz"
            "0123456789"
            "+/";
        (static_cast<void> (0));
        return lookup_table[static_cast<size_t>(t)];
    }
};

}
# 70 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/base64_from_binary.hpp" 3 4
template<
    class Base,
    class CharType = typename boost::iterator_value<Base>::type
>
class base64_from_binary :
    public transform_iterator<
        detail::from_6_bit<CharType>,
        Base
    >
{
    friend class boost::iterator_core_access;
    typedef transform_iterator<
        typename detail::from_6_bit<CharType>,
        Base
    > super_t;

public:

    template<class T>
    base64_from_binary(T start) :
        super_t(
            Base(static_cast< T >(start)),
            detail::from_6_bit<CharType>()
        )
    {}

    base64_from_binary(const base64_from_binary & rhs) :
        super_t(
            Base(rhs.base_reference()),
            detail::from_6_bit<CharType>()
        )
    {}

};

}
}
}
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/binary_from_base64.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/binary_from_base64.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/binary_from_base64.hpp" 2 3 4

# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/serialization/throw_exception.hpp" 1 3 4
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/serialization/throw_exception.hpp" 3 4
namespace boost {
namespace serialization {
# 35 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/serialization/throw_exception.hpp" 3 4
template<class E> inline void throw_exception(E const & e){
    throw e;
}



}
}
# 22 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/binary_from_base64.hpp" 2 3 4





namespace boost {
namespace archive {
namespace iterators {




namespace detail {

template<class CharType>
struct to_6_bit {
    typedef CharType result_type;
    CharType operator()(CharType t) const{
        static const signed char lookup_table[] = {
            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
            -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
            52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1,
            -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
            15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
            -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
            41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
        };


        static_assert(128 == sizeof(lookup_table), "128 == sizeof(lookup_table)");

        signed char value = -1;
        if((unsigned)t <= 127)
            value = lookup_table[(unsigned)t];
        if(-1 == value)
            boost::serialization::throw_exception(
                dataflow_exception(dataflow_exception::invalid_base64_character)
            );
        return value;
    }
};

}
# 80 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/binary_from_base64.hpp" 3 4
template<
    class Base,
    class CharType = typename boost::iterator_value<Base>::type
>
class binary_from_base64 : public
    transform_iterator<
        detail::to_6_bit<CharType>,
        Base
    >
{
    friend class boost::iterator_core_access;
    typedef transform_iterator<
        detail::to_6_bit<CharType>,
        Base
    > super_t;
public:

    template<class T>
    binary_from_base64(T start) :
        super_t(
            Base(static_cast< T >(start)),
            detail::to_6_bit<CharType>()
        )
    {}

    binary_from_base64(const binary_from_base64 & rhs) :
        super_t(
            Base(rhs.base_reference()),
            detail::to_6_bit<CharType>()
        )
    {}

};

}
}
}
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/insert_linebreaks.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/insert_linebreaks.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/insert_linebreaks.hpp" 2 3 4
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/insert_linebreaks.hpp" 3 4
namespace boost {
namespace archive {
namespace iterators {



template<
    class Base,
    int N,
    class CharType = typename boost::iterator_value<Base>::type
>
class insert_linebreaks :
    public iterator_adaptor<
        insert_linebreaks<Base, N, CharType>,
        Base,
        CharType,
        single_pass_traversal_tag,
        CharType
    >
{
private:
    friend class boost::iterator_core_access;
    typedef iterator_adaptor<
        insert_linebreaks<Base, N, CharType>,
        Base,
        CharType,
        single_pass_traversal_tag,
        CharType
    > super_t;

    bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
        return


            this->base_reference() == rhs.base_reference()
        ;
    }

    void increment() {
        if(m_count == N){
            m_count = 0;
            return;
        }
        ++m_count;
        ++(this->base_reference());
    }
    CharType dereference() const {
        if(m_count == N)
            return '\n';
        return * (this->base_reference());
    }
    unsigned int m_count;
public:

    template<class T>
    insert_linebreaks(T start) :
        super_t(Base(static_cast< T >(start))),
        m_count(0)
    {}

    insert_linebreaks(const insert_linebreaks & rhs) :
        super_t(rhs.base_reference()),
        m_count(rhs.m_count)
    {}
};

}
}
}
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/transform_width.hpp" 1 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/transform_width.hpp" 3 4
namespace boost {
namespace archive {
namespace iterators {




template<
    class Base,
    int BitsOut,
    int BitsIn,
    class CharType = typename boost::iterator_value<Base>::type
>
class transform_width :
    public boost::iterator_adaptor<
        transform_width<Base, BitsOut, BitsIn, CharType>,
        Base,
        CharType,
        single_pass_traversal_tag,
        CharType
    >
{
    friend class boost::iterator_core_access;
    typedef typename boost::iterator_adaptor<
        transform_width<Base, BitsOut, BitsIn, CharType>,
        Base,
        CharType,
        single_pass_traversal_tag,
        CharType
    > super_t;

    typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
    typedef typename iterator_value<Base>::type base_value_type;

    void fill();

    CharType dereference() const {
        if(!m_buffer_out_full)
            const_cast<this_t *>(this)->fill();
        return m_buffer_out;
    }

    bool equal_impl(const this_t & rhs){
        if(BitsIn < BitsOut)
            return this->base_reference() == rhs.base_reference();
        else{

            if(this->base_reference() == rhs.base_reference()){
                m_end_of_sequence = true;
                return 0 == m_remaining_bits;
            }
            return false;
        }
    }


    bool equal(const this_t & rhs) const {
        return const_cast<this_t *>(this)->equal_impl(rhs);
    }

    void increment(){
        m_buffer_out_full = false;
    }

    bool m_buffer_out_full;
    CharType m_buffer_out;


    base_value_type m_buffer_in;


    unsigned int m_remaining_bits;


    bool m_end_of_sequence;

public:

    template<class T>
    transform_width(T start) :
        super_t(Base(static_cast< T >(start))),
        m_buffer_out_full(false),
        m_buffer_out(0),



        m_buffer_in(0),
        m_remaining_bits(0),
        m_end_of_sequence(false)
    {}

    transform_width(const transform_width & rhs) :
        super_t(rhs.base_reference()),
        m_buffer_out_full(rhs.m_buffer_out_full),
        m_buffer_out(rhs.m_buffer_out),
        m_buffer_in(rhs.m_buffer_in),
        m_remaining_bits(rhs.m_remaining_bits),
        m_end_of_sequence(false)
    {}
};

template<
    class Base,
    int BitsOut,
    int BitsIn,
    class CharType
>
void transform_width<Base, BitsOut, BitsIn, CharType>::fill() {
    unsigned int missing_bits = BitsOut;
    m_buffer_out = 0;
    do{
        if(0 == m_remaining_bits){
            if(m_end_of_sequence){
                m_buffer_in = 0;
                m_remaining_bits = missing_bits;
            }
            else{
                m_buffer_in = * this->base_reference()++;
                m_remaining_bits = BitsIn;
            }
        }



        unsigned int i = (std::min)(missing_bits, m_remaining_bits);

        base_value_type j = m_buffer_in >> (m_remaining_bits - i);


        j &= (1 << i) - 1;

        m_buffer_out <<= i;
        m_buffer_out |= j;


        missing_bits -= i;
        m_remaining_bits -= i;
    }while(0 < missing_bits);
    m_buffer_out_full = true;
}

}
}
}
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 1 3 4
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 1 3 4
# 58 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 59 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/assert.hpp" 2 3 4
# 20 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 2 3 4


# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/filter_iterator.hpp" 1 3 4
# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/iterator/filter_iterator.hpp" 3 4
namespace boost {
namespace iterators {

  template <class Predicate, class Iterator>
  class filter_iterator;

  namespace detail
  {
    template <class Predicate, class Iterator>
    struct filter_iterator_base
    {
        typedef iterator_adaptor<
            filter_iterator<Predicate, Iterator>
          , Iterator
          , use_default
          , typename mpl::if_<
                is_convertible<
                    typename iterator_traversal<Iterator>::type
                  , random_access_traversal_tag
                >
              , bidirectional_traversal_tag
              , use_default
            >::type
        > type;
    };
  }

  template <class Predicate, class Iterator>
  class filter_iterator
    : public detail::filter_iterator_base<Predicate, Iterator>::type
  {
      typedef typename detail::filter_iterator_base<
          Predicate, Iterator
      >::type super_t;

      friend class iterator_core_access;

   public:
      filter_iterator() { }

      filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator())
          : super_t(x), m_predicate(f), m_end(end_)
      {
          satisfy_predicate();
      }

      filter_iterator(Iterator x, Iterator end_ = Iterator())
        : super_t(x), m_predicate(), m_end(end_)
      {





          static_assert(is_class<Predicate>::value, "is_class<Predicate>::value");

          satisfy_predicate();
      }

      template<class OtherIterator>
      filter_iterator(
          filter_iterator<Predicate, OtherIterator> const& t
          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
          )
          : super_t(t.base()), m_predicate(t.predicate()), m_end(t.end()) {}

      Predicate predicate() const { return m_predicate; }

      Iterator end() const { return m_end; }

   private:
      void increment()
      {
          ++(this->base_reference());
          satisfy_predicate();
      }

      void decrement()
      {
        while(!this->m_predicate(*--(this->base_reference()))){};
      }

      void satisfy_predicate()
      {
          while (this->base() != this->m_end && !this->m_predicate(*this->base()))
              ++(this->base_reference());
      }



      Predicate m_predicate;
      Iterator m_end;
  };

  template <class Predicate, class Iterator>
  inline filter_iterator<Predicate,Iterator>
  make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
  {
      return filter_iterator<Predicate,Iterator>(f,x,end);
  }

  template <class Predicate, class Iterator>
  inline filter_iterator<Predicate,Iterator>
  make_filter_iterator(
      typename iterators::enable_if<
          is_class<Predicate>
        , Iterator
      >::type x
    , Iterator end = Iterator())
  {
      return filter_iterator<Predicate,Iterator>(x,end);
  }

}

using iterators::filter_iterator;
using iterators::make_filter_iterator;

}
# 23 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 2 3 4
# 32 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 3 4
# 1 "/usr/include/c++/10/cwctype" 1 3 4
# 39 "/usr/include/c++/10/cwctype" 3 4
       
# 40 "/usr/include/c++/10/cwctype" 3
# 33 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 2 3 4





# 1 "/usr/include/c++/10/cctype" 1 3 4
# 39 "/usr/include/c++/10/cctype" 3 4
       
# 40 "/usr/include/c++/10/cctype" 3
# 39 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 2 3 4
# 49 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/archive/iterators/remove_whitespace.hpp" 3 4
namespace {

template<class CharType>
struct remove_whitespace_predicate;

template<>
struct remove_whitespace_predicate<char>
{
    bool operator()(unsigned char t){
        return ! std::isspace(t);
    }
};


template<>
struct remove_whitespace_predicate<wchar_t>
{
    bool operator()(wchar_t t){
        return ! std::iswspace(t);
    }
};


}




namespace boost {
namespace archive {
namespace iterators {




template<class Predicate, class Base>
class filter_iterator
    : public boost::iterator_adaptor<
        filter_iterator<Predicate, Base>,
        Base,
        use_default,
        single_pass_traversal_tag
    >
{
    friend class boost::iterator_core_access;
    typedef typename boost::iterator_adaptor<
        filter_iterator<Predicate, Base>,
        Base,
        use_default,
        single_pass_traversal_tag
    > super_t;
    typedef filter_iterator<Predicate, Base> this_t;
    typedef typename super_t::reference reference_type;

    reference_type dereference_impl(){
        if(! m_full){
            while(! m_predicate(* this->base_reference()))
                ++(this->base_reference());
            m_full = true;
        }
        return * this->base_reference();
    }

    reference_type dereference() const {
        return const_cast<this_t *>(this)->dereference_impl();
    }

    Predicate m_predicate;
    bool m_full;
public:


    void increment(){
        m_full = false;
        ++(this->base_reference());
    }
    filter_iterator(Base start) :
        super_t(start),
        m_full(false)
    {}
    filter_iterator(){}
};

template<class Base>
class remove_whitespace :
    public filter_iterator<
        remove_whitespace_predicate<
            typename boost::iterator_value<Base>::type

        >,
        Base
    >
{
    friend class boost::iterator_core_access;
    typedef filter_iterator<
        remove_whitespace_predicate<
            typename boost::iterator_value<Base>::type

        >,
        Base
    > super_t;
public:


    template<class T>
    remove_whitespace(T start) :
        super_t(Base(static_cast< T >(start)))
    {}

    remove_whitespace(const remove_whitespace & rhs) :
        super_t(rhs.base_reference())
    {}
};

}
}
}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h" 2



# 16 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h"
namespace rgw {
# 28 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_b64.h"
  template<int wrap_width = std::numeric_limits<int>::max()>
  inline std::string to_base64(boost::string_view sview)
  {
    using namespace boost::archive::iterators;


    auto psize = sview.size();
    while ((psize % 3) != 0) {
      ++psize;
    }




    typedef
      insert_linebreaks<
        base64_from_binary<
          transform_width<
     boost::string_view::const_iterator
            ,6,8>
          >
          ,wrap_width
        > b64_iter;

    std::string outstr(b64_iter(sview.data()),
         b64_iter(sview.data() + sview.size()));


    for (size_t ix = 0; ix < (psize-sview.size()); ++ix)
      outstr.push_back('=');

    return outstr;
  }

  inline std::string from_base64(boost::string_view sview)
  {
    using namespace boost::archive::iterators;
    if (sview.empty())
      return std::string();


    typedef
      transform_width<
      binary_from_base64<
 remove_whitespace<
   boost::string_view::const_iterator>>
      ,8,6
      > b64_iter;

    while (sview.back() == '=')
      sview.remove_suffix(1);

    std::string outstr(b64_iter(sview.data()),
        b64_iter(sview.data() + sview.size()));

    return outstr;
  }
}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_token.h" 2

namespace rgw {

  using std::string;

  class RGWToken {
  public:
    static constexpr auto type_name = "RGW_TOKEN";

    enum token_type : uint32_t {
      TOKEN_NONE,
 TOKEN_AD,
 TOKEN_KEYSTONE,
 TOKEN_LDAP,
    };

    static enum token_type to_type(const string& s) {
      if (boost::iequals(s, "ad"))
 return TOKEN_AD;
      if (boost::iequals(s, "ldap"))
 return TOKEN_LDAP;
      if (boost::iequals(s, "keystone"))
 return TOKEN_KEYSTONE;
      return TOKEN_NONE;
    }

    static const char* from_type(enum token_type type) {
      switch (type) {
      case TOKEN_AD:
 return "ad";
 break;
      case TOKEN_LDAP:
 return "ldap";
 break;
      case TOKEN_KEYSTONE:
 return "keystone";
 break;
      default:
 return "none";
      };
    }

    token_type type;
    string id;
    string key;

    virtual uint32_t version() const { return 1; };

    bool valid() const{
      return ((type != TOKEN_NONE) &&
       (! id.empty()) &&
       (! key.empty()));
    }

    RGWToken()
      : type(TOKEN_NONE) {};

    RGWToken(enum token_type _type, const std::string& _id,
      const std::string& _key)
      : type(_type), id(_id), key(_key) {};

    RGWToken(const string& json) {
      JSONParser p;
      p.parse(json.c_str(), json.length());
      JSONDecoder::decode_json(RGWToken::type_name, *this, &p);
    }

    void encode(bufferlist& bl) const {
      uint32_t ver = version();
      string typestr{from_type(type)};
      __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
      encode(type_name, bl);
      encode(ver, bl);
      encode(typestr, bl);
      encode(id, bl);
      encode(key, bl);
      } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
    }

    void decode(bufferlist::const_iterator& bl) {
      string name;
      string typestr;
      uint32_t version;
      __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
      decode(name, bl);
      decode(version, bl);
      decode(typestr, bl);
      type = to_type(typestr);
      decode(id, bl);
      decode(key, bl);
      } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
    }

    void dump(Formatter* f) const {
      ::encode_json("version", uint32_t(version()), f);
      ::encode_json("type", from_type(type), f);
      ::encode_json("id", id, f);
      ::encode_json("key", key, f);
    }

    void encode_json(Formatter* f) {
      RGWToken& token = *this;
      f->open_object_section(type_name);
      ::encode_json(type_name, token, f);
      f->close_section();
    }

    void decode_json(JSONObj* obj) {
      uint32_t version;
      string type_name;
      string typestr;
      JSONDecoder::decode_json("version", version, obj);
      JSONDecoder::decode_json("type", typestr, obj);
      type = to_type(typestr);
      JSONDecoder::decode_json("id", id, obj);
      JSONDecoder::decode_json("key", key, obj);
    }

    std::string encode_json_base64(Formatter* f) {
      encode_json(f);
      std::ostringstream os;
      f->flush(os);
      return to_base64(std::move(os.str()));
    }

    friend inline ostream& operator<<(ostream& os, const RGWToken& token);

    virtual ~RGWToken() {};
  };
  inline void encode(const RGWToken &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWToken &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

  inline ostream& operator<<(ostream& os, const RGWToken& token)
  {
    os << "<<RGWToken"
       << " type=" << RGWToken::from_type(token.type)
       << " id=" << token.id
       << " key=" << token.key
       << ">>";
    return os;
  }

}
# 26 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2



# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h" 1
# 9 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool_fwd.hpp" 1 3 4
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool_fwd.hpp" 3 4

# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool_fwd.hpp" 3 4
namespace boost { namespace logic { class tribool; } }
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 2 3 4




         


namespace boost { namespace logic {


namespace detail {






struct indeterminate_t
{



};

}







typedef bool (*indeterminate_keyword_t)(tribool, detail::indeterminate_t);
# 62 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
constexpr inline bool
indeterminate(tribool x,
              detail::indeterminate_t dummy = detail::indeterminate_t()) noexcept;







class tribool
{
private:

  struct dummy {
    void nonnull() {};
  };

  typedef void (dummy::*safe_bool)();

public:





  constexpr tribool() noexcept : value(false_value) {}







  constexpr tribool(bool initial_value) noexcept : value(initial_value? true_value : false_value) {}






  constexpr tribool(indeterminate_keyword_t) noexcept : value(indeterminate_value) {}
# 112 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
  constexpr operator safe_bool() const noexcept
  {
    return value == true_value? &dummy::nonnull : 0;
  }





  enum value_t { false_value, true_value, indeterminate_value } value;
};



constexpr inline bool indeterminate(tribool x, detail::indeterminate_t) noexcept
{
  return x.value == tribool::indeterminate_value;
}
# 159 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
constexpr inline tribool operator!(tribool x) noexcept
{
  return x.value == tribool::false_value? tribool(true)
        :x.value == tribool::true_value? tribool(false)
        :tribool(indeterminate);
}
# 199 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
constexpr inline tribool operator&&(tribool x, tribool y) noexcept
{
  return (static_cast<bool>(!x) || static_cast<bool>(!y))
    ? tribool(false)
    : ((static_cast<bool>(x) && static_cast<bool>(y)) ? tribool(true) : indeterminate)
  ;
}




constexpr inline tribool operator&&(tribool x, bool y) noexcept
{ return y? x : tribool(false); }




constexpr inline tribool operator&&(bool x, tribool y) noexcept
{ return x? y : tribool(false); }




constexpr inline tribool operator&&(indeterminate_keyword_t, tribool x) noexcept
{ return !x? tribool(false) : tribool(indeterminate); }




constexpr inline tribool operator&&(tribool x, indeterminate_keyword_t) noexcept
{ return !x? tribool(false) : tribool(indeterminate); }
# 264 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
constexpr inline tribool operator||(tribool x, tribool y) noexcept
{
  return (static_cast<bool>(!x) && static_cast<bool>(!y))
    ? tribool(false)
    : ((static_cast<bool>(x) || static_cast<bool>(y)) ? tribool(true) : tribool(indeterminate))
  ;
}




constexpr inline tribool operator||(tribool x, bool y) noexcept
{ return y? tribool(true) : x; }




constexpr inline tribool operator||(bool x, tribool y) noexcept
{ return x? tribool(true) : y; }




constexpr inline tribool operator||(indeterminate_keyword_t, tribool x) noexcept
{ return x? tribool(true) : tribool(indeterminate); }




constexpr inline tribool operator||(tribool x, indeterminate_keyword_t) noexcept
{ return x? tribool(true) : tribool(indeterminate); }
# 330 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
constexpr inline tribool operator==(tribool x, tribool y) noexcept
{
  return (indeterminate(x) || indeterminate(y))
    ? indeterminate
    : ((x && y) || (!x && !y))
  ;
}




constexpr inline tribool operator==(tribool x, bool y) noexcept { return x == tribool(y); }




constexpr inline tribool operator==(bool x, tribool y) noexcept { return tribool(x) == y; }




constexpr inline tribool operator==(indeterminate_keyword_t, tribool x) noexcept
{ return tribool(indeterminate) == x; }




constexpr inline tribool operator==(tribool x, indeterminate_keyword_t) noexcept
{ return tribool(indeterminate) == x; }
# 393 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/build/boost/include/boost/logic/tribool.hpp" 3 4
constexpr inline tribool operator!=(tribool x, tribool y) noexcept
{
  return (indeterminate(x) || indeterminate(y))
    ? indeterminate
    : !((x && y) || (!x && !y))
  ;
}




constexpr inline tribool operator!=(tribool x, bool y) noexcept { return x != tribool(y); }




constexpr inline tribool operator!=(bool x, tribool y) noexcept { return tribool(x) != y; }




constexpr inline tribool operator!=(indeterminate_keyword_t, tribool x) noexcept
{ return tribool(indeterminate) != x; }




constexpr inline tribool operator!=(tribool x, indeterminate_keyword_t) noexcept
{ return x != tribool(indeterminate); }

} }


namespace boost {
  using logic::tribool;
  using logic::indeterminate;
}
# 10 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h" 2






# 15 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h"
namespace rgw {
namespace auth {



template <typename DecorateeT>
class DecoratedApplier : public rgw::auth::IdentityApplier {
  typedef typename std::remove_pointer<DecorateeT>::type DerefedDecorateeT;

  static_assert(std::is_base_of<rgw::auth::IdentityApplier,
                                DerefedDecorateeT>::value,
                "DecorateeT must be a subclass of rgw::auth::IdentityApplier");

  DecorateeT decoratee;





  template <typename T = void,
            typename std::enable_if<
    std::is_pointer<DecorateeT>::value, T>::type* = nullptr>
  DerefedDecorateeT& get_decoratee() {
    return *decoratee;
  }

  template <typename T = void,
            typename std::enable_if<
    ! std::is_pointer<DecorateeT>::value, T>::type* = nullptr>
  DerefedDecorateeT& get_decoratee() {
    return decoratee;
  }

  template <typename T = void,
            typename std::enable_if<
    std::is_pointer<DecorateeT>::value, T>::type* = nullptr>
  const DerefedDecorateeT& get_decoratee() const {
    return *decoratee;
  }

  template <typename T = void,
            typename std::enable_if<
    ! std::is_pointer<DecorateeT>::value, T>::type* = nullptr>
  const DerefedDecorateeT& get_decoratee() const {
    return decoratee;
  }

public:
  explicit DecoratedApplier(DecorateeT&& decoratee)
    : decoratee(std::forward<DecorateeT>(decoratee)) {
  }

  uint32_t get_perms_from_aclspec(const DoutPrefixProvider* dpp, const aclspec_t& aclspec) const override {
    return get_decoratee().get_perms_from_aclspec(dpp, aclspec);
  }

  bool is_admin_of(const rgw_user& uid) const override {
    return get_decoratee().is_admin_of(uid);
  }

  bool is_owner_of(const rgw_user& uid) const override {
    return get_decoratee().is_owner_of(uid);
  }

  uint32_t get_perm_mask() const override {
    return get_decoratee().get_perm_mask();
  }

  uint32_t get_identity_type() const override {
    return get_decoratee().get_identity_type();
  }

  string get_acct_name() const override {
    return get_decoratee().get_acct_name();
  }

  bool is_identity(
    const boost::container::flat_set<Principal>& ids) const override {
    return get_decoratee().is_identity(ids);
  }

  void to_str(std::ostream& out) const override {
    get_decoratee().to_str(out);
  }

  void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const override {
    return get_decoratee().load_acct_info(dpp, user_info);
  }

  void modify_request_state(const DoutPrefixProvider* dpp, req_state * s) const override {
    return get_decoratee().modify_request_state(dpp, s);
  }
};


template <typename T>
class ThirdPartyAccountApplier : public DecoratedApplier<T> {
             RGWRados* const store;
  const rgw_user acct_user_override;

public:



  static const rgw_user UNKNOWN_ACCT;

  template <typename U>
  ThirdPartyAccountApplier(RGWRados* const store,
                           const rgw_user &acct_user_override,
                           U&& decoratee)
    : DecoratedApplier<T>(std::move(decoratee)),
      store(store),
      acct_user_override(acct_user_override) {
  }

  void to_str(std::ostream& out) const override;
  void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const override;
};



template <typename T>
const rgw_user ThirdPartyAccountApplier<T>::UNKNOWN_ACCT;

template <typename T>
void ThirdPartyAccountApplier<T>::to_str(std::ostream& out) const
{
  out << "rgw::auth::ThirdPartyAccountApplier(" + acct_user_override.to_str() + ")"
      << " -> ";
  DecoratedApplier<T>::to_str(out);
}

template <typename T>
void ThirdPartyAccountApplier<T>::load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const
{
  if (UNKNOWN_ACCT == acct_user_override) {


    DecoratedApplier<T>::load_acct_info(dpp, user_info);
  } else if (DecoratedApplier<T>::is_owner_of(acct_user_override)) {


    DecoratedApplier<T>::load_acct_info(dpp, user_info);
  } else {


    if (acct_user_override.tenant.empty()) {
      const rgw_user tenanted_uid(acct_user_override.id, acct_user_override.id);

      if (rgw_get_user_info_by_uid(store, tenanted_uid, user_info) >= 0) {

        return;
      }
    }

    const int ret = rgw_get_user_info_by_uid(store, acct_user_override, user_info);
    if (ret < 0) {


      if (ret == -
# 174 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h" 3 4
                 2
# 174 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h"
                       ) {
        throw -
# 175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h" 3 4
              13
# 175 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h"
                    ;
      } else {
        throw ret;
      }
    }

  }
}

template <typename T> static inline
ThirdPartyAccountApplier<T> add_3rdparty(RGWRados* const store,
                                         const rgw_user &acct_user_override,
                                         T&& t) {
  return ThirdPartyAccountApplier<T>(store, acct_user_override,
                                     std::forward<T>(t));
}


template <typename T>
class SysReqApplier : public DecoratedApplier<T> {
  CephContext* const cct;
            RGWRados* const store;
  const RGWHTTPArgs& args;
  mutable boost::tribool is_system;

public:
  template <typename U>
  SysReqApplier(CephContext* const cct,
                          RGWRados* const store,
                const req_state* const s,
                U&& decoratee)
    : DecoratedApplier<T>(std::forward<T>(decoratee)),
      cct(cct),
      store(store),
      args(s->info.args),
      is_system(boost::logic::indeterminate) {
  }

  void to_str(std::ostream& out) const override;
  void load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const override;
  void modify_request_state(const DoutPrefixProvider* dpp, req_state* s) const override;
};

template <typename T>
void SysReqApplier<T>::to_str(std::ostream& out) const
{
  out << "rgw::auth::SysReqApplier" << " -> ";
  DecoratedApplier<T>::to_str(out);
}

template <typename T>
void SysReqApplier<T>::load_acct_info(const DoutPrefixProvider* dpp, RGWUserInfo& user_info) const
{
  DecoratedApplier<T>::load_acct_info(dpp, user_info);
  is_system = user_info.system;

  if (is_system) {


    rgw_user effective_uid(args.sys_get("rgwx-" "uid"));
    if (! effective_uid.empty()) {



      RGWUserInfo euser_info;
      if (rgw_get_user_info_by_uid(store, effective_uid, euser_info) < 0) {

        throw -
# 242 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h" 3 4
              13
# 242 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_filters.h"
                    ;
      }
      user_info = euser_info;
    }
  }
}

template <typename T>
void SysReqApplier<T>::modify_request_state(const DoutPrefixProvider* dpp, req_state* const s) const
{
  if (boost::logic::indeterminate(is_system)) {
    RGWUserInfo unused_info;
    load_acct_info(dpp, unused_info);
  }

  if (is_system) {
    s->info.args.set_system();
    s->system_request = true;
  }
  DecoratedApplier<T>::modify_request_state(dpp, s);
}

template <typename T> static inline
SysReqApplier<T> add_sysreq(CephContext* const cct,
                                        RGWRados* const store,
                            const req_state* const s,
                            T&& t) {
  return SysReqApplier<T>(cct, store, s, std::forward<T>(t));
}

}
}
# 30 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sts.h" 1






# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_role.h" 1
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_role.h"
# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rados.h" 1
# 12 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_role.h" 2

class RGWRole
{
  using string = std::string;
  static const string role_name_oid_prefix;
  static const string role_oid_prefix;
  static const string role_path_oid_prefix;
  static const string role_arn_prefix;
  static constexpr int MAX_ROLE_NAME_LEN = 64;
  static constexpr int MAX_PATH_NAME_LEN = 512;
  static constexpr uint64_t SESSION_DURATION_MIN = 3600;
  static constexpr uint64_t SESSION_DURATION_MAX = 43200;

  CephContext *cct;
  RGWRados *store;
  string id;
  string name;
  string path;
  string arn;
  string creation_date;
  string trust_policy;
  map<string, string> perm_policy_map;
  string tenant;
  uint64_t max_session_duration;

  int store_info(bool exclusive);
  int store_name(bool exclusive);
  int store_path(bool exclusive);
  int read_id(const string& role_name, const string& tenant, string& role_id);
  int read_name();
  int read_info();
  void set_id(const string& id) { this->id = id; }
  bool validate_input();
  void extract_name_tenant(const std::string& str);

public:
  RGWRole(CephContext *cct,
          RGWRados *store,
          string name,
          string path,
          string trust_policy,
          string tenant,
          string max_session_duration_str="")
  : cct(cct),
    store(store),
    name(std::move(name)),
    path(std::move(path)),
    trust_policy(std::move(trust_policy)),
    tenant(std::move(tenant)) {
    if (this->path.empty())
      this->path = "/";
    extract_name_tenant(this->name);
    if (max_session_duration_str.empty()) {
      max_session_duration = SESSION_DURATION_MIN;
    } else {
      max_session_duration = std::stoull(max_session_duration_str);
    }
  }

  RGWRole(CephContext *cct,
          RGWRados *store,
          string name,
          string tenant)
  : cct(cct),
    store(store),
    name(std::move(name)),
    tenant(std::move(tenant)) {
    extract_name_tenant(this->name);
  }

  RGWRole(CephContext *cct,
          RGWRados *store,
          string id)
  : cct(cct),
    store(store),
    id(std::move(id)) {}

  RGWRole(CephContext *cct,
          RGWRados *store)
  : cct(cct),
    store(store) {}

  RGWRole() {}

  ~RGWRole() = default;

  void encode(bufferlist& bl) const {
    __u8 struct_v = 3; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(id, bl);
    encode(name, bl);
    encode(path, bl);
    encode(arn, bl);
    encode(creation_date, bl);
    encode(trust_policy, bl);
    encode(perm_policy_map, bl);
    encode(tenant, bl);
    encode(max_session_duration, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (2 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "2" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(id, bl);
    decode(name, bl);
    decode(path, bl);
    decode(arn, bl);
    decode(creation_date, bl);
    decode(trust_policy, bl);
    decode(perm_policy_map, bl);
    if (struct_v >= 2) {
      decode(tenant, bl);
    }
    if (struct_v >= 3) {
      decode(max_session_duration, bl);
    }
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }

  const string& get_id() const { return id; }
  const string& get_name() const { return name; }
  const string& get_path() const { return path; }
  const string& get_create_date() const { return creation_date; }
  const string& get_assume_role_policy() const { return trust_policy;}
  const uint64_t& get_max_session_duration() const { return max_session_duration; }

  int create(bool exclusive);
  int delete_obj();
  int get();
  int get_by_id();
  int update();
  void update_trust_policy(string& trust_policy);
  void set_perm_policy(const string& policy_name, const string& perm_policy);
  vector<string> get_role_policy_names();
  int get_role_policy(const string& policy_name, string& perm_policy);
  int delete_policy(const string& policy_name);
  void dump(Formatter *f) const;
  void decode_json(JSONObj *obj);

  static const string& get_names_oid_prefix();
  static const string& get_info_oid_prefix();
  static const string& get_path_oid_prefix();
  static int get_roles_by_path_prefix(RGWRados *store,
                                      CephContext *cct,
                                      const string& path_prefix,
                                      const string& tenant,
                                      vector<RGWRole>& roles);
};
inline void encode(const RGWRole &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(RGWRole &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
# 8 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_sts.h" 2



namespace STS {

class AssumeRoleRequestBase {
protected:
  static constexpr uint64_t MIN_POLICY_SIZE = 1;
  static constexpr uint64_t MAX_POLICY_SIZE = 2048;
  static constexpr uint64_t DEFAULT_DURATION_IN_SECS = 3600;
  static constexpr uint64_t MIN_DURATION_IN_SECS = 900;
  static constexpr uint64_t MIN_ROLE_ARN_SIZE = 2;
  static constexpr uint64_t MAX_ROLE_ARN_SIZE = 2048;
  static constexpr uint64_t MIN_ROLE_SESSION_SIZE = 2;
  static constexpr uint64_t MAX_ROLE_SESSION_SIZE = 64;
  uint64_t MAX_DURATION_IN_SECS;
  uint64_t duration;
  string iamPolicy;
  string roleArn;
  string roleSessionName;
public:
  AssumeRoleRequestBase(const string& duration,
                        const string& iamPolicy,
                        const string& roleArn,
                        const string& roleSessionName);
  const string& getRoleARN() const { return roleArn; }
  const string& getRoleSessionName() const { return roleSessionName; }
  const string& getPolicy() const {return iamPolicy; }
  static const uint64_t& getMaxPolicySize() { return MAX_POLICY_SIZE; }
  void setMaxDuration(const uint64_t& maxDuration) { MAX_DURATION_IN_SECS = maxDuration; }
  const uint64_t& getDuration() const { return duration; }
  int validate_input() const;
};

class AssumeRoleWithWebIdentityRequest : public AssumeRoleRequestBase {
  static constexpr uint64_t MIN_PROVIDER_ID_LEN = 4;
  static constexpr uint64_t MAX_PROVIDER_ID_LEN = 2048;
  string providerId;
  string iamPolicy;
  string iss;
  string sub;
  string aud;
public:
  AssumeRoleWithWebIdentityRequest( const string& duration,
                      const string& providerId,
                      const string& iamPolicy,
                      const string& roleArn,
                      const string& roleSessionName,
                      const string& iss,
                      const string& sub,
                      const string& aud)
    : AssumeRoleRequestBase(duration, iamPolicy, roleArn, roleSessionName),
      providerId(providerId), iss(iss), sub(sub), aud(aud) {}
  const string& getProviderId() const { return providerId; }
  const string& getIss() const { return iss; }
  const string& getAud() const { return aud; }
  const string& getSub() const { return sub; }
  int validate_input() const;
};

class AssumeRoleRequest : public AssumeRoleRequestBase {
  static constexpr uint64_t MIN_EXTERNAL_ID_LEN = 2;
  static constexpr uint64_t MAX_EXTERNAL_ID_LEN = 1224;
  static constexpr uint64_t MIN_SERIAL_NUMBER_SIZE = 9;
  static constexpr uint64_t MAX_SERIAL_NUMBER_SIZE = 256;
  static constexpr uint64_t TOKEN_CODE_SIZE = 6;
  string externalId;
  string serialNumber;
  string tokenCode;
public:
  AssumeRoleRequest(const string& duration,
                    const string& externalId,
                    const string& iamPolicy,
                    const string& roleArn,
                    const string& roleSessionName,
                    const string& serialNumber,
                    const string& tokenCode)
    : AssumeRoleRequestBase(duration, iamPolicy, roleArn, roleSessionName),
      externalId(externalId), serialNumber(serialNumber), tokenCode(tokenCode){}
  int validate_input() const;
};

class GetSessionTokenRequest {
protected:
  static constexpr uint64_t MIN_DURATION_IN_SECS = 900;
  static constexpr uint64_t DEFAULT_DURATION_IN_SECS = 3600;
  uint64_t duration;
  string serialNumber;
  string tokenCode;

public:
  GetSessionTokenRequest(const string& duration, const string& serialNumber, const string& tokenCode);

  const uint64_t& getDuration() const { return duration; }
  static const uint64_t& getMinDuration() { return MIN_DURATION_IN_SECS; }
};

class AssumedRoleUser {
  string arn;
  string assumeRoleId;
public:
  int generateAssumedRoleUser( CephContext* cct,
                                RGWRados *store,
                                const string& roleId,
                                const rgw::ARN& roleArn,
                                const string& roleSessionName);
  const string& getARN() const { return arn; }
  const string& getAssumeRoleId() const { return assumeRoleId; }
  void dump(Formatter *f) const;
};

struct SessionToken {
  string access_key_id;
  string secret_access_key;
  string expiration;
  string policy;
  string roleId;
  rgw_user user;
  string acct_name;
  uint32_t perm_mask;
  bool is_admin;
  uint32_t acct_type;

  SessionToken() {}

  void encode(bufferlist& bl) const {
    __u8 struct_v = 1; __u8 struct_compat = 1; ceph_le32 struct_len; auto filler = (bl).append_hole(sizeof(struct_v) + sizeof(struct_compat) + sizeof(struct_len)); const auto starting_bl_len = (bl).length(); using ::ceph::encode; do {;
    encode(access_key_id, bl);
    encode(secret_access_key, bl);
    encode(expiration, bl);
    encode(policy, bl);
    encode(roleId, bl);
    encode(user, bl);
    encode(acct_name, bl);
    encode(perm_mask, bl);
    encode(is_admin, bl);
    encode(acct_type, bl);
    } while (false); if (0) { struct_compat = 0; } struct_len = (bl).length() - starting_bl_len; filler.copy_in(sizeof(struct_v), (char *)&struct_v); filler.copy_in(sizeof(struct_compat), (char *)&struct_compat); filler.copy_in(sizeof(struct_len), (char *)&struct_len);;
  }

  void decode(bufferlist::const_iterator& bl) {
    __u8 struct_v, struct_compat; using ::ceph::decode; decode(struct_v, bl); decode(struct_compat, bl); if (1 < struct_compat) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " no longer understand old encoding version " "1" " < " + std::to_string(struct_compat))); __u32 struct_len; decode(struct_len, bl); if (struct_len > bl.get_remaining()) throw ::ceph::buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); unsigned struct_end = bl.get_off() + struct_len; do {;
    decode(access_key_id, bl);
    decode(secret_access_key, bl);
    decode(expiration, bl);
    decode(policy, bl);
    decode(roleId, bl);
    decode(user, bl);
    decode(acct_name, bl);
    decode(perm_mask, bl);
    decode(is_admin, bl);
    decode(acct_type, bl);
    } while (false); if (struct_end) { if (bl.get_off() > struct_end) throw buffer::malformed_input((std::string(__PRETTY_FUNCTION__) + " decode past end of struct encoding")); if (bl.get_off() < struct_end) bl.advance(struct_end - bl.get_off()); };
  }
};
inline void encode(const SessionToken &c, ::ceph::bufferlist &bl, uint64_t features=0) { ; c.encode(bl); ; } inline void decode(SessionToken &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }

class Credentials {
  static constexpr int MAX_ACCESS_KEY_LEN = 20;
  static constexpr int MAX_SECRET_KEY_LEN = 40;
  string accessKeyId;
  string expiration;
  string secretAccessKey;
  string sessionToken;
public:
  int generateCredentials(CephContext* cct,
                          const uint64_t& duration,
                          const boost::optional<string>& policy,
                          const boost::optional<string>& roleId,
                          boost::optional<rgw_user> user,
                          rgw::auth::Identity* identity);
  const string& getAccessKeyId() const { return accessKeyId; }
  const string& getExpiration() const { return expiration; }
  const string& getSecretAccessKey() const { return secretAccessKey; }
  const string& getSessionToken() const { return sessionToken; }
  void dump(Formatter *f) const;
};

struct AssumeRoleResponse {
  int retCode;
  AssumedRoleUser user;
  Credentials creds;
  uint64_t packedPolicySize;
};

struct AssumeRoleWithWebIdentityResponse {
  AssumeRoleResponse assumeRoleResp;
  string aud;
  string providerId;
  string sub;
};

using AssumeRoleResponse = struct AssumeRoleResponse ;
using GetSessionTokenResponse = std::tuple<int, Credentials>;
using AssumeRoleWithWebIdentityResponse = struct AssumeRoleWithWebIdentityResponse;

class STSService {
  CephContext* cct;
  RGWRados *store;
  rgw_user user_id;
  RGWRole role;
  rgw::auth::Identity* identity;
  int storeARN(string& arn);
public:
  STSService() = default;
  STSService(CephContext* cct, RGWRados *store, rgw_user user_id, rgw::auth::Identity* identity) : cct(cct), store(store), user_id(user_id), identity(identity) {}
  std::tuple<int, RGWRole> getRoleInfo(const string& arn);
  AssumeRoleResponse assumeRole(AssumeRoleRequest& req);
  GetSessionTokenResponse getSessionToken(GetSessionTokenRequest& req);
  AssumeRoleWithWebIdentityResponse assumeRoleWithWebIdentity(AssumeRoleWithWebIdentityRequest& req);
};
}
# 31 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_rest_s3.h" 2

struct rgw_http_error {
  int http_ret;
  const char *s3_code;
};

void rgw_get_errno_s3(struct rgw_http_error *e, int err_no);

class RGWGetObj_ObjStore_S3 : public RGWGetObj_ObjStore
{
protected:


  int custom_http_ret = 0;
  std::map<std::string, std::string> crypt_http_responses;
public:
  RGWGetObj_ObjStore_S3() {}
  ~RGWGetObj_ObjStore_S3() override {}

  int get_params() override;
  int send_response_data_error() override;
  int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
  void set_custom_http_response(int http_ret) { custom_http_ret = http_ret; }
  int get_decrypt_filter(std::unique_ptr<RGWGetObj_Filter>* filter,
                         RGWGetObj_Filter* cb,
                         bufferlist* manifest_bl) override;
};

class RGWGetObjTags_ObjStore_S3 : public RGWGetObjTags_ObjStore
{
  bufferlist tags_bl;
public:
  RGWGetObjTags_ObjStore_S3() {}
  ~RGWGetObjTags_ObjStore_S3() {}

  void send_response_data(bufferlist &bl) override;
};

class RGWPutObjTags_ObjStore_S3 : public RGWPutObjTags_ObjStore
{
public:
  RGWPutObjTags_ObjStore_S3() {}
  ~RGWPutObjTags_ObjStore_S3() {}

  int get_params() override;
  void send_response() override;
};

class RGWDeleteObjTags_ObjStore_S3 : public RGWDeleteObjTags
{
public:
  ~RGWDeleteObjTags_ObjStore_S3() override {}
  void send_response() override;
};

class RGWListBuckets_ObjStore_S3 : public RGWListBuckets_ObjStore {
public:
  RGWListBuckets_ObjStore_S3() {}
  ~RGWListBuckets_ObjStore_S3() override {}

  int get_params() override {
    limit = -1;
    return 0;
  }
  void send_response_begin(bool has_buckets) override;
  void send_response_data(RGWUserBuckets& buckets) override;
  void send_response_end() override;
};

class RGWGetUsage_ObjStore_S3 : public RGWGetUsage_ObjStore {
public:
  RGWGetUsage_ObjStore_S3() {}
  ~RGWGetUsage_ObjStore_S3() override {}

  int get_params() override ;
  void send_response() override;
};

class RGWListBucket_ObjStore_S3 : public RGWListBucket_ObjStore {
  protected: bool objs_container;
  int get_common_params();
  void send_common_response();
  void send_common_versioned_response();
  public:
  RGWListBucket_ObjStore_S3() : objs_container(false) {
    default_max = 1000;
  }
  ~RGWListBucket_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
  void send_versioned_response();
};

class RGWListBucket_ObjStore_S3v2 : public RGWListBucket_ObjStore_S3 {
  bool fetchOwner;
  bool start_after_exist;
  bool continuation_token_exist;
  string startAfter;
  string continuation_token;
public:
  RGWListBucket_ObjStore_S3v2() : fetchOwner(false) {
  }
  ~RGWListBucket_ObjStore_S3v2() override {}

  int get_params() override;
  void send_response() override;
  void send_versioned_response();
};

class RGWGetBucketLogging_ObjStore_S3 : public RGWGetBucketLogging {
public:
  RGWGetBucketLogging_ObjStore_S3() {}
  ~RGWGetBucketLogging_ObjStore_S3() override {}

  void send_response() override;
};

class RGWGetBucketLocation_ObjStore_S3 : public RGWGetBucketLocation {
public:
  RGWGetBucketLocation_ObjStore_S3() {}
  ~RGWGetBucketLocation_ObjStore_S3() override {}

  void send_response() override;
};

class RGWGetBucketVersioning_ObjStore_S3 : public RGWGetBucketVersioning {
public:
  RGWGetBucketVersioning_ObjStore_S3() {}
  ~RGWGetBucketVersioning_ObjStore_S3() override {}

  void send_response() override;
};

class RGWSetBucketVersioning_ObjStore_S3 : public RGWSetBucketVersioning {
public:
  RGWSetBucketVersioning_ObjStore_S3() {}
  ~RGWSetBucketVersioning_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
};

class RGWGetBucketWebsite_ObjStore_S3 : public RGWGetBucketWebsite {
public:
  RGWGetBucketWebsite_ObjStore_S3() {}
  ~RGWGetBucketWebsite_ObjStore_S3() override {}

  void send_response() override;
};

class RGWSetBucketWebsite_ObjStore_S3 : public RGWSetBucketWebsite {
public:
  RGWSetBucketWebsite_ObjStore_S3() {}
  ~RGWSetBucketWebsite_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
};

class RGWDeleteBucketWebsite_ObjStore_S3 : public RGWDeleteBucketWebsite {
public:
  RGWDeleteBucketWebsite_ObjStore_S3() {}
  ~RGWDeleteBucketWebsite_ObjStore_S3() override {}

  void send_response() override;
};

class RGWStatBucket_ObjStore_S3 : public RGWStatBucket_ObjStore {
public:
  RGWStatBucket_ObjStore_S3() {}
  ~RGWStatBucket_ObjStore_S3() override {}

  void send_response() override;
};

class RGWCreateBucket_ObjStore_S3 : public RGWCreateBucket_ObjStore {
public:
  RGWCreateBucket_ObjStore_S3() {}
  ~RGWCreateBucket_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
};

class RGWDeleteBucket_ObjStore_S3 : public RGWDeleteBucket_ObjStore {
public:
  RGWDeleteBucket_ObjStore_S3() {}
  ~RGWDeleteBucket_ObjStore_S3() override {}

  void send_response() override;
};

class RGWPutObj_ObjStore_S3 : public RGWPutObj_ObjStore {
private:
  std::map<std::string, std::string> crypt_http_responses;

public:
  RGWPutObj_ObjStore_S3() {}
  ~RGWPutObj_ObjStore_S3() override {}

  int get_params() override;
  int get_data(bufferlist& bl) override;
  void send_response() override;

  int get_encrypt_filter(std::unique_ptr<rgw::putobj::DataProcessor> *filter,
                         rgw::putobj::DataProcessor *cb) override;
  int get_decrypt_filter(std::unique_ptr<RGWGetObj_Filter>* filter,
                         RGWGetObj_Filter* cb,
                         map<string, bufferlist>& attrs,
                         bufferlist* manifest_bl) override;
};

class RGWPostObj_ObjStore_S3 : public RGWPostObj_ObjStore {
  parts_collection_t parts;
  std::string filename;
  std::string content_type;
  RGWPolicyEnv env;
  RGWPolicy post_policy;
  map<string, string> crypt_http_responses;

  const rgw::auth::StrategyRegistry* auth_registry_ptr = nullptr;

  int get_policy();
  int get_tags();
  void rebuild_key(string& key);

  std::string get_current_filename() const override;
  std::string get_current_content_type() const override;

public:
  RGWPostObj_ObjStore_S3() {}
  ~RGWPostObj_ObjStore_S3() override {}

  int verify_requester(const rgw::auth::StrategyRegistry& auth_registry) override {
    auth_registry_ptr = &auth_registry;
    return RGWPostObj_ObjStore::verify_requester(auth_registry);
  }

  int get_params() override;
  int complete_get_params();

  void send_response() override;
  int get_data(ceph::bufferlist& bl, bool& again) override;
  int get_encrypt_filter(std::unique_ptr<rgw::putobj::DataProcessor> *filter,
                         rgw::putobj::DataProcessor *cb) override;
};

class RGWDeleteObj_ObjStore_S3 : public RGWDeleteObj_ObjStore {
public:
  RGWDeleteObj_ObjStore_S3() {}
  ~RGWDeleteObj_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
};

class RGWCopyObj_ObjStore_S3 : public RGWCopyObj_ObjStore {
  bool sent_header;
public:
  RGWCopyObj_ObjStore_S3() : sent_header(false) {}
  ~RGWCopyObj_ObjStore_S3() override {}

  int init_dest_policy() override;
  int get_params() override;
  int check_storage_class(const rgw_placement_rule& src_placement);
  void send_partial_response(off_t ofs) override;
  void send_response() override;
};

class RGWGetACLs_ObjStore_S3 : public RGWGetACLs_ObjStore {
public:
  RGWGetACLs_ObjStore_S3() {}
  ~RGWGetACLs_ObjStore_S3() override {}

  void send_response() override;
};

class RGWPutACLs_ObjStore_S3 : public RGWPutACLs_ObjStore {
public:
  RGWPutACLs_ObjStore_S3() {}
  ~RGWPutACLs_ObjStore_S3() override {}

  int get_policy_from_state(RGWRados *store, struct req_state *s, stringstream& ss) override;
  void send_response() override;
  int get_params() override;
};

class RGWGetLC_ObjStore_S3 : public RGWGetLC_ObjStore {
protected:
  RGWLifecycleConfiguration_S3 config;
public:
  RGWGetLC_ObjStore_S3() {}
  ~RGWGetLC_ObjStore_S3() override {}
  void execute() override;

 void send_response() override;
};

class RGWPutLC_ObjStore_S3 : public RGWPutLC_ObjStore {
public:
  RGWPutLC_ObjStore_S3() {}
  ~RGWPutLC_ObjStore_S3() override {}

 void send_response() override;
};

class RGWDeleteLC_ObjStore_S3 : public RGWDeleteLC_ObjStore {
public:
  RGWDeleteLC_ObjStore_S3() {}
  ~RGWDeleteLC_ObjStore_S3() override {}

 void send_response() override;
};

class RGWGetCORS_ObjStore_S3 : public RGWGetCORS_ObjStore {
public:
  RGWGetCORS_ObjStore_S3() {}
  ~RGWGetCORS_ObjStore_S3() override {}

  void send_response() override;
};

class RGWPutCORS_ObjStore_S3 : public RGWPutCORS_ObjStore {
public:
  RGWPutCORS_ObjStore_S3() {}
  ~RGWPutCORS_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
};

class RGWDeleteCORS_ObjStore_S3 : public RGWDeleteCORS_ObjStore {
public:
  RGWDeleteCORS_ObjStore_S3() {}
  ~RGWDeleteCORS_ObjStore_S3() override {}

  void send_response() override;
};

class RGWOptionsCORS_ObjStore_S3 : public RGWOptionsCORS_ObjStore {
public:
  RGWOptionsCORS_ObjStore_S3() {}
  ~RGWOptionsCORS_ObjStore_S3() override {}

  void send_response() override;
};

class RGWGetRequestPayment_ObjStore_S3 : public RGWGetRequestPayment {
public:
  RGWGetRequestPayment_ObjStore_S3() {}
  ~RGWGetRequestPayment_ObjStore_S3() override {}

  void send_response() override;
};

class RGWSetRequestPayment_ObjStore_S3 : public RGWSetRequestPayment {
public:
  RGWSetRequestPayment_ObjStore_S3() {}
  ~RGWSetRequestPayment_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
};

class RGWInitMultipart_ObjStore_S3 : public RGWInitMultipart_ObjStore {
private:
  std::map<std::string, std::string> crypt_http_responses;
public:
  RGWInitMultipart_ObjStore_S3() {}
  ~RGWInitMultipart_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
  int prepare_encryption(map<string, bufferlist>& attrs) override;
};

class RGWCompleteMultipart_ObjStore_S3 : public RGWCompleteMultipart_ObjStore {
public:
  RGWCompleteMultipart_ObjStore_S3() {}
  ~RGWCompleteMultipart_ObjStore_S3() override {}

  int get_params() override;
  void send_response() override;
};

class RGWAbortMultipart_ObjStore_S3 : public RGWAbortMultipart_ObjStore {
public:
  RGWAbortMultipart_ObjStore_S3() {}
  ~RGWAbortMultipart_ObjStore_S3() override {}

  void send_response() override;
};

class RGWListMultipart_ObjStore_S3 : public RGWListMultipart_ObjStore {
public:
  RGWListMultipart_ObjStore_S3() {}
  ~RGWListMultipart_ObjStore_S3() override {}

  void send_response() override;
};

class RGWListBucketMultiparts_ObjStore_S3 : public RGWListBucketMultiparts_ObjStore {
public:
  RGWListBucketMultiparts_ObjStore_S3() {
    default_max = 1000;
  }
  ~RGWListBucketMultiparts_ObjStore_S3() override {}

  void send_response() override;
};

class RGWDeleteMultiObj_ObjStore_S3 : public RGWDeleteMultiObj_ObjStore {
public:
  RGWDeleteMultiObj_ObjStore_S3() {}
  ~RGWDeleteMultiObj_ObjStore_S3() override {}

  int get_params() override;
  void send_status() override;
  void begin_response() override;
  void send_partial_response(rgw_obj_key& key, bool delete_marker,
                             const string& marker_version_id, int ret) override;
  void end_response() override;
};

class RGWPutBucketObjectLock_ObjStore_S3 : public RGWPutBucketObjectLock_ObjStore {
public:
  RGWPutBucketObjectLock_ObjStore_S3() {}
  ~RGWPutBucketObjectLock_ObjStore_S3() override {}
  void send_response() override;
};

class RGWGetBucketObjectLock_ObjStore_S3 : public RGWGetBucketObjectLock_ObjStore {
public:
  RGWGetBucketObjectLock_ObjStore_S3() {}
  ~RGWGetBucketObjectLock_ObjStore_S3() {}
  void send_response() override;
};

class RGWPutObjRetention_ObjStore_S3 : public RGWPutObjRetention_ObjStore {
public:
  RGWPutObjRetention_ObjStore_S3() {}
  ~RGWPutObjRetention_ObjStore_S3() {}
  int get_params() override;
  void send_response() override;
};

class RGWGetObjRetention_ObjStore_S3 : public RGWGetObjRetention_ObjStore {
public:
  RGWGetObjRetention_ObjStore_S3() {}
  ~RGWGetObjRetention_ObjStore_S3() {}
  void send_response() override;
};

class RGWPutObjLegalHold_ObjStore_S3 : public RGWPutObjLegalHold_ObjStore {
public:
  RGWPutObjLegalHold_ObjStore_S3() {}
  ~RGWPutObjLegalHold_ObjStore_S3() {}
  void send_response() override;
};

class RGWGetObjLegalHold_ObjStore_S3 : public RGWGetObjLegalHold_ObjStore {
public:
  RGWGetObjLegalHold_ObjStore_S3() {}
  ~RGWGetObjLegalHold_ObjStore_S3() {}
  void send_response() override;
};

class RGWGetObjLayout_ObjStore_S3 : public RGWGetObjLayout {
public:
  RGWGetObjLayout_ObjStore_S3() {}
  ~RGWGetObjLayout_ObjStore_S3() {}

  void send_response() override;
};

class RGWConfigBucketMetaSearch_ObjStore_S3 : public RGWConfigBucketMetaSearch {
public:
  RGWConfigBucketMetaSearch_ObjStore_S3() {}
  ~RGWConfigBucketMetaSearch_ObjStore_S3() {}

  int get_params() override;
  void send_response() override;
};

class RGWGetBucketMetaSearch_ObjStore_S3 : public RGWGetBucketMetaSearch {
public:
  RGWGetBucketMetaSearch_ObjStore_S3() {}
  ~RGWGetBucketMetaSearch_ObjStore_S3() {}

  void send_response() override;
};

class RGWDelBucketMetaSearch_ObjStore_S3 : public RGWDelBucketMetaSearch {
public:
  RGWDelBucketMetaSearch_ObjStore_S3() {}
  ~RGWDelBucketMetaSearch_ObjStore_S3() {}

  void send_response() override;
};

class RGW_Auth_S3 {
public:
  static int authorize(const DoutPrefixProvider *dpp,
                       RGWRados *store,
                       const rgw::auth::StrategyRegistry& auth_registry,
                       struct req_state *s);
};

class RGWHandler_Auth_S3 : public RGWHandler_REST {
  friend class RGWRESTMgr_S3;

  const rgw::auth::StrategyRegistry& auth_registry;

public:
  explicit RGWHandler_Auth_S3(const rgw::auth::StrategyRegistry& auth_registry)
    : RGWHandler_REST(),
      auth_registry(auth_registry) {
  }
  ~RGWHandler_Auth_S3() override = default;

  static int validate_bucket_name(const string& bucket);
  static int validate_object_name(const string& bucket);

  int init(RGWRados *store,
           struct req_state *s,
           rgw::io::BasicClient *cio) override;
  int authorize(const DoutPrefixProvider *dpp) override {
    return RGW_Auth_S3::authorize(dpp, store, auth_registry, s);
  }
  int postauth_init() override { return 0; }
};

class RGWHandler_REST_S3 : public RGWHandler_REST {
  friend class RGWRESTMgr_S3;
protected:
  const rgw::auth::StrategyRegistry& auth_registry;
public:
  static int init_from_header(struct req_state *s, int default_formatter, bool configurable_format);

  explicit RGWHandler_REST_S3(const rgw::auth::StrategyRegistry& auth_registry)
    : RGWHandler_REST(),
      auth_registry(auth_registry) {
    }
  ~RGWHandler_REST_S3() override = default;

  int init(RGWRados *store,
           struct req_state *s,
           rgw::io::BasicClient *cio) override;
  int authorize(const DoutPrefixProvider *dpp) override;
  int postauth_init() override;
};

class RGWHandler_REST_Service_S3 : public RGWHandler_REST_S3 {
protected:
    const bool isSTSenabled;
    const bool isPSenabled;
    bool is_usage_op() {
    return s->info.args.exists("usage");
  }
  RGWOp *op_get() override;
  RGWOp *op_head() override;
  RGWOp *op_post() override;
public:
   RGWHandler_REST_Service_S3(const rgw::auth::StrategyRegistry& auth_registry,
                              bool _isSTSenabled, bool _isPSenabled) :
      RGWHandler_REST_S3(auth_registry), isSTSenabled(_isSTSenabled), isPSenabled(_isPSenabled) {}
  ~RGWHandler_REST_Service_S3() override = default;
};

class RGWHandler_REST_Bucket_S3 : public RGWHandler_REST_S3 {
  const bool enable_pubsub;
protected:
  bool is_acl_op() {
    return s->info.args.exists("acl");
  }
  bool is_cors_op() {
      return s->info.args.exists("cors");
  }
  bool is_lc_op() {
      return s->info.args.exists("lifecycle");
  }
  bool is_obj_update_op() override {
    return is_acl_op() || is_cors_op();
  }
  bool is_request_payment_op() {
    return s->info.args.exists("requestPayment");
  }
  bool is_policy_op() {
    return s->info.args.exists("policy");
  }
  bool is_object_lock_op() {
    return s->info.args.exists("object-lock");
  }
  bool is_notification_op() const {
    if (enable_pubsub) {
        return s->info.args.exists("notification");
    }
    return false;
  }
  RGWOp *get_obj_op(bool get_data);

  RGWOp *op_get() override;
  RGWOp *op_head() override;
  RGWOp *op_put() override;
  RGWOp *op_delete() override;
  RGWOp *op_post() override;
  RGWOp *op_options() override;
public:
  RGWHandler_REST_Bucket_S3(const rgw::auth::StrategyRegistry& auth_registry, bool _enable_pubsub) :
      RGWHandler_REST_S3(auth_registry), enable_pubsub(_enable_pubsub) {}
  ~RGWHandler_REST_Bucket_S3() override = default;
};

class RGWHandler_REST_Obj_S3 : public RGWHandler_REST_S3 {
protected:
  bool is_acl_op() {
    return s->info.args.exists("acl");
  }
  bool is_tagging_op() {
    return s->info.args.exists("tagging");
  }
  bool is_obj_retention_op() {
    return s->info.args.exists("retention");
  }
  bool is_obj_legal_hold_op() {
    return s->info.args.exists("legal-hold");
  }

  bool is_obj_update_op() override {
    return is_acl_op() || is_tagging_op() || is_obj_retention_op() || is_obj_legal_hold_op();
  }
  RGWOp *get_obj_op(bool get_data);

  RGWOp *op_get() override;
  RGWOp *op_head() override;
  RGWOp *op_put() override;
  RGWOp *op_delete() override;
  RGWOp *op_post() override;
  RGWOp *op_options() override;
public:
  using RGWHandler_REST_S3::RGWHandler_REST_S3;
  ~RGWHandler_REST_Obj_S3() override = default;
};

class RGWRESTMgr_S3 : public RGWRESTMgr {
private:
  bool enable_s3website;
  bool enable_sts;
  const bool enable_pubsub;
public:
  explicit RGWRESTMgr_S3(bool enable_s3website = false, bool enable_sts = false, bool _enable_pubsub = false)
    : enable_s3website(enable_s3website),
      enable_sts(enable_sts),
      enable_pubsub(_enable_pubsub) {
  }

  ~RGWRESTMgr_S3() override = default;

  RGWHandler_REST *get_handler(struct req_state* s,
                               const rgw::auth::StrategyRegistry& auth_registry,
                               const std::string& frontend_prefix) override;
};

class RGWHandler_REST_Obj_S3Website;

static inline bool looks_like_ip_address(const char *bucket)
{
  int num_periods = 0;
  bool expect_period = false;
  for (const char *b = bucket; *b; ++b) {
    if (*b == '.') {
      if (!expect_period)
 return false;
      ++num_periods;
      if (num_periods > 3)
 return false;
      expect_period = false;
    }
    else if (isdigit(*b)) {
      expect_period = true;
    }
    else {
      return false;
    }
  }
  return (num_periods == 3);
}

static inline int valid_s3_object_name(const string& name) {
  if (name.size() > 1024) {
    return -2001;
  }
  if (check_utf8(name.c_str(), name.size())) {
    return -2001;
  }
  return 0;
}

static inline int valid_s3_bucket_name(const string& name, bool relaxed=false)
{


  int len = name.size();
  if (len < 3) {

    return -2000;
  } else if (len > 255) {

    return -2000;
  }


  if (!(isalpha(name[0]) || isdigit(name[0]))) {
    if (!relaxed)
      return -2000;
    else if (!(name[0] == '_' || name[0] == '.' || name[0] == '-'))
      return -2000;
  }

  for (const char *s = name.c_str(); *s; ++s) {
    char c = *s;
    if (isdigit(c) || (c == '.'))
      continue;
    if (isalpha(c))
      continue;
    if ((c == '-') || (c == '_'))
      continue;

    return -2000;
  }

  if (looks_like_ip_address(name.c_str()))
    return -2000;

  return 0;
}


namespace rgw {
namespace auth {
namespace s3 {

class AWSEngine : public rgw::auth::Engine {
public:
  class VersionAbstractor {
    static constexpr size_t DIGEST_SIZE_V2 = 20;
    static constexpr size_t DIGEST_SIZE_V4 = 32;




    static constexpr size_t SIGNATURE_MAX_SIZE =
      std::max(DIGEST_SIZE_V2, DIGEST_SIZE_V4) * 2 + sizeof('\0');

  public:
    virtual ~VersionAbstractor() {};

    using access_key_id_t = boost::string_view;
    using client_signature_t = boost::string_view;
    using session_token_t = boost::string_view;
    using server_signature_t = basic_sstring<char, uint16_t, SIGNATURE_MAX_SIZE>;
    using string_to_sign_t = std::string;




    using signature_factory_t =
      std::function<server_signature_t(CephContext* cct,
                                       const std::string& secret_key,
                                       const string_to_sign_t& string_to_sign)>;




    using completer_factory_t =
      std::function<rgw::auth::Completer::cmplptr_t(
        const boost::optional<std::string>& secret_key)>;

    struct auth_data_t {
      access_key_id_t access_key_id;
      client_signature_t client_signature;
      session_token_t session_token;
      string_to_sign_t string_to_sign;
      signature_factory_t signature_factory;
      completer_factory_t completer_factory;
    };

    virtual auth_data_t get_auth_data(const req_state* s) const = 0;
  };

protected:
  CephContext* cct;
  const VersionAbstractor& ver_abstractor;

  AWSEngine(CephContext* const cct, const VersionAbstractor& ver_abstractor)
    : cct(cct),
      ver_abstractor(ver_abstractor) {
  }

  using result_t = rgw::auth::Engine::result_t;
  using string_to_sign_t = VersionAbstractor::string_to_sign_t;
  using signature_factory_t = VersionAbstractor::signature_factory_t;
  using completer_factory_t = VersionAbstractor::completer_factory_t;




  virtual result_t authenticate(const DoutPrefixProvider* dpp,
                                const boost::string_view& access_key_id,
                                const boost::string_view& signature,
                                const boost::string_view& session_token,
                                const string_to_sign_t& string_to_sign,
                                const signature_factory_t& signature_factory,
                                const completer_factory_t& completer_factory,
                                const req_state* s) const = 0;

public:
  result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s) const final;
};


class AWSGeneralAbstractor : public AWSEngine::VersionAbstractor {
  CephContext* const cct;

  virtual boost::optional<std::string>
  get_v4_canonical_headers(const req_info& info,
                           const boost::string_view& signedheaders,
                           const bool using_qs) const;

  auth_data_t get_auth_data_v2(const req_state* s) const;
  auth_data_t get_auth_data_v4(const req_state* s, const bool using_qs) const;

public:
  explicit AWSGeneralAbstractor(CephContext* const cct)
    : cct(cct) {
  }

  auth_data_t get_auth_data(const req_state* s) const override;
};

class AWSGeneralBoto2Abstractor : public AWSGeneralAbstractor {
  boost::optional<std::string>
  get_v4_canonical_headers(const req_info& info,
                           const boost::string_view& signedheaders,
                           const bool using_qs) const override;

public:
  using AWSGeneralAbstractor::AWSGeneralAbstractor;
};

class AWSBrowserUploadAbstractor : public AWSEngine::VersionAbstractor {
  static std::string to_string(ceph::bufferlist bl) {
    return std::string(bl.c_str(),
                       static_cast<std::string::size_type>(bl.length()));
  }

  auth_data_t get_auth_data_v2(const req_state* s) const;
  auth_data_t get_auth_data_v4(const req_state* s) const;

public:
  explicit AWSBrowserUploadAbstractor(CephContext*) {
  }

  auth_data_t get_auth_data(const req_state* s) const override;
};


class LDAPEngine : public AWSEngine {
  static rgw::LDAPHelper* ldh;
  static std::mutex mtx;

  static void init(CephContext* const cct);

  using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;
  using auth_info_t = rgw::auth::RemoteApplier::AuthInfo;
  using result_t = rgw::auth::Engine::result_t;

protected:
  RGWRados* const store;
  const rgw::auth::RemoteApplier::Factory* const apl_factory;

  acl_strategy_t get_acl_strategy() const;
  auth_info_t get_creds_info(const rgw::RGWToken& token) const noexcept;

  result_t authenticate(const DoutPrefixProvider* dpp,
                        const boost::string_view& access_key_id,
                        const boost::string_view& signature,
                        const boost::string_view& session_token,
                        const string_to_sign_t& string_to_sign,
                        const signature_factory_t&,
                        const completer_factory_t& completer_factory,
                        const req_state* s) const override;
public:
  LDAPEngine(CephContext* const cct,
             RGWRados* const store,
             const VersionAbstractor& ver_abstractor,
             const rgw::auth::RemoteApplier::Factory* const apl_factory)
    : AWSEngine(cct, ver_abstractor),
      store(store),
      apl_factory(apl_factory) {
    init(cct);
  }

  using AWSEngine::authenticate;

  const char* get_name() const noexcept override {
    return "rgw::auth::s3::LDAPEngine";
  }

  static bool valid();
  static void shutdown();
};

class LocalEngine : public AWSEngine {
  RGWRados* const store;
  const rgw::auth::LocalApplier::Factory* const apl_factory;

  result_t authenticate(const DoutPrefixProvider* dpp,
                        const boost::string_view& access_key_id,
                        const boost::string_view& signature,
                        const boost::string_view& session_token,
                        const string_to_sign_t& string_to_sign,
                        const signature_factory_t& signature_factory,
                        const completer_factory_t& completer_factory,
                        const req_state* s) const override;
public:
  LocalEngine(CephContext* const cct,
              RGWRados* const store,
              const VersionAbstractor& ver_abstractor,
              const rgw::auth::LocalApplier::Factory* const apl_factory)
    : AWSEngine(cct, ver_abstractor),
      store(store),
      apl_factory(apl_factory) {
  }

  using AWSEngine::authenticate;

  const char* get_name() const noexcept override {
    return "rgw::auth::s3::LocalEngine";
  }
};

class STSEngine : public AWSEngine {
  RGWRados* const store;
  const rgw::auth::LocalApplier::Factory* const local_apl_factory;
  const rgw::auth::RemoteApplier::Factory* const remote_apl_factory;
  const rgw::auth::RoleApplier::Factory* const role_apl_factory;

  using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;
  using auth_info_t = rgw::auth::RemoteApplier::AuthInfo;

  acl_strategy_t get_acl_strategy() const { return nullptr; };
  auth_info_t get_creds_info(const STS::SessionToken& token) const noexcept;

  int get_session_token(const boost::string_view& session_token,
                        STS::SessionToken& token) const;

  result_t authenticate(const DoutPrefixProvider* dpp,
                        const boost::string_view& access_key_id,
                        const boost::string_view& signature,
                        const boost::string_view& session_token,
                        const string_to_sign_t& string_to_sign,
                        const signature_factory_t& signature_factory,
                        const completer_factory_t& completer_factory,
                        const req_state* s) const override;
public:
  STSEngine(CephContext* const cct,
              RGWRados* const store,
              const VersionAbstractor& ver_abstractor,
              const rgw::auth::LocalApplier::Factory* const local_apl_factory,
              const rgw::auth::RemoteApplier::Factory* const remote_apl_factory,
              const rgw::auth::RoleApplier::Factory* const role_apl_factory)
    : AWSEngine(cct, ver_abstractor),
      store(store),
      local_apl_factory(local_apl_factory),
      remote_apl_factory(remote_apl_factory),
      role_apl_factory(role_apl_factory) {
  }

  using AWSEngine::authenticate;

  const char* get_name() const noexcept override {
    return "rgw::auth::s3::STSEngine";
  }
};

class S3AnonymousEngine : public rgw::auth::AnonymousEngine {
  bool is_applicable(const req_state* s) const noexcept override;

public:

  using rgw::auth::AnonymousEngine::AnonymousEngine;

  const char* get_name() const noexcept override {
    return "rgw::auth::s3::S3AnonymousEngine";
  }
};


class S3AuthFactory : public rgw::auth::RemoteApplier::Factory,
                      public rgw::auth::LocalApplier::Factory {
  typedef rgw::auth::IdentityApplier::aplptr_t aplptr_t;
  RGWRados* const store;

public:
  explicit S3AuthFactory(RGWRados* const store)
    : store(store) {
  }

  aplptr_t create_apl_remote(CephContext* const cct,
                             const req_state* const s,
                             rgw::auth::RemoteApplier::acl_strategy_t&& acl_alg,
                             const rgw::auth::RemoteApplier::AuthInfo &info
                            ) const override {
    return aplptr_t(
      new rgw::auth::RemoteApplier(cct, store, std::move(acl_alg), info,
                                   cct->_conf->rgw_keystone_implicit_tenants));
  }

  aplptr_t create_apl_local(CephContext* const cct,
                            const req_state* const s,
                            const RGWUserInfo& user_info,
                            const std::string& subuser,
                            const boost::optional<uint32_t>& perm_mask) const override {
      return aplptr_t(
        new rgw::auth::LocalApplier(cct, user_info, subuser, perm_mask));
  }
};


}
}
}
# 14 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_auth_keystone.h" 2



namespace rgw {
namespace auth {
namespace keystone {





class TokenEngine : public rgw::auth::Engine {
  CephContext* const cct;

  using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;
  using auth_info_t = rgw::auth::RemoteApplier::AuthInfo;
  using result_t = rgw::auth::Engine::result_t;
  using token_envelope_t = rgw::keystone::TokenEnvelope;

  const rgw::auth::TokenExtractor* const extractor;
  const rgw::auth::RemoteApplier::Factory* const apl_factory;
  rgw::keystone::Config& config;
  rgw::keystone::TokenCache& token_cache;


  bool is_applicable(const std::string& token) const noexcept;
  token_envelope_t decode_pki_token(const DoutPrefixProvider* dpp, const std::string& token) const;

  boost::optional<token_envelope_t>
  get_from_keystone(const DoutPrefixProvider* dpp, const std::string& token) const;

  acl_strategy_t get_acl_strategy(const token_envelope_t& token) const;
  auth_info_t get_creds_info(const token_envelope_t& token,
                             const std::vector<std::string>& admin_roles
                            ) const noexcept;
  result_t authenticate(const DoutPrefixProvider* dpp,
                        const std::string& token,
                        const req_state* s) const;

public:
  TokenEngine(CephContext* const cct,
              const rgw::auth::TokenExtractor* const extractor,
              const rgw::auth::RemoteApplier::Factory* const apl_factory,
              rgw::keystone::Config& config,
              rgw::keystone::TokenCache& token_cache)
    : cct(cct),
      extractor(extractor),
      apl_factory(apl_factory),
      config(config),
      token_cache(token_cache) {
  }

  const char* get_name() const noexcept override {
    return "rgw::auth::keystone::TokenEngine";
  }

  result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s) const override {
    return authenticate(dpp, extractor->get_token(s), s);
  }
};


class EC2Engine : public rgw::auth::s3::AWSEngine {
  using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;
  using auth_info_t = rgw::auth::RemoteApplier::AuthInfo;
  using result_t = rgw::auth::Engine::result_t;
  using token_envelope_t = rgw::keystone::TokenEnvelope;

  const rgw::auth::RemoteApplier::Factory* const apl_factory;
  rgw::keystone::Config& config;
  rgw::keystone::TokenCache& token_cache;


  acl_strategy_t get_acl_strategy(const token_envelope_t& token) const;
  auth_info_t get_creds_info(const token_envelope_t& token,
                             const std::vector<std::string>& admin_roles
                            ) const noexcept;
  std::pair<boost::optional<token_envelope_t>, int>
  get_from_keystone(const DoutPrefixProvider* dpp, const boost::string_view& access_key_id,
                    const std::string& string_to_sign,
                    const boost::string_view& signature) const;
  result_t authenticate(const DoutPrefixProvider* dpp,
                        const boost::string_view& access_key_id,
                        const boost::string_view& signature,
                        const boost::string_view& session_token,
                        const string_to_sign_t& string_to_sign,
                        const signature_factory_t&,
                        const completer_factory_t& completer_factory,
                        const req_state* s) const override;
public:
  EC2Engine(CephContext* const cct,
            const rgw::auth::s3::AWSEngine::VersionAbstractor* const ver_abstractor,
            const rgw::auth::RemoteApplier::Factory* const apl_factory,
            rgw::keystone::Config& config,



            rgw::keystone::TokenCache& token_cache)
    : AWSEngine(cct, *ver_abstractor),
      apl_factory(apl_factory),
      config(config),
      token_cache(token_cache) {
  }

  using AWSEngine::authenticate;

  const char* get_name() const noexcept override {
    return "rgw::auth::keystone::EC2Engine";
  }

};

};
};
};
# 11 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.h" 2




namespace rgw {
namespace auth {
namespace swift {


class TempURLApplier : public rgw::auth::LocalApplier {
public:
  TempURLApplier(CephContext* const cct,
                 const RGWUserInfo& user_info)
    : LocalApplier(cct, user_info, LocalApplier::NO_SUBUSER, boost::none) {
  };

  void modify_request_state(const DoutPrefixProvider* dpp, req_state * s) const override;

  struct Factory {
    virtual ~Factory() {}
    virtual aplptr_t create_apl_turl(CephContext* cct,
                                     const req_state* s,
                                     const RGWUserInfo& user_info) const = 0;
  };
};


class TempURLEngine : public rgw::auth::Engine {
  using result_t = rgw::auth::Engine::result_t;

  CephContext* const cct;
              RGWRados* const store;
  const TempURLApplier::Factory* const apl_factory;


  void get_owner_info(const DoutPrefixProvider* dpp,
                      const req_state* s,
                      RGWUserInfo& owner_info) const;
  std::string convert_from_iso8601(std::string expires) const;
  bool is_applicable(const req_state* s) const noexcept;
  bool is_expired(const std::string& expires) const;
  bool is_disallowed_header_present(const req_info& info) const;

  class SignatureHelper;
  class PrefixableSignatureHelper;

public:
  TempURLEngine(CephContext* const cct,
                          RGWRados* const store,
                const TempURLApplier::Factory* const apl_factory)
    : cct(cct),
      store(store),
      apl_factory(apl_factory) {
  }


  const char* get_name() const noexcept override {
    return "rgw::auth::swift::TempURLEngine";
  }

  result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s) const override;
};



class SignedTokenEngine : public rgw::auth::Engine {
  using result_t = rgw::auth::Engine::result_t;

  CephContext* const cct;
  RGWRados* const store;
  const rgw::auth::TokenExtractor* const extractor;
  const rgw::auth::LocalApplier::Factory* const apl_factory;

  bool is_applicable(const std::string& token) const noexcept;
  result_t authenticate(const DoutPrefixProvider* dpp,
                        const std::string& token,
                        const req_state* s) const;

public:
  SignedTokenEngine(CephContext* const cct,
                               RGWRados* const store,
                    const rgw::auth::TokenExtractor* const extractor,
                    const rgw::auth::LocalApplier::Factory* const apl_factory)
    : cct(cct),
      store(store),
      extractor(extractor),
      apl_factory(apl_factory) {
  }

  const char* get_name() const noexcept override {
    return "rgw::auth::swift::SignedTokenEngine";
  }

  result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s) const override {
    return authenticate(dpp, extractor->get_token(s), s);
  }
};



class ExternalTokenEngine : public rgw::auth::Engine {
  using result_t = rgw::auth::Engine::result_t;

  CephContext* const cct;
  RGWRados* const store;
  const rgw::auth::TokenExtractor* const extractor;
  const rgw::auth::LocalApplier::Factory* const apl_factory;

  bool is_applicable(const std::string& token) const noexcept;
  result_t authenticate(const DoutPrefixProvider* dpp,
                        const std::string& token,
                        const req_state* s) const;

public:
  ExternalTokenEngine(CephContext* const cct,
                                 RGWRados* const store,
                      const rgw::auth::TokenExtractor* const extractor,
                      const rgw::auth::LocalApplier::Factory* const apl_factory)
    : cct(cct),
      store(store),
      extractor(extractor),
      apl_factory(apl_factory) {
  }

  const char* get_name() const noexcept override {
    return "rgw::auth::swift::ExternalTokenEngine";
  }

  result_t authenticate(const DoutPrefixProvider* dpp, const req_state* const s) const override {
    return authenticate(dpp, extractor->get_token(s), s);
  }
};


class SwiftAnonymousEngine : public rgw::auth::AnonymousEngine {
  const rgw::auth::TokenExtractor* const extractor;

  bool is_applicable(const req_state* s) const noexcept override {
    return extractor->get_token(s).empty();
  }

public:
  SwiftAnonymousEngine(CephContext* const cct,
                       const rgw::auth::LocalApplier::Factory* const apl_factory,
                       const rgw::auth::TokenExtractor* const extractor)
    : AnonymousEngine(cct, apl_factory),
      extractor(extractor) {
  }

  const char* get_name() const noexcept override {
    return "rgw::auth::swift::SwiftAnonymousEngine";
  }
};


class DefaultStrategy : public rgw::auth::Strategy,
                        public rgw::auth::TokenExtractor,
                        public rgw::auth::RemoteApplier::Factory,
                        public rgw::auth::LocalApplier::Factory,
                        public rgw::auth::swift::TempURLApplier::Factory {
  RGWRados* const store;


  const rgw::auth::swift::TempURLEngine tempurl_engine;
  const rgw::auth::swift::SignedTokenEngine signed_engine;
  boost::optional <const rgw::auth::keystone::TokenEngine> keystone_engine;
  const rgw::auth::swift::ExternalTokenEngine external_engine;
  const rgw::auth::swift::SwiftAnonymousEngine anon_engine;

  using keystone_config_t = rgw::keystone::CephCtxConfig;
  using keystone_cache_t = rgw::keystone::TokenCache;
  using aplptr_t = rgw::auth::IdentityApplier::aplptr_t;
  using acl_strategy_t = rgw::auth::RemoteApplier::acl_strategy_t;


  std::string get_token(const req_state* const s) const override {


    return s->info.env->get("HTTP_X_AUTH_TOKEN", "");
  }

  aplptr_t create_apl_remote(CephContext* const cct,
                             const req_state* const s,
                             acl_strategy_t&& extra_acl_strategy,
                             const rgw::auth::RemoteApplier::AuthInfo &info) const override {
    auto apl =
      rgw::auth::add_3rdparty(store, s->account_name,
        rgw::auth::add_sysreq(cct, store, s,
          rgw::auth::RemoteApplier(cct, store, std::move(extra_acl_strategy), info,
                                   cct->_conf->rgw_keystone_implicit_tenants)));

    return aplptr_t(new decltype(apl)(std::move(apl)));
  }

  aplptr_t create_apl_local(CephContext* const cct,
                            const req_state* const s,
                            const RGWUserInfo& user_info,
                            const std::string& subuser,
                            const boost::optional<uint32_t>& perm_mask) const override {
    auto apl =
      rgw::auth::add_3rdparty(store, s->account_name,
        rgw::auth::add_sysreq(cct, store, s,
          rgw::auth::LocalApplier(cct, user_info, subuser, perm_mask)));

    return aplptr_t(new decltype(apl)(std::move(apl)));
  }

  aplptr_t create_apl_turl(CephContext* const cct,
                           const req_state* const s,
                           const RGWUserInfo& user_info) const override {



    return aplptr_t(new rgw::auth::swift::TempURLApplier(cct, user_info));
  }

public:
  DefaultStrategy(CephContext* const cct,
                  RGWRados* const store)
    : store(store),
      tempurl_engine(cct,
                     store,
                     static_cast<rgw::auth::swift::TempURLApplier::Factory*>(this)),
      signed_engine(cct,
                    store,
                    static_cast<rgw::auth::TokenExtractor*>(this),
                    static_cast<rgw::auth::LocalApplier::Factory*>(this)),
      external_engine(cct,
                      store,
                      static_cast<rgw::auth::TokenExtractor*>(this),
                      static_cast<rgw::auth::LocalApplier::Factory*>(this)),
      anon_engine(cct,
                  static_cast<rgw::auth::LocalApplier::Factory*>(this),
                  static_cast<rgw::auth::TokenExtractor*>(this)) {


    using Control = rgw::auth::Strategy::Control;

    add_engine(Control::SUFFICIENT, tempurl_engine);
    add_engine(Control::SUFFICIENT, signed_engine);



    if (! cct->_conf->rgw_keystone_url.empty()) {
      keystone_engine.emplace(cct,
                              static_cast<rgw::auth::TokenExtractor*>(this),
                              static_cast<rgw::auth::RemoteApplier::Factory*>(this),
                              keystone_config_t::get_instance(),
                              keystone_cache_t::get_instance<keystone_config_t>());

      add_engine(Control::SUFFICIENT, *keystone_engine);
    }
    if (! cct->_conf->rgw_swift_auth_url.empty()) {
      add_engine(Control::SUFFICIENT, external_engine);
    }

    add_engine(Control::SUFFICIENT, anon_engine);
  }

  const char* get_name() const noexcept override {
    return "rgw::auth::swift::DefaultStrategy";
  }
};

}
}
}


class RGW_SWIFT_Auth_Get : public RGWOp {
public:
  RGW_SWIFT_Auth_Get() {}
  ~RGW_SWIFT_Auth_Get() override {}

  int verify_permission() override { return 0; }
  void execute() override;
  const char* name() const override { return "swift_auth_get"; }
  dmc::client_id dmclock_client() override { return dmc::client_id::auth; }
};

class RGWHandler_SWIFT_Auth : public RGWHandler_REST {
public:
  RGWHandler_SWIFT_Auth() {}
  ~RGWHandler_SWIFT_Auth() override {}
  RGWOp *op_get() override;

  int init(RGWRados *store, struct req_state *state, rgw::io::BasicClient *cio) override;
  int authorize(const DoutPrefixProvider *dpp) override;
  int postauth_init() override { return 0; }
  int read_permissions(RGWOp *op) override { return 0; }

  virtual RGWAccessControlPolicy *alloc_policy() { return 
# 302 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.h" 3 4
                                                         __null
# 302 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.h"
                                                             ; }
  virtual void free_policy(RGWAccessControlPolicy *policy) {}
};

class RGWRESTMgr_SWIFT_Auth : public RGWRESTMgr {
public:
  RGWRESTMgr_SWIFT_Auth() = default;
  ~RGWRESTMgr_SWIFT_Auth() override = default;

  RGWRESTMgr *get_resource_mgr(struct req_state* const s,
                               const std::string& uri,
                               std::string* const out_uri) override {
    return this;
  }

  RGWHandler_REST* get_handler(struct req_state*,
                               const rgw::auth::StrategyRegistry&,
                               const std::string&) override {
    return new RGWHandler_SWIFT_Auth;
  }
};
# 13 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2





# 1 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/random.h" 1
# 24 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/include/random.h"
namespace ceph::util {

inline namespace version_1_0_2 {

namespace detail {

template <typename T0, typename T1>
using larger_of = typename std::conditional<
                    sizeof(T0) >= sizeof(T1),
                    T0, T1>
                  ::type;


template <typename NumberT0, typename NumberT1>
using has_compatible_numeric_types =
            std::disjunction<
                std::conjunction<
                    std::is_floating_point<NumberT0>, std::is_floating_point<NumberT1>
                >,
                std::conjunction<
                    std::is_integral<NumberT0>, std::is_integral<NumberT1>
                >
            >;



template <typename NumberT0, typename NumberT1>
using select_number_t = std::enable_if_t<detail::has_compatible_numeric_types<NumberT0, NumberT1>::value,
                                         detail::larger_of<NumberT0, NumberT1>>;

}

namespace detail {


template <typename NumberT,
          bool IsIntegral>
struct select_distribution
{
 using type = std::uniform_int_distribution<NumberT>;
};

template <typename NumberT>
struct select_distribution<NumberT, false>
{
 using type = std::uniform_real_distribution<NumberT>;
};

template <typename NumberT>
using default_distribution = typename
    select_distribution<NumberT, std::is_integral<NumberT>::value>::type;

}

namespace detail {

template <typename EngineT>
EngineT& engine();

template <typename MutexT, typename EngineT,
          typename SeedT = typename EngineT::result_type>
void randomize_rng(const SeedT seed, MutexT& m, EngineT& e)
{
  std::lock_guard<MutexT> lg(m);
  e.seed(seed);
}

template <typename MutexT, typename EngineT>
void randomize_rng(MutexT& m, EngineT& e)
{
  std::random_device rd;

  std::lock_guard<MutexT> lg(m);
  e.seed(rd());
}

template <typename EngineT = std::default_random_engine,
          typename SeedT = typename EngineT::result_type>
void randomize_rng(const SeedT n)
{
  detail::engine<EngineT>().seed(n);
}

template <typename EngineT = std::default_random_engine>
void randomize_rng()
{
  std::random_device rd;
  detail::engine<EngineT>().seed(rd());
}

template <typename EngineT>
EngineT& engine()
{
  thread_local boost::optional<EngineT> rng_engine;

  if (!rng_engine) {
    rng_engine.emplace(EngineT());
    randomize_rng<EngineT>();
  }

  return *rng_engine;
}

}

namespace detail {

template <typename NumberT,
          typename DistributionT = detail::default_distribution<NumberT>,
          typename EngineT>
NumberT generate_random_number(const NumberT min, const NumberT max,
                               EngineT& e)
{
  DistributionT d { min, max };

  using param_type = typename DistributionT::param_type;
  return d(e, param_type { min, max });
}

template <typename NumberT,
          typename MutexT,
          typename DistributionT = detail::default_distribution<NumberT>,
          typename EngineT>
NumberT generate_random_number(const NumberT min, const NumberT max,
                               MutexT& m, EngineT& e)
{
  DistributionT d { min, max };

  using param_type = typename DistributionT::param_type;

  std::lock_guard<MutexT> lg(m);
  return d(e, param_type { min, max });
}

template <typename NumberT,
          typename DistributionT = detail::default_distribution<NumberT>,
          typename EngineT>
NumberT generate_random_number(const NumberT min, const NumberT max)
{
  return detail::generate_random_number<NumberT, DistributionT, EngineT>
          (min, max, detail::engine<EngineT>());
}

template <typename MutexT,
          typename EngineT,
          typename NumberT = int,
          typename DistributionT = detail::default_distribution<NumberT>>
NumberT generate_random_number(MutexT& m, EngineT& e)
{
  return detail::generate_random_number<NumberT, MutexT, DistributionT, EngineT>
          (0, std::numeric_limits<NumberT>::max(), m, e);
}

template <typename NumberT, typename MutexT, typename EngineT>
NumberT generate_random_number(const NumberT max, MutexT& m, EngineT& e)
{
  return generate_random_number<NumberT>(0, max, m, e);
}

}

template <typename EngineT = std::default_random_engine>
void randomize_rng()
{
  detail::randomize_rng<EngineT>();
}

template <typename NumberT = int,
          typename DistributionT = detail::default_distribution<NumberT>,
          typename EngineT = std::default_random_engine>
NumberT generate_random_number()
{
  return detail::generate_random_number<NumberT, DistributionT, EngineT>
          (0, std::numeric_limits<NumberT>::max());
}

template <typename NumberT0, typename NumberT1,
          typename NumberT = detail::select_number_t<NumberT0, NumberT1>
         >
NumberT generate_random_number(const NumberT0 min, const NumberT1 max)
{
  return detail::generate_random_number<NumberT,
                                        detail::default_distribution<NumberT>,
                                        std::default_random_engine>
                                       (static_cast<NumberT>(min), static_cast<NumberT>(max));
}

template <typename NumberT0, typename NumberT1,
          typename DistributionT,
          typename EngineT,
          typename NumberT = detail::select_number_t<NumberT0, NumberT1>
   >
NumberT generate_random_number(const NumberT min, const NumberT max,
                               EngineT& e)
{
 return detail::generate_random_number<NumberT,
                       DistributionT,
                       EngineT>(static_cast<NumberT>(min), static_cast<NumberT>(max), e);
}

template <typename NumberT>
NumberT generate_random_number(const NumberT max)
{
 return generate_random_number<NumberT>(0, max);
}


template <typename NumberT>
class random_number_generator final
{
  std::mutex l;
  std::random_device rd;
  std::default_random_engine e;

  using seed_type = typename decltype(e)::result_type;

  public:
  using number_type = NumberT;
  using random_engine_type = decltype(e);
  using random_device_type = decltype(rd);

  public:
  random_device_type& random_device() noexcept { return rd; }
  random_engine_type& random_engine() noexcept { return e; }

  public:
  random_number_generator() {
    detail::randomize_rng(l, e);
  }

  explicit random_number_generator(const seed_type seed) {
    detail::randomize_rng(seed, l, e);
  }

  random_number_generator(random_number_generator&& rhs)
   : e(std::move(rhs.e))
  {}

  public:
  random_number_generator(const random_number_generator&) = delete;
  random_number_generator& operator=(const random_number_generator&) = delete;

  public:
  NumberT operator()() {
    return detail::generate_random_number(l, e);
  }

  NumberT operator()(const NumberT max) {
    return detail::generate_random_number<NumberT>(max, l, e);
  }

  NumberT operator()(const NumberT min, const NumberT max) {
    return detail::generate_random_number<NumberT>(min, max, l, e);
  }

  public:
  void seed(const seed_type n) {
    detail::randomize_rng(n, l, e);
  }
};

}

}
# 19 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 2
# 29 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
using namespace ceph::crypto;


namespace rgw {
namespace auth {
namespace swift {


void TempURLApplier::modify_request_state(const DoutPrefixProvider* dpp, req_state* s) const
{
  bool inline_exists = false;
  const std::string& filename = s->info.args.get("filename");

  s->info.args.get("inline", &inline_exists);
  if (inline_exists) {
    s->content_disp.override = "inline";
  } else if (!filename.empty()) {
    std::string fenc;
    url_encode(filename, fenc);
    s->content_disp.override = "attachment; filename=\"" + fenc + "\"";
  } else {
    std::string fenc;
    url_encode(s->object.name, fenc);
    s->content_disp.fallback = "attachment; filename=\"" + fenc + "\"";
  }

  if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(20)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 20); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 20>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(20, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "finished applying changes to req_state for TempURL: "
                    << " content_disp override " << s->content_disp.override
                    << " content_disp fallback " << s->content_disp.fallback
                    << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);

}


bool TempURLEngine::is_applicable(const req_state* const s) const noexcept
{
  return s->info.args.exists("temp_url_sig") ||
         s->info.args.exists("temp_url_expires");
}

void TempURLEngine::get_owner_info(const DoutPrefixProvider* dpp, const req_state* const s,
                                   RGWUserInfo& owner_info) const
{


  const string& bucket_name = s->init_state.url_bucket;


  if (bucket_name.empty() || s->object.empty()) {
    throw -
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
          1
# 78 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
               ;
  }





  string bucket_tenant;
  if (!s->account_name.empty()) {
    RGWUserInfo uinfo;
    bool found = false;

    const rgw_user uid(s->account_name);
    if (uid.tenant.empty()) {
      const rgw_user tenanted_uid(uid.id, uid.id);

      if (rgw_get_user_info_by_uid(store, tenanted_uid, uinfo) >= 0) {

        bucket_tenant = uinfo.user_id.tenant;
        found = true;
      }
    }

    if (!found && rgw_get_user_info_by_uid(store, uid, uinfo) < 0) {
      throw -
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
            1
# 102 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                 ;
    } else {
      bucket_tenant = uinfo.user_id.tenant;
    }
  }


  RGWBucketInfo bucket_info;
  int ret = store->get_bucket_info(*s->sysobj_ctx,
                                   bucket_tenant, bucket_name,
                                   bucket_info, nullptr);
  if (ret < 0) {
    throw ret;
  }

  if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(20)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 20); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 20>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(20, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "temp url user (bucket owner): " << bucket_info.owner
                 << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);

  if (rgw_get_user_info_by_uid(store, bucket_info.owner, owner_info) < 0) {
    throw -
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
          1
# 121 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
               ;
  }
}

std::string TempURLEngine::convert_from_iso8601(std::string expires) const
{



  struct tm date_t;
  if (!parse_iso8601(expires.c_str(), &date_t, nullptr, true)) {
    return std::move(expires);
  } else {
    return std::to_string(internal_timegm(&date_t));
  }
}

bool TempURLEngine::is_expired(const std::string& expires) const
{
  string err;
  const utime_t now = ceph_clock_now();
  const uint64_t expiration = (uint64_t)strict_strtoll(expires.c_str(),
                                                       10, &err);
  if (!err.empty()) {
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype((5))>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, (5)); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, (5)>()); } }((g_ceph_context)); if (should_gather) { ceph::logging::MutableEntry _dout_e((5), ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*(g_ceph_context)), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = (g_ceph_context); std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "failed to parse temp_url_expires: " << err << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return true;
  }

  if (expiration <= (uint64_t)now.sec()) {
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype((5))>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, (5)); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, (5)>()); } }((g_ceph_context)); if (should_gather) { ceph::logging::MutableEntry _dout_e((5), ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*(g_ceph_context)), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = (g_ceph_context); std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "temp url expired: " << expiration << " <= " << now.sec() << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return true;
  }

  return false;
}

bool TempURLEngine::is_disallowed_header_present(const req_info& info) const
{
  static const auto headers = {
    "HTTP_X_OBJECT_MANIFEST",
  };

  return std::any_of(std::begin(headers), std::end(headers),
                     [&info](const char* header) {
                       return info.env->exists(header);
                     });
}

std::string extract_swift_subuser(const std::string& swift_user_name)
{
  size_t pos = swift_user_name.find(':');
  if (std::string::npos == pos) {
    return swift_user_name;
  } else {
    return swift_user_name.substr(pos + 1);
  }
}

class TempURLEngine::SignatureHelper
{
private:
  static constexpr uint32_t output_size =
    20 * 2 + 1;

  unsigned char dest[20];
  char dest_str[output_size];

public:
  SignatureHelper() = default;

  const char* calc(const std::string& key,
                   const boost::string_view& method,
                   const boost::string_view& path,
                   const std::string& expires) {

    using ceph::crypto::HMACSHA1;
    using UCHARPTR = const unsigned char*;

    HMACSHA1 hmac((UCHARPTR) key.c_str(), key.size());
    hmac.Update((UCHARPTR) method.data(), method.size());
    hmac.Update((UCHARPTR) "\n", 1);
    hmac.Update((UCHARPTR) expires.c_str(), expires.size());
    hmac.Update((UCHARPTR) "\n", 1);
    hmac.Update((UCHARPTR) path.data(), path.size());
    hmac.Final(dest);

    buf_to_hex((UCHARPTR) dest, sizeof(dest), dest_str);

    return dest_str;
  }

  bool is_equal_to(const std::string& rhs) const {

    if (rhs.size() < (output_size - 1)) {
      return false;
    }
    return rhs.compare(0 , output_size, dest_str) == 0;
  }

};

class TempURLEngine::PrefixableSignatureHelper
    : private TempURLEngine::SignatureHelper {
  using base_t = SignatureHelper;

  const boost::string_view decoded_uri;
  const boost::string_view object_name;
  boost::string_view no_obj_uri;

  const boost::optional<const std::string&> prefix;

public:
  PrefixableSignatureHelper(const std::string& _decoded_uri,
                     const std::string& object_name,
                            const boost::optional<const std::string&> prefix)
    : decoded_uri(_decoded_uri),
      object_name(object_name),
      prefix(prefix) {





    no_obj_uri =
      decoded_uri.substr(0, decoded_uri.length() - object_name.length());
  }

  const char* calc(const std::string& key,
                   const boost::string_view& method,
                   const boost::string_view& path,
                   const std::string& expires) {
    if (!prefix) {
      return base_t::calc(key, method, path, expires);
    } else {
      const auto prefixed_path =
        string_cat_reserve("prefix:", no_obj_uri, *prefix);
      return base_t::calc(key, method, prefixed_path, expires);
    }
  }

  bool is_equal_to(const std::string& rhs) const {
    bool is_auth_ok = base_t::is_equal_to(rhs);

    if (prefix && is_auth_ok) {
      const auto prefix_uri = string_cat_reserve(no_obj_uri, *prefix);
      is_auth_ok = boost::algorithm::starts_with(decoded_uri, prefix_uri);
    }

    return is_auth_ok;
  }
};

TempURLEngine::result_t
TempURLEngine::authenticate(const DoutPrefixProvider* dpp, const req_state* const s) const
{
  if (! is_applicable(s)) {
    return result_t::deny();
  }




  const std::string& temp_url_sig = s->info.args.get("temp_url_sig");
  const std::string& temp_url_expires =
    convert_from_iso8601(s->info.args.get("temp_url_expires"));

  if (temp_url_sig.empty() || temp_url_expires.empty()) {
    return result_t::deny();
  }




  const boost::optional<const std::string&> temp_url_prefix =
    s->info.args.get_optional("temp_url_prefix");

  RGWUserInfo owner_info;
  try {
    get_owner_info(dpp, s, owner_info);
  } catch (...) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(5)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 5); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 5>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(5, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "cannot get user_info of account's owner" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return result_t::reject();
  }

  if (owner_info.temp_url_keys.empty()) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(5)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 5); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 5>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(5, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "user does not have temp url key set, aborting" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return result_t::reject();
  }

  if (is_expired(temp_url_expires)) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(5)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 5); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 5>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(5, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "temp url link expired" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return result_t::reject(-
# 312 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                            1
# 312 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                                 );
  }

  if (is_disallowed_header_present(s->info)) {
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype(5)>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, 5); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, 5>()); } }(cct); if (should_gather) { ceph::logging::MutableEntry _dout_e(5, ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*cct), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = cct; std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "temp url rejected due to disallowed header" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return result_t::reject(-
# 317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                            22
# 317 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                                  );
  }






  const size_t pos = g_conf()->rgw_swift_url_prefix.find_last_not_of('/') + 1;
  const boost::string_view ref_uri = s->decoded_uri;
  const std::array<boost::string_view, 2> allowed_paths = {
    ref_uri,
    ref_uri.substr(pos + 1)
  };


  boost::container::static_vector<boost::string_view, 3> allowed_methods;
  if (strcmp("HEAD", s->info.method) == 0) {





    allowed_methods.emplace_back("HEAD");
    allowed_methods.emplace_back("GET");
    allowed_methods.emplace_back("PUT");
  } else if (strlen(s->info.method) > 0) {
    allowed_methods.emplace_back(s->info.method);
  }


  PrefixableSignatureHelper sig_helper {
    s->decoded_uri,
    s->object.name,
    temp_url_prefix
  };

  for (const auto& kv : owner_info.temp_url_keys) {
    const int temp_url_key_num = kv.first;
    const string& temp_url_key = kv.second;

    if (temp_url_key.empty()) {
      continue;
    }

    for (const auto& path : allowed_paths) {
      for (const auto& method : allowed_methods) {
        const char* const local_sig = sig_helper.calc(temp_url_key, method,
                                                      path, temp_url_expires);

        if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(20)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 20); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 20>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(20, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "temp url signature [" << temp_url_key_num
                          << "] (calculated): " << local_sig
                          << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);

        if (sig_helper.is_equal_to(temp_url_sig)) {
          auto apl = apl_factory->create_apl_turl(cct, s, owner_info);
          return result_t::grant(std::move(apl));
        } else {
          if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(5)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 5); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 5>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(5, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "temp url signature mismatch: " << local_sig
                            << " != " << temp_url_sig << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
        }
      }
    }
  }

  return result_t::reject();
}



bool ExternalTokenEngine::is_applicable(const std::string& token) const noexcept
{
  if (token.empty()) {
    return false;
  } else if (g_conf()->rgw_swift_auth_url.empty()) {
    return false;
  } else {
    return true;
  }
}

ExternalTokenEngine::result_t
ExternalTokenEngine::authenticate(const DoutPrefixProvider* dpp,
                                  const std::string& token,
                                  const req_state* const s) const
{
  if (! is_applicable(token)) {
    return result_t::deny();
  }

  std::string auth_url = g_conf()->rgw_swift_auth_url;
  if (auth_url.back() != '/') {
    auth_url.append("/");
  }

  auth_url.append("token");
  char url_buf[auth_url.size() + 1 + token.length() + 1];
  sprintf(url_buf, "%s/%s", auth_url.c_str(), token.c_str());

  RGWHTTPHeadersCollector validator(cct, "GET", url_buf, { "X-Auth-Groups", "X-Auth-Ttl" });

  if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 10); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 10>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "rgw_swift_validate_token url=" << url_buf << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);

  int ret = validator.process();
  if (ret < 0) {
    throw ret;
  }

  std::string swift_user;
  try {
    std::vector<std::string> swift_groups;
    get_str_vec(validator.get_header_value("X-Auth-Groups"),
                ",", swift_groups);

    if (0 == swift_groups.size()) {
      return result_t::deny(-
# 432 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                            1
# 432 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                                 );
    } else {
      swift_user = std::move(swift_groups[0]);
    }
  } catch (const std::out_of_range&) {

    return result_t::deny(-
# 438 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                          1
# 438 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                               );
  }

  if (swift_user.empty()) {
    return result_t::deny(-
# 442 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                          1
# 442 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                               );
  }

  if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 10); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 10>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "swift user=" << swift_user << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);

  RGWUserInfo tmp_uinfo;
  ret = rgw_get_user_info_by_swift(store, swift_user, tmp_uinfo);
  if (ret < 0) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(0)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 0); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 0>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(0, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "NOTICE: couldn't map swift user" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    throw ret;
  }

  auto apl = apl_factory->create_apl_local(cct, s, tmp_uinfo,
                                           extract_swift_subuser(swift_user),
                                           boost::none);
  return result_t::grant(std::move(apl));
}

static int build_token(const string& swift_user,
                       const string& key,
                       const uint64_t nonce,
                       const utime_t& expiration,
                       bufferlist& bl)
{
  using ceph::encode;
  encode(swift_user, bl);
  encode(nonce, bl);
  encode(expiration, bl);

  bufferptr p(20);

  char buf[bl.length() * 2 + 1];
  buf_to_hex((const unsigned char *)bl.c_str(), bl.length(), buf);
  do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype((20))>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, (20)); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, (20)>()); } }((g_ceph_context)); if (should_gather) { ceph::logging::MutableEntry _dout_e((20), ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*(g_ceph_context)), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = (g_ceph_context); std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "build_token token=" << buf << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);

  char k[20];
  memset(k, 0, sizeof(k));
  const char *s = key.c_str();
  for (int i = 0; i < (int)key.length(); i++, s++) {
    k[i % 20] |= *s;
  }
  calc_hmac_sha1(k, sizeof(k), bl.c_str(), bl.length(), p.c_str());

  bl.append(p);

  return 0;

}

static int encode_token(CephContext *cct, string& swift_user, string& key,
   bufferlist& bl)
{
  const auto nonce = ceph::util::generate_random_number<uint64_t>();

  utime_t expiration = ceph_clock_now();
  expiration += cct->_conf->rgw_swift_token_expiration;

  return build_token(swift_user, key, nonce, expiration, bl);
}



bool SignedTokenEngine::is_applicable(const std::string& token) const noexcept
{
  if (token.empty()) {
    return false;
  } else {
    return token.compare(0, 10, "AUTH_rgwtk") == 0;
  }
}

SignedTokenEngine::result_t
SignedTokenEngine::authenticate(const DoutPrefixProvider* dpp,
                                const std::string& token,
                                const req_state* const s) const
{
  if (! is_applicable(token)) {
    return result_t::deny(-
# 519 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                          1
# 519 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                               );
  }


  const std::string etoken = token.substr(strlen("AUTH_rgwtk"));
  const size_t etoken_len = etoken.length();

  if (etoken_len & 1) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(0)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 0); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 0>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(0, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "NOTICE: failed to verify token: odd token length="
           << etoken_len << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    throw -
# 529 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
          22
# 529 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                ;
  }

  ceph::bufferptr p(etoken_len/2);
  int ret = hex_to_buf(etoken.c_str(), p.c_str(), etoken_len);
  if (ret < 0) {
    throw ret;
  }

  ceph::bufferlist tok_bl;
  tok_bl.append(p);

  uint64_t nonce;
  utime_t expiration;
  std::string swift_user;

  try {
    auto iter = tok_bl.cbegin();

    using ceph::decode;
    decode(swift_user, iter);
    decode(nonce, iter);
    decode(expiration, iter);
  } catch (buffer::error& err) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(0)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 0); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 0>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(0, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "NOTICE: failed to decode token" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    throw -
# 554 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
          22
# 554 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                ;
  }

  const utime_t now = ceph_clock_now();
  if (expiration < now) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(0)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 0); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 0>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(0, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "NOTICE: old timed out token was used now=" << now
           << " token.expiration=" << expiration
                  << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return result_t::deny(-
# 562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                          1
# 562 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                               );
  }

  RGWUserInfo user_info;
  ret = rgw_get_user_info_by_swift(store, swift_user, user_info);
  if (ret < 0) {
    throw ret;
  }

  if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(10)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 10); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 10>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(10, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "swift_user=" << swift_user << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);

  const auto siter = user_info.swift_keys.find(swift_user);
  if (siter == std::end(user_info.swift_keys)) {
    return result_t::deny(-
# 575 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                          1
# 575 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                               );
  }

  const auto swift_key = siter->second;

  bufferlist local_tok_bl;
  ret = build_token(swift_user, swift_key.key, nonce, expiration, local_tok_bl);
  if (ret < 0) {
    throw ret;
  }

  if (local_tok_bl.length() != tok_bl.length()) {
    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(0)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 0); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 0>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(0, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "NOTICE: tokens length mismatch:"
                  << " tok_bl.length()=" << tok_bl.length()
           << " local_tok_bl.length()=" << local_tok_bl.length()
                  << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return result_t::deny(-
# 591 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                          1
# 591 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                               );
  }

  if (memcmp(local_tok_bl.c_str(), tok_bl.c_str(),
             local_tok_bl.length()) != 0) {
    char buf[local_tok_bl.length() * 2 + 1];

    buf_to_hex(reinterpret_cast<const unsigned char *>(local_tok_bl.c_str()),
               local_tok_bl.length(), buf);

    if (decltype(auto) pdpp = (dpp); pdpp) do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph::dout::need_dynamic(pdpp->get_subsys()))>::value || ceph::dout::is_dynamic<decltype(0)>::value) { return cctX->_conf->subsys.should_gather(ceph::dout::need_dynamic(pdpp->get_subsys()), 0); } else { return (cctX->_conf->subsys.template should_gather<ceph::dout::need_dynamic(pdpp->get_subsys()), 0>()); } }(pdpp->get_cct()); if (should_gather) { ceph::logging::MutableEntry _dout_e(0, ceph::dout::need_dynamic(pdpp->get_subsys())); static_assert(std::is_convertible<decltype(&*pdpp->get_cct()), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = pdpp->get_cct(); std::ostream* _dout = &_dout_e.get_ostream(); pdpp->gen_prefix(*_dout) << "NOTICE: tokens mismatch tok=" << buf << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    return result_t::deny(-
# 602 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
                          1
# 602 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                               );
  }

  auto apl = apl_factory->create_apl_local(cct, s, user_info,
                                           extract_swift_subuser(swift_user),
                                           boost::none);
  return result_t::grant(std::move(apl));
}

}
}
}


void RGW_SWIFT_Auth_Get::execute()
{
  int ret = -
# 618 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
            1
# 618 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                 ;

  const char *key = s->info.env->get("HTTP_X_AUTH_KEY");
  const char *user = s->info.env->get("HTTP_X_AUTH_USER");

  s->prot_flags |= 0x1;

  string user_str;
  RGWUserInfo info;
  bufferlist bl;
  RGWAccessKey *swift_key;
  map<string, RGWAccessKey>::iterator siter;

  string swift_url = g_conf()->rgw_swift_url;
  string swift_prefix = g_conf()->rgw_swift_url_prefix;
  string tenant_path;







  if (swift_prefix.size() == 0) {
    swift_prefix = "/swift";
  } else if (swift_prefix == "/") {
    swift_prefix.clear();
  } else {
    if (swift_prefix[0] != '/') {
      swift_prefix.insert(0, "/");
    }
  }

  if (swift_url.size() == 0) {
    bool add_port = false;
    const char *server_port = s->info.env->get("SERVER_PORT_SECURE");
    const char *protocol;
    if (server_port) {
      add_port = (strcmp(server_port, "443") != 0);
      protocol = "https";
    } else {
      server_port = s->info.env->get("SERVER_PORT");
      add_port = (strcmp(server_port, "80") != 0);
      protocol = "http";
    }
    const char *host = s->info.env->get("HTTP_HOST");
    if (!host) {
      do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype((0))>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, (0)); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, (0)>()); } }((g_ceph_context)); if (should_gather) { ceph::logging::MutableEntry _dout_e((0), ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*(g_ceph_context)), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = (g_ceph_context); std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "NOTICE: server is misconfigured, missing rgw_swift_url_prefix or rgw_swift_url, HTTP_HOST is not set" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
      ret = -
# 666 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
            22
# 666 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                  ;
      goto done;
    }
    swift_url = protocol;
    swift_url.append("://");
    swift_url.append(host);
    if (add_port && !strchr(host, ':')) {
      swift_url.append(":");
      swift_url.append(server_port);
    }
  }

  if (!key || !user)
    goto done;

  user_str = user;

  if ((ret = rgw_get_user_info_by_swift(store, user_str, info)) < 0)
  {
    ret = -
# 685 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
          13
# 685 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
                ;
    goto done;
  }

  siter = info.swift_keys.find(user_str);
  if (siter == info.swift_keys.end()) {
    ret = -
# 691 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
          1
# 691 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
               ;
    goto done;
  }
  swift_key = &siter->second;

  if (swift_key->key.compare(key) != 0) {
    do { const bool should_gather = [&](const auto cctX) { if constexpr (ceph::dout::is_dynamic<decltype(ceph_subsys_rgw)>::value || ceph::dout::is_dynamic<decltype((0))>::value) { return cctX->_conf->subsys.should_gather(ceph_subsys_rgw, (0)); } else { return (cctX->_conf->subsys.template should_gather<ceph_subsys_rgw, (0)>()); } }((g_ceph_context)); if (should_gather) { ceph::logging::MutableEntry _dout_e((0), ceph_subsys_rgw); static_assert(std::is_convertible<decltype(&*(g_ceph_context)), CephContext* >::value, "provided cct must be compatible with CephContext*"); auto _dout_cct = (g_ceph_context); std::ostream* _dout = &_dout_e.get_ostream(); *_dout << "NOTICE: RGW_SWIFT_Auth_Get::execute(): bad swift key" << std::flush; _dout_cct->_log->submit_entry(std::move(_dout_e)); } } while (0);
    ret = -
# 698 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc" 3 4
          1
# 698 "/home/kkeithle/rpmbuild/BUILD/ceph-14.2.6/src/rgw/rgw_swift_auth.cc"
               ;
    goto done;
  }

  if (!g_conf()->rgw_swift_tenant_name.empty()) {
    tenant_path = "/AUTH_";
    tenant_path.append(g_conf()->rgw_swift_tenant_name);
  } else if (g_conf()->rgw_swift_account_in_url) {
    tenant_path = "/AUTH_";
    tenant_path.append(info.user_id.to_str());
  }

  dump_header(s, "X-Storage-Url", swift_url + swift_prefix + "/v1" +
              tenant_path);

  using rgw::auth::swift::encode_token;
  if ((ret = encode_token(s->cct, swift_key->id, swift_key->key, bl)) < 0)
    goto done;

  {
    static constexpr size_t PREFIX_LEN = sizeof("AUTH_rgwtk") - 1;
    char token_val[PREFIX_LEN + bl.length() * 2 + 1];

    snprintf(token_val, PREFIX_LEN + 1, "AUTH_rgwtk");
    buf_to_hex((const unsigned char *)bl.c_str(), bl.length(),
        token_val + PREFIX_LEN);

    dump_header(s, "X-Storage-Token", token_val);
    dump_header(s, "X-Auth-Token", token_val);
  }

  ret = 1902;

done:
  set_req_state_err(s, ret);
  dump_errno(s);
  end_header(s);
}

int RGWHandler_SWIFT_Auth::init(RGWRados *store, struct req_state *state,
    rgw::io::BasicClient *cio)
{
  state->dialect = "swift-auth";
  state->formatter = new JSONFormatter;
  state->format = 2;

  return RGWHandler::init(store, state, cio);
}

int RGWHandler_SWIFT_Auth::authorize(const DoutPrefixProvider *dpp)
{
  return 0;
}

RGWOp *RGWHandler_SWIFT_Auth::op_get()
{
  return new RGW_SWIFT_Auth_Get;
}